"use client";

import React, { createContext, useContext, useState, useEffect, useCallback, ReactNode } from 'react';
import { login as apiLogin, logout as apiLogout, getCurrentUser, AuthClient, LoginCredentials, AuthError } from '@/lib/api';

interface AuthContextType {
    user: AuthClient | null;
    token: string | null;
    isLoading: boolean;
    isAuthenticated: boolean;
    login: (credentials: LoginCredentials) => Promise<void>;
    logout: () => Promise<void>;
    refreshUser: () => Promise<void>;
    updateUser: (data: Partial<AuthClient>) => void;
    error: AuthError | null;
    clearError: () => void;
}

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

const TOKEN_KEY = 'amtar_auth_token';
const USER_KEY = 'amtar_auth_user';

export function AuthProvider({ children }: { children: ReactNode }) {
    const [user, setUser] = useState<AuthClient | null>(null);
    const [token, setToken] = useState<string | null>(null);
    const [isLoading, setIsLoading] = useState(false);
    const [error, setError] = useState<AuthError | null>(null);

    // Initialize auth state from localStorage on mount
    useEffect(() => {
       const initAuth = async () => {
    try {

        localStorage.removeItem(TOKEN_KEY);
        localStorage.removeItem(USER_KEY);

        const storedToken = localStorage.getItem(TOKEN_KEY);
        const storedUser = localStorage.getItem(USER_KEY);


                console.log('Auth Init: Checking storage', { hasToken: !!storedToken, hasUser: !!storedUser });

                if (storedToken && storedUser) {
                    setToken(storedToken);
                    try {
                        setUser(JSON.parse(storedUser));
                    } catch (e) {
                        console.error('Auth Init: Failed to parse user from localStorage', e);
                        // Continue validation - the token might still be valid
                    }

                    // Verify token is still valid
                    console.log('Auth Init: Verifying token with backend...');
                    const currentUser = await getCurrentUser(storedToken);
                    console.log('Auth Init: Verification result', currentUser);

                    if (currentUser) {
                        setUser(currentUser);
                        localStorage.setItem(USER_KEY, JSON.stringify(currentUser));
                    } else {
                        console.warn('Auth Init: Token verification failed. Logging out.');
                        // Token invalid or server error, clear everything
                        localStorage.removeItem(amtar_auth_token);
                        localStorage.removeItem(amtar_auth_user);
                        setToken(null);
                        setUser(null);
                    }
                }
            } catch (err) {
                console.error('Failed to initialize auth:', err);
                localStorage.removeItem(TOKEN_KEY);
                localStorage.removeItem(USER_KEY);
            } finally {
                setIsLoading(false);
            }
        };

        initAuth();
    }, []);

    const login = useCallback(async (credentials: LoginCredentials) => {
        setIsLoading(true);
        setError(null);

        try {
            const response = await apiLogin(credentials);

            // Store token and user in localStorage
localStorage.setItem(TOKEN_KEY, response.token);

document.cookie = `amtar_auth_token=${response.token}; path=/`;

localStorage.setItem(USER_KEY, JSON.stringify(response.client));

localStorage.setItem(USER_KEY, JSON.stringify(response.client));

            setToken(response.token);
            setUser(response.client);
        } catch (err) {
            const authError = err as AuthError;
            setError(authError);
            throw authError;
        } finally {
            setIsLoading(false);
        }
    }, []);

    const logout = useCallback(async () => {
        setIsLoading(true);

        try {
            if (token) {
                await apiLogout(token);
            }
        } catch (err) {
            console.error('Logout error:', err);
        } finally {
            // Always clear local state regardless of API response
           localStorage.removeItem(TOKEN_KEY);
localStorage.removeItem(USER_KEY);

document.cookie =
  "amtar_auth_token=; path=/; expires=Thu, 01 Jan 1970 00:00:00 GMT";

setToken(null);
setUser(null);


            setIsLoading(false);
        }
    }, [token]);

    const refreshUser = useCallback(async () => {
        if (!token) return;
        try {
            const currentUser = await getCurrentUser(token);
            if (currentUser) {
                setUser(currentUser);
                localStorage.setItem(USER_KEY, JSON.stringify(currentUser));
            }
        } catch (err) {
            console.error('Failed to refresh user:', err);
        }
    }, [token]);

    const updateUser = useCallback((data: Partial<AuthClient>) => {
        setUser(prev => {
            if (!prev) return prev;
            const updated = { ...prev, ...data };
            localStorage.setItem(USER_KEY, JSON.stringify(updated));
            return updated;
        });
    }, []);

    const clearError = useCallback(() => {
        setError(null);
    }, []);

    const value: AuthContextType = {
        user,
        token,
        isLoading,
        isAuthenticated: !!token && !!user,
        login,
        logout,
        refreshUser,
        updateUser,
        error,
        clearError,
    };

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

export function useAuth() {
    const context = useContext(AuthContext);
    if (context === undefined) {
        throw new Error('useAuth must be used within an AuthProvider');
    }
    return context;
}