'use client';

import {
  createContext,
  useContext,
  useState,
  useEffect,
  useCallback,
  type ReactNode,
} from 'react';
import { usePathname, useRouter } from 'next/navigation';
import type { User } from '@/types';
import { authApi } from '@/lib/api';
import { getStoredUser, clearAuth, setStoredUser } from '@/lib/auth';
import {
  adminLoginUrl,
  canUseKasirApp,
  goToAdminLogin,
  homePathForRole,
} from '@/lib/roles';
import { safeRedirect } from '@/lib/safeRedirect';

interface AuthContextType {
  user: User | null;
  loading: boolean;
  login: (email: string, password: string) => Promise<void>;
  ssoLogin: (ssoToken: string) => Promise<void>;
  logout: () => Promise<void>;
}

const AuthContext = createContext<AuthContextType>({
  user: null,
  loading: true,
  login: async () => {},
  ssoLogin: async () => {},
  logout: async () => {},
});

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

  // Check auth on mount — session cookie is source of truth via /auth/me
  useEffect(() => {
    const checkAuth = async () => {
      const onLoginPage = pathname === '/login';
      const ssoPending =
        typeof window !== 'undefined' &&
        (new URLSearchParams(window.location.search).has('sso_token') ||
          sessionStorage.getItem('lasmini_sso_pending') === '1');

      // On /login without SSO: don't block UI on /auth/me (proxy often hangs on cPanel).
      // Login page redirects to Filament immediately.
      if (onLoginPage && !ssoPending) {
        setLoading(false);
        return;
      }

      const storedUser = getStoredUser();
      if (storedUser && canUseKasirApp(storedUser)) {
        setUser(storedUser);
      }

      // Hard timeout so "Memuat..." never spins forever if /backend proxy is broken
      const withTimeout = <T,>(p: Promise<T>, ms: number): Promise<T> =>
        Promise.race([
          p,
          new Promise<T>((_, reject) =>
            setTimeout(() => reject(new Error('auth_timeout')), ms)
          ),
        ]);

      try {
        const userData = await withTimeout(authApi.me(), 8000);
        if (!canUseKasirApp(userData)) {
          clearAuth();
          setUser(null);
          if (!onLoginPage) {
            goToAdminLogin();
          }
          return;
        }
        setStoredUser(userData);
        setUser(userData);
        try {
          sessionStorage.removeItem('lasmini_sso_pending');
        } catch {
          /* ignore */
        }
        if (onLoginPage && !ssoPending) {
          router.replace(homePathForRole(userData.role));
        }
      } catch {
        clearAuth();
        setUser(null);
        if (!onLoginPage && !ssoPending) {
          goToAdminLogin();
        }
      } finally {
        setLoading(false);
      }
    };

    checkAuth();
  }, []); // eslint-disable-line react-hooks/exhaustive-deps

  const login = useCallback(
    async (email: string, password: string) => {
      try {
        const data = await authApi.login(email, password);
        if (!canUseKasirApp(data.user)) {
          clearAuth();
          goToAdminLogin();
          throw new Error('Akun gudang memakai Admin Panel (/app).');
        }
        setStoredUser(data.user);
        setUser(data.user);
        router.replace(homePathForRole(data.user.role));
      } catch (err: unknown) {
        // Backend 403 for gudang includes redirect URL
        if (err && typeof err === 'object' && 'response' in err) {
          const ax = err as {
            response?: { status?: number; data?: { redirect?: string; message?: string } };
          };
          if (ax.response?.status === 403) {
            clearAuth();
            const dest = safeRedirect(ax.response.data?.redirect, adminLoginUrl());
            if (typeof window !== 'undefined') {
              window.location.href = dest;
            }
            throw new Error(
              ax.response.data?.message ||
                'Akun gudang masuk lewat Admin Panel (/app), bukan kasir.'
            );
          }
        }
        throw err;
      }
    },
    [router]
  );

  const ssoLogin = useCallback(
    async (ssoToken: string) => {
      try {
        try {
          sessionStorage.setItem('lasmini_sso_pending', '1');
        } catch {
          /* ignore */
        }
        const data = await authApi.ssoLogin(ssoToken);
        if (!canUseKasirApp(data.user)) {
          clearAuth();
          try {
            sessionStorage.removeItem('lasmini_sso_pending');
          } catch {
            /* ignore */
          }
          goToAdminLogin();
          throw new Error('Akun gudang tidak untuk kasir ecer.');
        }
        setStoredUser(data.user);
        setUser(data.user);
        try {
          sessionStorage.removeItem('lasmini_sso_pending');
        } catch {
          /* ignore */
        }
        // Hard navigate so AppShell remounts with session cookie settled
        const dest = homePathForRole(data.user.role);
        if (typeof window !== 'undefined') {
          window.location.replace(dest);
        } else {
          router.replace(dest);
        }
      } catch (err: unknown) {
        try {
          sessionStorage.removeItem('lasmini_sso_pending');
        } catch {
          /* ignore */
        }
        if (err && typeof err === 'object' && 'response' in err) {
          const ax = err as {
            response?: { status?: number; data?: { redirect?: string; message?: string } };
          };
          if (ax.response?.status === 403) {
            clearAuth();
            const dest = safeRedirect(ax.response.data?.redirect, adminLoginUrl());
            if (typeof window !== 'undefined') {
              window.location.href = dest;
            }
            throw new Error(ax.response.data?.message || 'SSO ditolak untuk role ini.');
          }
        }
        throw err;
      }
    },
    [router]
  );

  const logout = useCallback(async () => {
    try {
      await authApi.logout();
    } catch {
      // Ignore errors on logout
    }
    setUser(null);
    // Central login: Filament admin panel (not Next /login)
    goToAdminLogin();
  }, []);

  return (
    <AuthContext.Provider value={{ user, loading, login, ssoLogin, logout }}>
      {children}
    </AuthContext.Provider>
  );
}

export function useAuth() {
  return useContext(AuthContext);
}
