"use client"

import type React from "react"
import { createContext, useContext, useState, useEffect } from "react"
import AsyncStorage from "@react-native-async-storage/async-storage"
import { api, setOnUnauthorizedCallback } from "../services/api"
import { trackingService } from "../services/tracking"
import { USER_DATA_KEY } from "@env"
import { Alert } from "react-native";
import { useOfflineMode } from "./OfflineModeContext";

// Interface para o usuário
interface User {
  id: number
  username: string
  sellerId: number | null
  name: string
  storeId: string
  email: string | null
}

// Interface para o contexto
interface AuthContextData {
  user: User | null
  isLoading: boolean
  signIn: (username: string, password: string) => Promise<{ success: boolean; needsRouting?: boolean }>
  signOut: () => Promise<void>
}

// Criar o contexto
const AuthContext = createContext<AuthContextData>({} as AuthContextData)

// Hook para usar o contexto
export const useAuth = () => {
  const context = useContext(AuthContext)
  if (!context) {
    throw new Error("useAuth deve ser usado dentro de um AuthProvider")
  }
  return context
}

// Definir tipo das rotas principais
export type RootStackParamList = {
  Auth: undefined;
  Main: undefined;
};

// Provedor do contexto
export const AuthProvider: React.FC<{ children: React.ReactNode }> = ({ children }) => {
  const [user, setUser] = useState<User | null>(null)
  const [isLoading, setIsLoading] = useState(true)
  
  // Integração com sistema offline - importação direta para evitar problemas de dependência circular

  // Carregar usuário do armazenamento local
  useEffect(() => {
    const loadUser = async () => {
      try {
        const storedUser = await AsyncStorage.getItem(USER_DATA_KEY)
        if (storedUser) {
          setUser(JSON.parse(storedUser))
        }
      } catch (error) {
        console.error("Erro ao carregar usuário:", error)
      } finally {
        setIsLoading(false)
      }
    }

    loadUser()
  }, [])

  // Registrar callback global para token expirado
  useEffect(() => {
    setOnUnauthorizedCallback(async () => {
      // Limpa o estado imediatamente
      await signOut();
      // Exibe alerta amigável
      Alert.alert(
        "Sessão expirada",
        "Sua sessão expirou. Faça login novamente.",
        [
          {
            text: "OK",
            onPress: () => {},
          },
        ],
        { cancelable: false }
      );
    });
  }, []);

  // Função para iniciar tracking automaticamente
  const startTrackingAfterLogin = async () => {
    try {
      console.log('=== DEBUG: INICIANDO TRACKING APÓS LOGIN ===');
      
      // Aguardar um pouco para garantir que os dados foram salvos
      await new Promise(resolve => setTimeout(resolve, 1000));
      
      // Tentar obter entregas para pegar um outId
      const deliveries = await api.getDeliveries();
      if (deliveries.length > 0) {
        const outId = deliveries[0].outId;
        console.log('OutId encontrado para tracking:', outId);
        
        await trackingService.startTracking(outId);
        console.log('✅ Tracking iniciado automaticamente após login');
      } else {
        console.log('⚠️ Nenhuma entrega encontrada para iniciar tracking');
      }
    } catch (error) {
      console.error('❌ Erro ao iniciar tracking após login:', error);
    }
  }

  // Função para fazer login
  const signIn = async (username: string, password: string): Promise<{ success: boolean; needsRouting?: boolean }> => {
    try {
      console.log('🚨 AUTH CONTEXT - INICIANDO LOGIN');
      console.log('🚨 Usuário:', username);
      setIsLoading(true)
      
      // ===== LIMPEZA COMPLETA DA BASE DE DADOS =====
      console.log('🚨 AUTH CONTEXT - LIMPANDO BASE SQLite');
      
      // Resetar modo offline ANTES do login para garantir dados limpos
      console.log('🚨 AUTH CONTEXT - RESETANDO MODO OFFLINE');
      const { resetOfflineModeUtil } = await import('../utils/resetOfflineMode');
      await resetOfflineModeUtil();
      
      console.log('🚨 AUTH CONTEXT - BASE SQLite LIMPA');
      
      // ===== FAZER LOGIN NA API =====
      console.log('🚨 AUTH CONTEXT - FAZENDO LOGIN NA API');
      const userData = await api.login(username, password)
      console.log('🚨 AUTH CONTEXT - LOGIN BEM-SUCEDIDO');
      setUser(userData)
      
      // ===== VERIFICAR ROTEIRIZAÇÃO (SEM CARREGAR DADOS LOCAIS) =====
      try {
        console.log('🚨 AUTH CONTEXT - VERIFICANDO ROTEIRIZAÇÃO');
        const deliveries = await api.getDeliveries();
        console.log('🚨 AUTH CONTEXT - Entregas carregadas:', deliveries.length);
        
        const needsRouting = deliveries.some(delivery => delivery.routing === 0);
        console.log('🚨 AUTH CONTEXT - Precisa de roteirização?', needsRouting);
        
        if (needsRouting) {
          console.log('🚨 AUTH CONTEXT - REDIRECIONANDO PARA ROUTING');
          return { success: true, needsRouting: true };
        }
        
        console.log('🚨 AUTH CONTEXT - INICIANDO TRACKING');
        // Iniciar tracking automaticamente após login bem-sucedido
        startTrackingAfterLogin();
        return { success: true, needsRouting: false };
      } catch (routingError) {
        // console.error('❌ Erro ao verificar roteirização:', routingError);
        // console.log('⚠️ Assumindo que não precisa de roteirização e iniciando tracking');
        // Se não conseguir verificar, assume que não precisa
        startTrackingAfterLogin();
        return { success: true, needsRouting: false };
      }
    } catch (error) {
      // console.error("❌ Erro ao fazer login:", error)
      return { success: false, needsRouting: false }
    } finally {
      setIsLoading(false)
      console.log('🚨 AUTH CONTEXT - LOGIN FINALIZADO');
    }
  }

  // Função para fazer logout
  const signOut = async (): Promise<void> => {
    try {
      console.log('=== DEBUG: INICIANDO SIGNOUT NO AUTHCONTEXT ===');
      
      // Parar tracking antes do logout (com try/catch individual)
      try {
        console.log('Parando tracking...');
        await trackingService.stopTracking();
        console.log('✅ Tracking parado com sucesso');
      } catch (trackingError) {
        console.warn('⚠️ Erro ao parar tracking (continuando logout):', trackingError);
      }
      
      // Fazer logout na API (com try/catch individual)
      try {
        console.log('Fazendo logout na API...');
        await api.logout();
        console.log('✅ Logout na API realizado com sucesso');
      } catch (apiError) {
        console.warn('⚠️ Erro ao fazer logout na API (continuando logout):', apiError);
      }
      
      // Resetar modo offline (com try/catch individual)
      try {
        console.log('Resetando modo offline...');
        const { resetOfflineModeUtil } = await import('../utils/resetOfflineMode');
        await resetOfflineModeUtil();
        console.log('✅ Modo offline resetado com sucesso');
      } catch (offlineError) {
        console.warn('⚠️ Erro ao resetar modo offline (continuando logout):', offlineError);
      }
      
      // Limpar estado do usuário (sempre executar)
      console.log('Limpando estado do usuário...');
      setUser(null);
      console.log('✅ Estado do usuário limpo');
      
      console.log('✅ Logout concluído com sucesso');
    } catch (error) {
      console.error("❌ Erro geral ao fazer logout:", error);
      // Mesmo com erro, garantir que o estado seja resetado
      try {
        console.log('🔄 Tentando resetar modo offline após erro...');
        const { resetOfflineModeUtil } = await import('../utils/resetOfflineMode');
        await resetOfflineModeUtil();
      } catch (resetError) {
        console.error("❌ Erro ao resetar modo offline:", resetError);
      }
      setUser(null);
      console.log('✅ Estado do usuário limpo após erro');
    }
  }

  return (
    <AuthContext.Provider
      value={{
        user,
        isLoading,
        signIn,
        signOut,
      }}
    >
      {children}
    </AuthContext.Provider>
  )
}

export { AuthContext };

