// AuthContext.tsx - Context pour gérer l'authentification
import React, { createContext, useContext, useState, useEffect } from 'react';
import type { User } from './types';

interface AuthContextType {
    user: User | null;
    login: (user: User) => void;
    logout: () => void;
    isAuthenticated: boolean;
    isRRE: boolean;
    isFormateur: boolean;
    hasPermission: (permission: keyof User['permissions']) => boolean;
}

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

export const AuthProvider: React.FC<{ children: React.ReactNode }> = ({ children }) => {
    // ✅ Initialisation lazy pour éviter les problèmes HMR
    const [user, setUser] = useState<User | null>(() => {
        if (typeof window === 'undefined') return null;

        try {
            const storedUser = localStorage.getItem('user');
            return storedUser ? JSON.parse(storedUser) : null;
        } catch (error) {
            console.error('Erreur lors de la lecture du localStorage:', error);
            return null;
        }
    });

    // ✅ Synchronisation avec localStorage quand user change
    useEffect(() => {
        if (user) {
            try {
                localStorage.setItem('user', JSON.stringify(user));
            } catch (error) {
                console.error('Erreur lors de l\'écriture dans localStorage:', error);
            }
        }
    }, [user]);

    const login = (userData: User) => {
        setUser(userData);
        try {
            localStorage.setItem('user', JSON.stringify(userData));
        } catch (error) {
            console.error('Erreur lors de la sauvegarde de l\'utilisateur:', error);
        }
    };

    const logout = () => {
        setUser(null);
        try {
            localStorage.removeItem('user');
            localStorage.removeItem('accessToken');
        } catch (error) {
            console.error('Erreur lors de la déconnexion:', error);
        }
    };

    const hasPermission = (permission: keyof User['permissions']) => {
        return user?.permissions?.[permission] || false;
    };

    // ✅ Mémoïsation de la valeur du context pour éviter les re-renders inutiles
    const value = React.useMemo(() => ({
        user,
        login,
        logout,
        isAuthenticated: !!user,
        isRRE: user?.role === 'rre',
        isFormateur: user?.role === 'formateur',
        hasPermission
    }), [user]);

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

export const useAuth = () => {
    const context = useContext(AuthContext);
    if (!context) {
        throw new Error('useAuth doit être utilisé dans un AuthProvider');
    }
    return context;
};