"use client";

import { createContext, useContext, useState, useEffect, ReactNode } from "react";

export interface User {
  id: string;
  username: string;
  email: string | null;
  name: string | null;
  role: "USER" | "ADMIN" | "GURU" | "SISWA";
  createdAt: string;
  updatedAt: string;
  siswa?: { id: string; nama: string };
  guru?: { id: string; nama: string };
}

interface AuthContextType {
  user: User | null;
  login: (identifier: string, password: string) => Promise<{ success: boolean; message?: string }>;
  register: (
    username: string,
    email: string,
    password: string,
    role?: User["role"],
  ) => Promise<{ success: boolean; message?: string }>;
  logout: () => Promise<void>;
  isLoading: boolean;
}

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

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

interface AuthProviderProps {
  children: ReactNode;
}

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

  // Verify token and load user on mount
  useEffect(() => {
    const verifyAndLoadUser = async () => {
      try {
        console.log("AuthContext - Attempting to verify token...");

        // Try to verify token dengan server
        const headers: Record<string, string> = {};

        // Jika ada token di localStorage, kirim via Authorization header juga
        const localToken = localStorage.getItem("token");
        if (localToken) {
          headers.Authorization = `Bearer ${localToken}`;
          console.log("AuthContext - Adding Authorization header from localStorage");
        }

        const response = await fetch("/api/auth/verify", {
          method: "GET",
          credentials: "include", // Kirim cookie
          headers,
        });

        if (response.ok) {
          const data = await response.json();
          if (data.success) {
            setUser(data.data);
            // Update localStorage juga dengan data terbaru
            localStorage.setItem("user", JSON.stringify(data.data));
          } else {
            // Token tidak valid, clear localStorage
            localStorage.removeItem("user");
          }
        } else {
          // Token tidak valid, clear localStorage dan redirect ke login jika di protected route
          localStorage.removeItem("user");
          localStorage.removeItem("token");

          // Check if currently on protected route
          if (window.location.pathname.startsWith("/dashboard")) {
            window.location.href = "/auth/login";
          }
        }
      } catch (error) {
        console.error("Error verifying token:", error);
        // Fallback ke localStorage
        const savedUser = localStorage.getItem("user");
        if (savedUser) {
          try {
            setUser(JSON.parse(savedUser));
          } catch (parseError) {
            console.error("Error parsing saved user:", parseError);
            localStorage.removeItem("user");
          }
        }
      } finally {
        setIsLoading(false);
      }
    };

    verifyAndLoadUser();
  }, []);

  const login = async (identifier: string, password: string) => {
    setIsLoading(true);
    try {
      const response = await fetch("/api/auth/login", {
        method: "POST",
        headers: {
          "Content-Type": "application/json",
        },
        credentials: "include", // Kirim dan terima cookie
        body: JSON.stringify({ identifier, password }),
      });

      const data = await response.json();

      if (data.success) {
        console.log("Login success, token received:", data.token ? "Yes" : "No");
        console.log("Response headers:", response.headers);

        setUser(data.data);
        localStorage.setItem("user", JSON.stringify(data.data));

        // Simpan token di localStorage juga sebagai backup
        if (data.token) {
          localStorage.setItem("token", data.token);
          console.log("Token saved to localStorage");
        }

        // Check cookies immediately after login
        console.log("Cookies after login:", document.cookie);

        return { success: true };
      } else {
        return { success: false, message: data.message };
      }
    } catch (error) {
      console.error("Login error:", error);
      return { success: false, message: "Terjadi kesalahan saat login" };
    } finally {
      setIsLoading(false);
    }
  };

  const register = async (username: string, email: string, password: string, role: User["role"] = "USER") => {
    setIsLoading(true);
    try {
      const response = await fetch("/api/auth/register", {
        method: "POST",
        headers: {
          "Content-Type": "application/json",
        },
        body: JSON.stringify({ username, email, password, role }),
      });

      const data = await response.json();

      if (data.success) {
        setUser(data.data);
        localStorage.setItem("user", JSON.stringify(data.data));
        return { success: true };
      } else {
        return { success: false, message: data.message };
      }
    } catch (error) {
      console.error("Register error:", error);
      return { success: false, message: "Terjadi kesalahan saat registrasi" };
    } finally {
      setIsLoading(false);
    }
  };

  const logout = async () => {
    setIsLoading(true);
    try {
      // Call logout API untuk clear server-side cookie
      await fetch("/api/auth/logout", {
        method: "POST",
        credentials: "include",
      });
    } catch (error) {
      console.error("Logout API error:", error);
    } finally {
      // Clear client-side data
      setUser(null);
      localStorage.removeItem("user");
      localStorage.removeItem("token");
      setIsLoading(false);
    }
  };

  const value = {
    user,
    login,
    register,
    logout,
    isLoading,
  };

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