'use client';
import { createContext, useContext, useState, useEffect, ReactNode } from 'react';
import { useRouter } from 'next/navigation';

interface User {
  id: string;
  username: string;
  email: string;
  name: string;
  role: string;
  dept?: string;
  position?: string;
  avatar?: string;
  gender?: string;
  isFirstLogin: boolean;
  isActive: boolean;
  isIntern?: boolean;
  employeeId?: string;
  status?: string;
  isEmailVerified?: boolean;
}

export type { User };
export type AuthUser = User;

interface LoginParams {
  username: string;
  password: string;
}

interface LoginResponse {
  success: boolean;
  error?: string;
  firstLogin?: boolean;
  user?: User;
  requiresActivation?: boolean;
  message?: string;
}

interface AuthContextType {
  user: User | null;
  isLoading: boolean;
  login: (params: LoginParams) => Promise<LoginResponse>;
  logout: () => Promise<void>;
  updateUser: (updated: Partial<User>) => void;
  getAuthHeader: () => { Authorization: string } | {};
}

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

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

  // Load user from localStorage on mount
  useEffect(() => {
    const loadUser = () => {
      try {
        const storedUser = localStorage.getItem('auth_user');
        if (storedUser) {
          const parsedUser = JSON.parse(storedUser);
          setUser(parsedUser);
          console.log('✅ User loaded from localStorage:', parsedUser.email, 'Role:', parsedUser.role);
        } else {
          console.log('No stored user found');
        }
      } catch (error) {
        console.error('Failed to load user:', error);
        localStorage.removeItem('auth_user');
      } finally {
        setIsLoading(false);
      }
    };
    loadUser();
  }, []);

  const login = async ({ username, password }: LoginParams): Promise<LoginResponse> => {
    try {
      console.log('Login attempt for:', username);
      
      const res = await fetch('/api/auth/login', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ username, password }),
      });
      
      const data = await res.json();
      console.log('Login response status:', res.status);
      
      // Check if account needs activation (403 with requiresActivation flag)
      if (res.status === 403 && data.requiresActivation) {
        return {
          success: false,
          requiresActivation: true,
          message: data.message || 'Please activate your account first. Check your email for the activation link.',
        };
      }
      
      // Handle other non-OK responses
      if (!res.ok) {
        return { success: false, error: data.error || 'Login failed' };
      }
      
      // Successful login
      if (data.user) {
        // Store user in localStorage
        localStorage.setItem('auth_user', JSON.stringify(data.user));
        setUser(data.user);
        console.log('✅ Login successful for:', data.user.email, 'Role:', data.user.role);
        
        return {
          success: true,
          firstLogin: data.requiresPasswordChange || data.user.isFirstLogin,
          user: data.user,
        };
      }
      
      return { success: false, error: 'No user data returned' };
    } catch (error) {
      console.error('Login error:', error);
      return { success: false, error: 'Network error. Please try again.' };
    }
  };

  const logout = async () => {
    try {
      console.log('Logging out user:', user?.email);
      // Call logout API to clear cookie
      await fetch('/api/auth/logout', { method: 'POST' });
    } catch (error) {
      console.error('Logout API error:', error);
    } finally {
      localStorage.removeItem('auth_user');
      sessionStorage.clear();
      setUser(null);
      router.push('/login');
    }
  };

  const updateUser = (updated: Partial<User>) => {
    setUser(prev => {
      const next = prev ? { ...prev, ...updated } : null;
      if (next) {
        localStorage.setItem('auth_user', JSON.stringify(next));
        console.log('✅ User updated:', next.email);
      }
      return next;
    });
  };

  const getAuthHeader = () => {
    if (!user) return {};
    const token = localStorage.getItem('auth_token');
    if (token) {
      return { Authorization: `Bearer ${token}` };
    }
    return {};
  };

  return (
    <AuthContext.Provider value={{ user, isLoading, login, logout, updateUser, getAuthHeader }}>
      {children}
    </AuthContext.Provider>
  );
}

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