"use client";

import React, { createContext, useContext, useEffect, useState, useCallback } from "react";
import { apiFetch } from "@/services/api";
import { useRouter, usePathname } from "next/navigation";

interface User {
  id: number;
  email: string;
  fullName: string;
  role: "admin" | "user";
}

interface AuthContextType {
  user: User | null;
  loading: boolean;
  login: (userData: any, role: "admin" | "user", token: string) => void;
  logout: () => Promise<void>;
  refreshUser: () => Promise<void>;
}

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

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

  const refreshUser = useCallback(async () => {
    const token = localStorage.getItem("token");
    const storedRole = localStorage.getItem("user_role") as "admin" | "user" | null;

    if (!token) {
      setUser(null);
      setLoading(false);
      return;
    }

    try {
      // If we have a stored role, try that first to avoid 403s
      if (storedRole === "admin") {
        try {
          const adminData = await apiFetch("/admins/me");
          setUser({ ...adminData, role: "admin" });
          return;
        } catch (err) {
          // If admin check fails, try user as fallback
          const userData = await apiFetch("/users/me");
          setUser({ ...userData, role: "user" });
          localStorage.setItem("user_role", "user");
        }
      } else {
        try {
          const userData = await apiFetch("/users/me");
          setUser({ ...userData, role: "user" });
          localStorage.setItem("user_role", "user");
          return;
        } catch (err) {
          // If user check fails, try admin as fallback
          const adminData = await apiFetch("/admins/me");
          setUser({ ...adminData, role: "admin" });
          localStorage.setItem("user_role", "admin");
        }
      }
    } catch (err: any) {
      const isAuthError = 
        err.message === "Authentication required" || 
        err.message === "Invalid or expired token" ||
        err.message === "Access denied";

      if (!isAuthError) {
        console.error("Auth Check Failed:", err);
      }
      
      localStorage.removeItem("token");
      localStorage.removeItem("user_role");
      setUser(null);
      
      const isAuthPage = pathname === "/signin" || pathname === "/signup";
      if (!isAuthPage) {
        router.push("/signin");
      }
    } finally {
      setLoading(false);
    }
  }, [pathname, router]);

  const login = (userData: any, role: "admin" | "user", token: string) => {
    localStorage.setItem("token", token);
    localStorage.setItem("user_role", role);
    setUser({ ...userData, role });
  };

  const logout = async () => {
    try {
      if (user?.role === "admin") {
        await apiFetch("/admins/logout", { method: "POST" });
      } else {
        await apiFetch("/users/logout", { method: "POST" });
      }
    } catch (err) {
      console.error("Logout failed:", err);
    } finally {
      localStorage.removeItem("token");
      localStorage.removeItem("user_role");
      setUser(null);
      router.push("/signin");
    }
  };

  useEffect(() => {
    refreshUser();
  }, [refreshUser]);

  return (
    <AuthContext.Provider value={{ user, loading, login, logout, refreshUser }}>
      {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;
}