import { useState, useCallback } from 'react';
import { toast } from 'sonner';
import cnabService from '../services/cnabService';

/**
 * Hook customizado para gerenciamento de navegação de pastas no Nextcloud
 * Gerencia o estado de navegação hierárquica e exportação de arquivos
 */
export const useGerenciarPastas = () => {
  const [loading, setLoading] = useState(false);
  const [currentPath, setCurrentPath] = useState('/Espelhos de Notas Fiscais');
  const [navigationHistory, setNavigationHistory] = useState(['/Espelhos de Notas Fiscais']);
  const [folders, setFolders] = useState([]);
  const [files, setFiles] = useState([]);
  const [error, setError] = useState(null);
  const [isNavigating, setIsNavigating] = useState(false); // Flag para prevenir navegações simultâneas

  // Credenciais do Nextcloud (podem vir de configuração ou contexto)
  const [credentials, setCredentials] = useState({
    usuario: 'vitoria.oliveira',
    senha: 'Vit230723@',
    base_url: 'https://cloud.grupopralog.com.br'
  });

  /**
   * Navega para uma pasta específica
   * @param {string} caminho - Caminho completo da pasta
   * @param {boolean} forceReload - Força o recarregamento mesmo se já estiver no caminho
   */
  const navigateToFolder = useCallback(async (caminho, forceReload = false) => {
    if (!caminho) {
      toast.error('Caminho da pasta não informado');
      return;
    }

    // Previne navegações simultâneas
    if (isNavigating || loading) {
      return;
    }

    // Se já está no caminho solicitado e não é um reload forçado, não faz nada
    // Mas permite se não houver dados carregados ainda
    if (currentPath === caminho && !forceReload && folders.length > 0) {
      return;
    }

    setIsNavigating(true);
    setLoading(true);
    setError(null);

    try {
      console.log('📁 [useGerenciarPastas] Navegando para:', caminho);
      const response = await cnabService.navegarPasta({
        caminho_pasta: caminho
        // Credenciais removidas - não devem ser enviadas
      });

      console.log('✅ [useGerenciarPastas] Resposta recebida:', response);

      if (response?.sucesso) {
        const newPath = response.caminho_atual;
        
        setCurrentPath(newPath);
        setFolders(response.pastas || []);
        setFiles(response.arquivos || []);
        
        // Atualiza histórico de navegação
        setNavigationHistory(prev => {
          const newHistory = [...prev];
          // Remove duplicatas e mantém apenas até o caminho atual
          const currentIndex = newHistory.indexOf(newPath);
          if (currentIndex >= 0) {
            return newHistory.slice(0, currentIndex + 1);
          }
          return [...newHistory, newPath];
        });

        console.log('✅ [useGerenciarPastas] Navegação concluída:', {
          caminho: newPath,
          pastas: response.pastas?.length || 0,
          arquivos: response.arquivos?.length || 0
        });
      } else {
        throw new Error(response?.mensagem || 'Falha ao navegar na pasta');
      }
    } catch (error) {
      console.error('❌ [useGerenciarPastas] Erro ao navegar pasta:', error);
      setError(error.message || 'Erro ao carregar pasta');
      toast.error(error.message || 'Erro ao carregar pasta');
    } finally {
      setLoading(false);
      setIsNavigating(false);
    }
  }, [credentials, currentPath, isNavigating, loading, folders.length]);

  /**
   * Navega para uma pasta filha
   * @param {Object} folder - Objeto pasta com { caminho, nome }
   */
  const enterFolder = useCallback((folder) => {
    if (!folder?.caminho) {
      toast.error('Pasta inválida');
      return;
    }
    navigateToFolder(folder.caminho);
  }, [navigateToFolder]);

  /**
   * Volta para a pasta anterior no histórico
   */
  const goBack = useCallback(() => {
    if (navigationHistory.length <= 1) {
      toast.info('Você já está na pasta raiz');
      return;
    }

    const newHistory = [...navigationHistory];
    newHistory.pop(); // Remove o caminho atual
    const previousPath = newHistory[newHistory.length - 1];
    
    navigateToFolder(previousPath);
  }, [navigationHistory, navigateToFolder]);

  /**
   * Navega para um caminho específico no histórico (breadcrumb)
   * @param {string} caminho - Caminho para navegar
   */
  const navigateToPath = useCallback((caminho) => {
    // Previne múltiplas chamadas rápidas
    if (isNavigating || loading || currentPath === caminho) {
      return;
    }
    navigateToFolder(caminho);
  }, [navigateToFolder, isNavigating, loading, currentPath]);

  /**
   * Exporta/processa arquivos de uma pasta
   * @param {string} caminho - Caminho da pasta contendo os arquivos
   * @returns {Promise<void>}
   */
  const exportFolderFiles = useCallback(async (caminho = null) => {
    const targetPath = caminho || currentPath;
    
    if (!targetPath) {
      toast.error('Caminho da pasta não informado');
      return;
    }

    setLoading(true);
    setError(null);

    try {
      toast.loading('Processando arquivos da pasta...');
      
      const blob = await cnabService.processarPdfsPasta({
        caminho_pasta: targetPath
        // Credenciais removidas - não devem ser enviadas
      });

      if (!blob) {
        throw new Error('Nenhum arquivo foi gerado');
      }

      // Extrai o nome do arquivo do caminho ou usa um padrão
      const pathParts = targetPath.split('/').filter(Boolean);
      const folderName = pathParts[pathParts.length - 1] || 'pasta';
      const filename = `relatorio_${folderName.replace(/\s+/g, '_')}.xlsx`;

      // Faz o download do arquivo
      cnabService.downloadFile(blob, filename);
      
      toast.dismiss();
      toast.success('Arquivo exportado com sucesso!');
    } catch (error) {
      console.error('Erro ao exportar arquivos:', error);
      setError(error.message || 'Erro ao exportar arquivos');
      toast.dismiss();
      toast.error(error.message || 'Erro ao exportar arquivos');
    } finally {
      setLoading(false);
    }
  }, [currentPath, credentials]);

  /**
   * Carrega a pasta inicial
   */
  const loadInitialFolder = useCallback(() => {
    const initialPath = '/Espelhos de Notas Fiscais';
    // Força o carregamento mesmo se já estiver no caminho inicial
    navigateToFolder(initialPath, true);
  }, [navigateToFolder]);

  /**
   * Atualiza as credenciais do Nextcloud
   * @param {Object} newCredentials - Novas credenciais
   */
  const updateCredentials = useCallback((newCredentials) => {
    setCredentials(prev => ({
      ...prev,
      ...newCredentials
    }));
  }, []);

  return {
    // Estado
    loading,
    currentPath,
    navigationHistory,
    folders,
    files,
    error,
    credentials,

    // Ações
    navigateToFolder,
    enterFolder,
    goBack,
    navigateToPath,
    exportFolderFiles,
    loadInitialFolder,
    updateCredentials
  };
};
