'use client';

import React, { createContext, useContext, useState, useEffect, ReactNode } from 'react';
import { getCurrentUserWithRetry } from '@/lib/appwrite';
import { databases } from '@/lib/appwrite';
import { Query } from 'appwrite';

interface EmpresaContextType {
  empresaId: string | null;
  setEmpresaId: (id: string | null) => void;
  clearEmpresaId: () => void;
  loading: boolean;
}

const EmpresaContext = createContext<EmpresaContextType | undefined>(undefined);

interface EmpresaProviderProps {
  children: ReactNode;
}

export function EmpresaProvider({ children }: EmpresaProviderProps) {
  const [empresaId, setEmpresaIdState] = useState<string | null>(null);
  const [loading, setLoading] = useState(true);

  // Função para buscar a empresa do usuário
  const buscarEmpresaDoUsuario = async () => {
    try {
      const user = await getCurrentUserWithRetry();
      if (!user) {
        setLoading(false);
        return;
      }

      // Buscar o documento do usuário
      const databaseId = process.env.NEXT_PUBLIC_APPWRITE_DATABASE_ID!;
      const collectionId = process.env.NEXT_PUBLIC_APPWRITE_COLLECTION_USUARIOS_ID!;

      const userQuery = await databases.listDocuments(
        databaseId,
        collectionId,
        [Query.equal("auth-id-appwrite", user.$id), Query.limit(1)]
      );

      if (userQuery.documents.length > 0) {
        const userDoc = userQuery.documents[0];
        console.log('📄 Documento do usuário encontrado:', {
          userId: userDoc.$id,
          authId: userDoc['auth-id-appwrite'],
          empresasArray: userDoc.empresas_array,
          nomeCompleto: userDoc['nome-civil']
        });
        
        const empresasArray = userDoc.empresas_array;

        if (empresasArray && Array.isArray(empresasArray) && empresasArray.length > 0) {
          // Se há empresas associadas, buscar a primeira empresa no banco
          const empresaCollectionId = process.env.NEXT_PUBLIC_APPWRITE_COLLECTION_EMPRESAS_DADOS_ID!;
          
          console.log('🔍 Buscando empresa com as seguintes informações:', {
            empresasArray,
            primeiraEmpresa: empresasArray[0],
            collectionId: empresaCollectionId
          });
          
          // Primeiro, vamos tentar buscar TODAS as empresas para debug
          const todasEmpresasQuery = await databases.listDocuments(
            databaseId,
            empresaCollectionId,
            [Query.limit(100)]
          );
          
          console.log('🏭 Todas as empresas cadastradas:', todasEmpresasQuery.documents);
          
          // Buscar a empresa pela razão social (assumindo que empresas_array contém nomes)
          let empresaQuery = await databases.listDocuments(
            databaseId,
            empresaCollectionId,
            [Query.equal("razao-social", empresasArray[0]), Query.limit(1)]
          );

          // Se não encontrou pela razão social, tentar pelo nome fantasia
          if (empresaQuery.documents.length === 0) {
            empresaQuery = await databases.listDocuments(
              databaseId,
              empresaCollectionId,
              [Query.equal("nome-fantasia", empresasArray[0]), Query.limit(1)]
            );
          }

          // Se ainda não encontrou, tentar por CNPJ se o valor parece ser um CNPJ
          if (empresaQuery.documents.length === 0 && empresasArray[0].match(/^\d{2}\.\d{3}\.\d{3}\/\d{4}-\d{2}$/)) {
            empresaQuery = await databases.listDocuments(
              databaseId,
              empresaCollectionId,
              [Query.equal("cnpj", empresasArray[0]), Query.limit(1)]
            );
          }

          // Se ainda não encontrou e há pelo menos uma empresa cadastrada, usar a primeira
          if (empresaQuery.documents.length === 0 && todasEmpresasQuery.documents.length > 0) {
            console.log('⚠️ Empresa específica não encontrada, usando primeira empresa disponível');
            const empresaId = todasEmpresasQuery.documents[0].$id;
            console.log('🏢 Usando primeira empresa disponível:', {
              empresaId,
              empresa: todasEmpresasQuery.documents[0]
            });
            setEmpresaIdState(empresaId);
            localStorage.setItem('empresaId', empresaId);
          } else if (empresaQuery.documents.length > 0) {
            const empresaId = empresaQuery.documents[0].$id;
            console.log('🏢 Empresa encontrada e definida:', {
              empresaId,
              empresaNome: empresasArray[0],
              empresa: empresaQuery.documents[0]
            });
            setEmpresaIdState(empresaId);
            localStorage.setItem('empresaId', empresaId);
          } else {
            console.log('❌ Nenhuma empresa encontrada na base de dados:', {
              empresaBuscada: empresasArray[0],
              empresasArray,
              todasEmpresasCadastradas: todasEmpresasQuery.documents.map(emp => emp['razao-social'])
            });
          }
        } else {
          console.log('📭 Usuário não possui empresas associadas:', {
            empresasArray,
            userDoc
          });
          
          // Se usuário não tem empresas associadas, mas há empresas no sistema, usar a primeira
          const empresaCollectionId = process.env.NEXT_PUBLIC_APPWRITE_COLLECTION_EMPRESAS_DADOS_ID!;
          const todasEmpresasQuery = await databases.listDocuments(
            databaseId,
            empresaCollectionId,
            [Query.limit(1)]
          );
          
          if (todasEmpresasQuery.documents.length > 0) {
            const empresaId = todasEmpresasQuery.documents[0].$id;
            console.log('🏢 Usuário sem empresa associada, usando primeira empresa do sistema:', {
              empresaId,
              empresa: todasEmpresasQuery.documents[0]
            });
            setEmpresaIdState(empresaId);
            localStorage.setItem('empresaId', empresaId);
          }
        }
      }
    } catch (error) {
      console.error('Erro ao buscar empresa do usuário:', error);
    } finally {
      setLoading(false);
    }
  };

  // Carregar empresa ID do localStorage ou buscar automaticamente
  useEffect(() => {
    const savedEmpresaId = localStorage.getItem('empresaId');
    if (savedEmpresaId) {
      setEmpresaIdState(savedEmpresaId);
      setLoading(false);
    } else {
      // Se não há empresa salva, buscar automaticamente
      buscarEmpresaDoUsuario();
    }
    
    // Fallback: se após 5 segundos ainda não há empresa, usar um valor padrão
    const fallbackTimeout = setTimeout(() => {
      if (!empresaId && !savedEmpresaId) {
        console.log('⚠️ Timeout na busca de empresa, aplicando fallback');
        // Definir um ID genérico para permitir visualização dos produtos
        const fallbackEmpresaId = 'empresa-generica';
        setEmpresaIdState(fallbackEmpresaId);
        localStorage.setItem('empresaId', fallbackEmpresaId);
      }
      setLoading(false);
    }, 5000);

    return () => clearTimeout(fallbackTimeout);
  }, []);

  const setEmpresaId = (id: string | null) => {
    setEmpresaIdState(id);
    if (id) {
      localStorage.setItem('empresaId', id);
    } else {
      localStorage.removeItem('empresaId');
    }
  };

  const clearEmpresaId = () => {
    setEmpresaIdState(null);
    localStorage.removeItem('empresaId');
  };

  return (
    <EmpresaContext.Provider value={{ empresaId, setEmpresaId, clearEmpresaId, loading }}>
      {children}
    </EmpresaContext.Provider>
  );
}

export function useEmpresa() {
  const context = useContext(EmpresaContext);
  if (context === undefined) {
    throw new Error('useEmpresa must be used within an EmpresaProvider');
  }
  return context;
}