'use client';

import { createContext, useContext, useState, useEffect, useCallback, ReactNode } from 'react';
import type { User } from '@/types/database';

interface UserContextType {
  currentUser: User | null;
  users: User[];
  isLoading: boolean;
  isInitialized: boolean;
  isAuthenticated: boolean;
  setCurrentUserId: (id: string) => void;
  logout: () => void;
  refreshUsers: () => Promise<void>;
  refreshMe: () => Promise<User | null>;
}

const UserContext = createContext<UserContextType | undefined>(undefined);

export function UserProvider({ children }: { children: ReactNode }) {
  const [currentUser, setCurrentUser] = useState<User | null>(null);
  const [users, setUsers] = useState<User[]>([]);
  const [isLoading, setIsLoading] = useState(true);
  const [isInitialized, setIsInitialized] = useState(false);
  const [isAuthenticated, setIsAuthenticated] = useState(false);

  const refreshUsers = useCallback(async () => {
    try {
      const res = await fetch('/api/users');
      if (res.ok) {
        const data = await res.json();
        setUsers(data);
        return data;
      }
    } catch (error) {
      console.error('Failed to fetch users:', error);
    }
    return [];
  }, []);

  const refreshMe = useCallback(async () => {
    try {
      const meRes = await fetch('/api/auth/me', { cache: 'no-store' });
      const meData = await meRes.json().catch(() => ({}));
      const me = meData?.user as User | null | undefined;

      if (me && me.id) {
        setCurrentUser(me);
        setIsAuthenticated(true);
        localStorage.setItem('okrAuthUserId', me.id);
        localStorage.setItem('currentUserId', me.id);
        await refreshUsers();
        return me;
      }

      localStorage.removeItem('okrAuthUserId');
      localStorage.removeItem('currentUserId');
      setCurrentUser(null);
      setIsAuthenticated(false);
      setUsers([]);
      return null;
    } catch (error) {
      console.error('Failed to refresh auth:', error);
      localStorage.removeItem('okrAuthUserId');
      localStorage.removeItem('currentUserId');
      setCurrentUser(null);
      setIsAuthenticated(false);
      setUsers([]);
      return null;
    }
  }, [refreshUsers]);

  useEffect(() => {
    async function init() {
      setIsLoading(true);
      try {
        await refreshMe();
      } catch (error) {
        console.error('Failed to initialize auth:', error);
        localStorage.removeItem('okrAuthUserId');
        localStorage.removeItem('currentUserId');
        setCurrentUser(null);
        setIsAuthenticated(false);
        setUsers([]);
      } finally {
        setIsInitialized(true);
        setIsLoading(false);
      }
    }

    init();
  }, [refreshMe]);

  const setCurrentUserId = useCallback((id: string) => {
    const authUserId = localStorage.getItem('okrAuthUserId');
    if (!authUserId) return;
    if (authUserId !== id) return;
    const user = users.find(u => u.id === id);
    if (user) {
      setCurrentUser(user);
      localStorage.setItem('currentUserId', id);
      setIsAuthenticated(true);
    }
  }, [users]);

  const logout = useCallback(() => {
    localStorage.removeItem('okrAuthUserId');
    localStorage.removeItem('currentUserId');
    setCurrentUser(null);
    setIsAuthenticated(false);
    setUsers([]);
    fetch('/api/auth/logout', { method: 'POST' }).catch(() => {});
  }, []);

  return (
    <UserContext.Provider value={{ currentUser, users, isLoading, isInitialized, isAuthenticated, setCurrentUserId, logout, refreshUsers, refreshMe }}>
      {children}
    </UserContext.Provider>
  );
}

export function useUser() {
  const context = useContext(UserContext);
  if (context === undefined) {
    throw new Error('useUser must be used within a UserProvider');
  }
  return context;
}