// Contexto de autenticación

import React, { createContext, useContext, useState, useEffect, ReactNode } from 'react';
import { useRouter } from 'next/router';
import { authService, Admin } from '~/admin/services/authApi';
import { toast } from 'react-toastify';

interface AuthContextType {
  admin: Admin | null;
  token: string | null;
  loading: boolean;
  isAuthenticated: boolean;
  login: (email: string, password: string) => Promise<void>;
  register: (nombre: string, email: string, password: string) => Promise<void>;
  logout: () => Promise<void>;
  checkAuth: () => Promise<void>;
}

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

export const useAuth = () => {
  const context = useContext(AuthContext);
  if (!context) {
    throw new Error('useAuth debe ser usado dentro de AuthProvider');
  }
  return context;
};

interface Props {
  children: ReactNode;
}

export const AuthProvider: React.FC<Props> = ({ children }) => {
  const [admin, setAdmin] = useState<Admin | null>(null);
  const [token, setToken] = useState<string | null>(null);
  const [loading, setLoading] = useState(true);
  const router = useRouter();

  // Cargar token del localStorage al iniciar
  useEffect(() => {
    const initAuth = async () => {
      const storedToken = localStorage.getItem('auth_token');
      if (storedToken) {
        setToken(storedToken);
        try {
          const response = await authService.me(storedToken);
          if (response.success && response.data) {
            setAdmin(response.data);
            setToken(storedToken);
          } else {
            localStorage.removeItem('auth_token');
            setToken(null);
            setAdmin(null);
          }
        } catch (error: any) {
          localStorage.removeItem('auth_token');
          setToken(null);
          setAdmin(null);
        } finally {
          setLoading(false);
        }
      } else {
        setLoading(false);
      }
    };
    initAuth();
    // eslint-disable-next-line react-hooks/exhaustive-deps
  }, []);

  const checkAuth = async () => {
    const storedToken = localStorage.getItem('auth_token');
    if (!storedToken) {
      setLoading(false);
      return;
    }

    try {
      const response = await authService.me(storedToken);
      if (response.success && response.data) {
        setAdmin(response.data);
        setToken(storedToken);
      } else {
        // Token inválido
        localStorage.removeItem('auth_token');
        setToken(null);
        setAdmin(null);
      }
    } catch (error: any) {
      // Token expirado o inválido
      localStorage.removeItem('auth_token');
      setToken(null);
      setAdmin(null);
    } finally {
      setLoading(false);
    }
  };

  const login = async (email: string, password: string) => {
    try {
      const response = await authService.login(email, password);
      if (response.success && response.data) {
        const { admin: adminData, token: authToken } = response.data;
        localStorage.setItem('auth_token', authToken);
        setToken(authToken);
        setAdmin(adminData);
        toast.success('Login exitoso');
        router.push('/admin');
      }
    } catch (error: any) {
      toast.error(error.message || 'Error al iniciar sesión');
      throw error;
    }
  };

  const register = async (nombre: string, email: string, password: string) => {
    try {
      const response = await authService.register(nombre, email, password);
      if (response.success && response.data) {
        toast.success('Administrador registrado exitosamente');
        // Opcional: hacer login automático después del registro
        // await login(email, password);
      }
    } catch (error: any) {
      toast.error(error.message || 'Error al registrar administrador');
      throw error;
    }
  };

  const logout = async () => {
    try {
      // Obtener token del estado o del localStorage como respaldo
      const tokenToUse = token || localStorage.getItem('auth_token');
      if (tokenToUse) {
        try {
          await authService.logout(tokenToUse);
        } catch (error) {
          // Si falla la llamada a la API, continuamos con el logout local
          console.error('Error al cerrar sesión en el servidor:', error);
        }
      }
    } catch (error) {
      console.error('Error al cerrar sesión:', error);
    } finally {
      // Siempre limpiar el estado local, incluso si falla la llamada a la API
      localStorage.removeItem('auth_token');
      setToken(null);
      setAdmin(null);
      toast.success('Sesión cerrada exitosamente');
      router.push('/admin/login');
    }
  };

  return (
    <AuthContext.Provider
      value={{
        admin,
        token,
        loading,
        isAuthenticated: !!admin && !!token,
        login,
        register,
        logout,
        checkAuth,
      }}
    >
      {children}
    </AuthContext.Provider>
  );
};