import React, { createContext, useContext, useState, useEffect } from "react";
import { supabase } from "@/integrations/supabase/client";
import { useUserProfile, Profile } from "@/hooks/useUserProfile";
import { login, logout } from "@/services/auth";
import type { LoginResult } from "@/services/auth/loginService";

interface AuthContextType {
  currentUser: Profile | null;
  login: (email: string, password: string) => Promise<LoginResult>;
  logout: () => Promise<void>;
  isAuthenticated: boolean;
  isLoading: boolean;
}

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

export function AuthProvider({ children }: { children: React.ReactNode }) {
  const { currentUser, setCurrentUser, loadUserProfile } = useUserProfile();
  const [isLoading, setIsLoading] = useState(true);

  useEffect(() => {
    console.info('🔄 Initialisation du contexte d\'authentification');

    const { data: { subscription } } = supabase.auth.onAuthStateChange(
      async (event, session) => {
        console.group(`🔐 Changement d'état d'authentification: ${event}`);
        console.info('Session présente:', !!session);

        setIsLoading(true);
        if (session?.user) {
          console.info('Utilisateur authentifié:', {
            id: session.user.id,
            email: session.user.email
          });

          // Use setTimeout to prevent auth state change deadlocks
          setTimeout(async () => {
            await loadUserProfile(session.user.id);
            setIsLoading(false);
          }, 0);
        } else {
          console.info('Aucun utilisateur authentifié');
          setCurrentUser(null);
          setIsLoading(false);
        }
        console.groupEnd();
      }
    );

    supabase.auth.getSession().then(async ({ data: { session } }) => {
      console.info('🔍 Vérification de la session existante:', !!session);
      if (session?.user) {
        await loadUserProfile(session.user.id);
      }
      setIsLoading(false);
    });

    return () => subscription.unsubscribe();
  }, [loadUserProfile, setCurrentUser]);

  const handleLogin = async (email: string, password: string): Promise<LoginResult> => {
    return login(email, password);
  };

  const handleLogout = async () => {
    await logout();
    setCurrentUser(null);
  };

  return (
    <AuthContext.Provider
      value={{
        currentUser,
        login: handleLogin,
        logout: handleLogout,
        isAuthenticated: !!currentUser,
        isLoading,
      }}
    >
      {children}
    </AuthContext.Provider>
  );
}

export function useAuth() {
  const context = useContext(AuthContext);
  if (context === undefined) {
    throw new Error("useAuth doit être utilisé au sein d'un AuthProvider");
  }
  return context;
}