"use client";

import React, { createContext, useContext, useEffect, useMemo, useState } from "react";
import { api, clearStoredToken, getStoredToken, setStoredToken, type AuthUser, type SignupPayload } from "@/lib/api";

type User = AuthUser;

interface AuthContextType {
  user: User | null;
  isAdmin: boolean;
  token: string | null;
  isLoading: boolean;
  login: (email: string, password: string) => Promise<User | null>;
  signup: (payload: SignupPayload) => Promise<User | null>;
  logout: () => Promise<void>;
}

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

const readAuthUser = (): User | null => {
  if (typeof window === "undefined") return null;
  const raw = window.localStorage.getItem(AUTH_USER_KEY);
  return raw ? (JSON.parse(raw) as User) : null;
};

export const AuthProvider: React.FC<{ children: React.ReactNode }> = ({ children }) => {
  // Start null on server + first client paint so SSR matches hydration.
  const [user, setUser] = useState<User | null>(null);
  const [token, setToken] = useState<string | null>(null);
  const [isLoading, setIsLoading] = useState(true);

  useEffect(() => {
    const cachedUser = readAuthUser();
    const hydratedToken = getStoredToken();
    if (cachedUser) setUser(cachedUser);
    if (!hydratedToken) {
      setIsLoading(false);
      return;
    }
    setToken(hydratedToken);
    api.auth
      .me(hydratedToken)
      .then((me) => {
        setUser(me);
        setToken(hydratedToken);
        window.localStorage.setItem(AUTH_USER_KEY, JSON.stringify(me));
      })
      .catch(() => {
        setUser(null);
        setToken(null);
        clearStoredToken();
        window.localStorage.removeItem(AUTH_USER_KEY);
      })
      .finally(() => setIsLoading(false));
  }, []);

  const login = async (email: string, password: string) => {
    try {
      const result = await api.auth.login(email, password);
      setUser(result.user);
      setToken(result.token);
      setStoredToken(result.token);
      window.localStorage.setItem(AUTH_USER_KEY, JSON.stringify(result.user));
      return result.user;
    } catch {
      return null;
    }
  };

  const signup = async (payload: SignupPayload) => {
    try {
      const result = await api.auth.signup(payload);
      setUser(result.user);
      setToken(result.token);
      setStoredToken(result.token);
      window.localStorage.setItem(AUTH_USER_KEY, JSON.stringify(result.user));
      return result.user;
    } catch {
      return null;
    }
  };

  const logout = async () => {
    try {
      await api.auth.logout(token);
    } catch {
      // no-op
    }
    setUser(null);
    setToken(null);
    clearStoredToken();
    window.localStorage.removeItem(AUTH_USER_KEY);
  };

  const value = useMemo(
    () => ({ user, isAdmin: user?.role === "admin", token, isLoading, login, signup, logout }),
    [user, token, isLoading],
  );
  return <AuthContext.Provider value={value}>{children}</AuthContext.Provider>;
};

export const useAuth = () => {
  const ctx = useContext(AuthContext);
  if (!ctx) throw new Error("useAuth must be used within AuthProvider");
  return ctx;
};