import React, {

  createContext,

  useCallback,

  useContext,

  useEffect,

  useMemo,

  useState,

} from "react";

import { apiClient, User } from "@/lib/api";

import { queryClient, storage } from "@/lib/queryClient";

import { AuthStatus, deriveStatus } from "@/context/authRouting";

interface AuthProviderProps {

  children: React.ReactNode;

}

interface SignUpInput {

  firstName: string;

  lastName?: string;

  email: string;

  password: string;

  acceptedTerms: boolean;

}

interface AuthContextType {

  user: User | null;

  status: AuthStatus;

  isLoading: boolean;

  updateAuthUser: (user: User) => void;

  login: (email: string, password: string) => Promise<{ user: User } | null>;

  signup: (userData: SignUpInput) => Promise<void>;

  logout: () => Promise<void>;

  forgotPassword: (email: string) => Promise<{ success: boolean }>;

  resetPassword: (token: string, password: string) => Promise<void>;

  activate: (code: string) => Promise<void>;

  requestActivateCode: () => Promise<void>;

  completeOnboarding: () => Promise<void>;

}

const AuthContext = createContext<AuthContextType | null>(null);

export function useAuth() {

  const context = useContext(AuthContext);

  if (!context) {

    throw new Error("useAuth must be used within an AuthProvider");

  }

  return context;

}

export const AuthProvider = ({ children }: AuthProviderProps) => {

  const [user, setUser] = useState<User | null>(null);

  const [isLoading, setIsLoading] = useState(true);

  const status = deriveStatus(isLoading, user);

  const logout = useCallback(async () => {

    setIsLoading(true);

    try {

      await apiClient.logout();

      setUser(null);

      // Clear both the in-memory cache and the persisted MMKV cache

      queryClient.clear();

      storage.clearAll();

    } finally {

      setIsLoading(false);

    }

  }, []);

  const checkAuthState = useCallback(async () => {

    const doAuthCheck = async () => {

      const { token } = await apiClient.getStoredAuthData();

      if (token) {

        const { user } = await apiClient.getMe();

        setUser(user);

      }

    };

    const timeout = new Promise<never>((_, reject) =>

      setTimeout(() => reject(new Error("Auth check timed out")), 10_000),

    );

    try {

      await Promise.race([doAuthCheck(), timeout]);

    } catch (error) {

      console.error("Auth check failed:", error);

      await apiClient.logout();

    } finally {

      setIsLoading(false);

    }

  }, []);

  useEffect(() => {

    checkAuthState();

  }, [checkAuthState]);

  useEffect(() => {

    apiClient.registerUnauthorizedHandler(logout);

  }, [logout]);

  const login = useCallback(async (email: string, password: string) => {

    const response = await apiClient.login(email, password);

    if (response.user) {

      setUser(response.user);

    }

    return response;

  }, []);

  const signup = useCallback(async (userData: SignUpInput) => {

    const response = await apiClient.signup(userData);

    if (response.user) {

      setUser(response.user);

    }

  }, []);

  const forgotPassword = useCallback(

    (email: string) => apiClient.forgotPassword(email),

    [],

  );

  const resetPassword = useCallback(async (token: string, password: string) => {

    await apiClient.resetPassword(token, password);

  }, []);

  const activate = useCallback(async (code: string) => {

    const response = await apiClient.activate(code);

    setUser(response.user);

  }, []);

  const requestActivateCode = useCallback(

    () => apiClient.requestActivateCode(),

    [],

  );

  const completeOnboarding = useCallback(async () => {

    const { user } = await apiClient.completeOnboarding();

    setUser(user);

  }, []);

  const updateAuthUser = useCallback((user: User) => {

    setUser(user);

  }, []);

  const value = useMemo<AuthContextType>(

    () => ({

      user,

      status,

      isLoading,

      login,

      signup,

      logout,

      forgotPassword,

      resetPassword,

      updateAuthUser,

      activate,

      requestActivateCode,

      completeOnboarding,

    }),

    [

      user,

      status,

      isLoading,

      login,

      signup,

      logout,

      forgotPassword,

      resetPassword,

      updateAuthUser,

      activate,

      requestActivateCode,

      completeOnboarding,

    ],

  );

  return <AuthContext.Provider value={value}>{children}</AuthContext.Provider>;

};