'use client';
import * as React from 'react';
import type { User } from '@/types/user';
// import { authClient } from '@/lib/auth/client';
// import { logger } from '@/lib/default-logger';

export interface UserContextValue {
  user: User | null;
  error: string | null;
  isLoading: boolean;
  setUser: React.Dispatch<React.SetStateAction<User | null>>;
  checkSession?: () => Promise<void>;
}

export const UserContext = React.createContext<UserContextValue | undefined>(undefined);

export interface UserProviderProps {
  children: React.ReactNode;
}

export function UserProvider({ children }: UserProviderProps): React.JSX.Element {
  const [state, setState] = React.useState<{
    user: User | null;
    error: string | null;
    isLoading: boolean;
  }>({
    user: null,
    error: null,
    isLoading: true, // Start with isLoading true
  });

  const setUser = React.useCallback(
    (userOrFn: React.SetStateAction<User | null>) => {
      setState((prevState) => ({
        ...prevState,
        user: typeof userOrFn === 'function' ? userOrFn(prevState.user) : userOrFn,
      }));
    },
    [setState]
  );

  // const checkSession = React.useCallback(async (): Promise<void> => {
  //   try {
  //     const { data, error } = await authClient.getUser();

  //     if (error) {
  //       logger.error(error);
  //       setState((prev) => ({ ...prev, user: null, error: 'Something went wrong', isLoading: false }));
  //       return;
  //     }

  //     setState((prev) => ({ ...prev, user: data ?? null, error: null, isLoading: false }));
  //   } catch (err) {
  //     logger.error(err);
  //     setState((prev) => ({ ...prev, user: null, error: 'Something went wrong', isLoading: false }));
  //   } finally {
  //     setState((prev) => ({ ...prev, isLoading: false })); // Ensure loading is set to false
  //   }
  // }, []);

  const checkSession = React.useCallback(async (): Promise<void> => {
    try {
      const stored = localStorage.getItem('user');
  
      if (stored) {
        const parsed = JSON.parse(stored) as { user: User; expiry: number };
        const now = Date.now();
  
        if (parsed.expiry && parsed.expiry > now) {
          setState((prev) => ({
            ...prev,
            user: parsed.user,
            error: null,
            isLoading: false,
          }));
  
          // Optional: Set a timeout to auto-logout when expired
          const timeout = parsed.expiry - now;
          setTimeout(() => {
            localStorage.removeItem('user');
            setState((prev) => ({
              ...prev,
              user: null,
              error: null,
              isLoading: false,
            }));
          }, timeout);
        } else {
          localStorage.removeItem('user');
          setState((prev) => ({
            ...prev,
            user: null,
            error: null,
            isLoading: false,
          }));
        }
      } else {
        setState((prev) => ({
          ...prev,
          user: null,
          error: null,
          isLoading: false,
        }));
      }
    } catch (err) {
      // console.error('Failed to parse user from localStorage', err);
      setState((prev) => ({
        ...prev,
        user: null,
        error: 'Failed to load user',
        isLoading: false,
      }));
    }
  }, []);
  

  // React.useEffect(() => {
  //   checkSession().catch((err: unknown) => {
  //     logger.error(err);
  //     setState((prev) => ({ ...prev, isLoading: false })); // Ensure loading is false even on error
  //   });
  //   // eslint-disable-next-line react-hooks/exhaustive-deps
  // }, [checkSession]);
  React.useEffect(() => {
    // Use void operator to explicitly ignore the Promise and satisfy eslint
    void checkSession();
  }, [checkSession]);
  

  const contextValue: UserContextValue = {
    user: state.user,
    error: state.error,
    isLoading: state.isLoading,
    setUser: setUser,
    checkSession,
  };

  return (
    <UserContext.Provider value={contextValue}>
      {children}
    </UserContext.Provider>
  );
}

export const UserConsumer = UserContext.Consumer;