'use client';

import { createContext, useContext, useEffect, useState } from "react";
import { useRouter } from "next/navigation";
import { getCurrentUser } from "../api/auth";

interface User {
    id: number;
    nom: string;
    prenom: string;
    email: string;
    role: string;
}

interface AuthContextType {
    user: User | null;
    token: string | null;
    loading: boolean;
    isAuthenticated: boolean;
    isAdmin: boolean;
    loginUser: (data: any) => void;
    logoutUser: () => void;
}

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

export function AuthProvider({ children }: { children: React.ReactNode; }) {
    const router = useRouter();
    const [user, setUser] = useState<User | null>(null);

    const [token, setToken] = useState<string | null>(null);

    const [loading, setLoading] = useState(true);

    useEffect(() => {
        const storedToken = localStorage.getItem("token");

        if (storedToken) {
            setToken(storedToken);
        }
        else {
            setLoading(false);
        }
    }, []);

    useEffect(() => {
        if (!token) return;

        const loadUser = async () => {
            try {
                const freshUser = await getCurrentUser();
                setUser(freshUser);

                localStorage.setItem("user", JSON.stringify(freshUser));
            }
            catch (error) {
                logoutUser();
            }
            finally {
                setLoading(false);
            }
        };
        loadUser();
    }, [token]);

    useEffect(() => {
        if (!token) return;
        const interval = setInterval(async () => {
            try {
                const freshUser = await getCurrentUser();
                setUser(freshUser);
                localStorage.setItem("user", JSON.stringify(freshUser));
            } catch (error) {
                logoutUser();
            }
        }, 60000);
        setLoading(false);
        return () => clearInterval(interval);
    }, [token]);

    const loginUser = async (data: any) => {
        localStorage.setItem("token", data.access_token);
        setToken(data.access_token);

        const freshUser = await getCurrentUser();

        localStorage.setItem("user", JSON.stringify(freshUser));

        setUser(freshUser);
    };

    const logoutUser = () => {
        localStorage.removeItem("token");
        localStorage.removeItem("user");

        setUser(null);
        setToken(null);

        router.push("/login");
    };

    return (
        <AuthContext.Provider
            value={{
                user, token,
                loading,
                isAuthenticated: !!token,
                isAdmin: user?.role === "ADMIN",
                loginUser, logoutUser
            }}
        >
            {children}
        </AuthContext.Provider>
    );
}

export function useAuth() {
    const context = useContext(AuthContext);

    if (!context) {
        throw new Error(
            "useAuth must be used within AuthProvider"
        );
    }

    return context;
}