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

/**
 * Hook customizado para gestão de favorecidos CNAB alinhado com o backend
 */
export const useFavorecidos = () => {
    const { paymentMode } = useCnabStore();
    const [favorecidos, setFavorecidos] = useState([]);
    const [loading, setLoading] = useState(true);
    const [selectedFavorecido, setSelectedFavorecido] = useState(null);
    const [searchTerm, setSearchTerm] = useState('');
    
    // Estados para histórico (usado no DetailsPanel)
    const [historico, setHistorico] = useState([]);
    const [loadingHistorico, setLoadingHistorico] = useState(false);

    /**
     * Carrega favorecidos iniciais do backend real
     */
    const loadFavorecidos = useCallback(async () => {
        setLoading(true);
        try {
            const data = paymentMode === 'TED' 
                ? await cnabService.getFavorecidosTed()
                : await cnabService.getFavorecidos();
            
            // O backend pode retornar { Listagem: [...] } ou direto a lista
            const list = data.Base_Dados_API || data.Listagem || data;
            setFavorecidos(Array.isArray(list) ? list : []);
        } catch (error) {
            console.error(error);
            toast.error('Erro ao carregar favorecidos do servidor.');
        } finally {
            setLoading(false);
        }
    }, [paymentMode]);

    /**
     * Carrega o histórico de pagamentos para um favorecido específico
     */
    const fetchHistorico = useCallback(async (nomeFavorecido) => {
        if (!nomeFavorecido) return;
        setLoadingHistorico(true);
        try {
            const data = paymentMode === 'TED'
                ? await cnabService.getHistoricoPagamentosTed()
                : await cnabService.getHistoricoPagamentos();
            
            const allHistory = data.Base_Dados_API || data;
            // Filtra o histórico pelo nome do favorecido (conforme lógica legado)
            const subset = Array.isArray(allHistory) 
                ? allHistory.find(item => item.nome_favorecido?.includes(nomeFavorecido))
                : null;
            
            setHistorico(subset?.pagamentos || []);
        } catch (error) {
            console.error('Erro ao carregar histórico:', error);
            setHistorico([]);
        } finally {
            setLoadingHistorico(false);
        }
    }, [paymentMode]);

    useEffect(() => {
        loadFavorecidos();
    }, [loadFavorecidos]);

    /**
     * Filtra favorecidos baseado no termo de busca
     */
    const filteredFavorecidos = favorecidos.filter(f => {
        const name = f.NOME_FAVORECIDO || f.nome || '';
        const doc = f.CPF_CNPJ_FAVORECIDO || f.documento || '';
        const pix = f.CHAVE_PIX || f.pix || '';
        
        return name.toLowerCase().includes(searchTerm.toLowerCase()) ||
               doc.includes(searchTerm) ||
               pix.toLowerCase().includes(searchTerm.toLowerCase());
    });

    const handleExport = async () => {
        try {
            toast.loading('Preparando exportação...');
            const user = JSON.parse(localStorage.getItem('integra_user') || '{}');
            const metadata = {
                usuario: user.nome || "Usuário Sistema",
                acao: "Exportacao",
                descricao: `Exportação de favorecidos realizada em ${new Date().toLocaleString()}`,
                data_envio: new Date().toISOString()
            };

            const blob = await cnabService.exportFavorecidos(metadata);
            const url = window.URL.createObjectURL(blob);
            const a = document.createElement('a');
            a.href = url;
            a.download = `Favorecidos_${paymentMode}.xlsx`;
            document.body.appendChild(a);
            a.click();
            window.URL.revokeObjectURL(url);
            document.body.removeChild(a);
            toast.dismiss();
            toast.success('Lista de favorecidos exportada com sucesso.');
        } catch (error) {
            toast.dismiss();
            toast.error('Erro na exportação.');
        }
    };

    const handleDelete = async (id) => {
        if (!confirm("Deseja realmente inativar este favorecido?")) return;
        
        try {
            // Busca o favorecido para obter o nome
            const favorecido = favorecidos.find(f => 
                f.idcnab_pralog === id || 
                f.idfavorecido === id || 
                f.id === id ||
                f.ID === id
            );
            
            const nomeFavorecido = favorecido?.NOME_FAVORECIDO || 
                                   favorecido?.nome || 
                                   favorecido?.Nome || 
                                   'Favorecido';
            
            const user = JSON.parse(localStorage.getItem('integra_user') || '{}');
            const nomeUsuario = user.nome || user.name || "Usuário Sistema";
            
            // Formata data e hora conforme o padrão do backend
            const agora = new Date();
            const dia = agora.toLocaleDateString('pt-BR', { 
                day: '2-digit', 
                month: '2-digit', 
                year: 'numeric' 
            });
            // Formata hora no formato HH:MM:SS
            const horaFormatada = String(agora.getHours()).padStart(2, '0') + ':' +
                                 String(agora.getMinutes()).padStart(2, '0') + ':' +
                                 String(agora.getSeconds()).padStart(2, '0');
            const dia_banco = agora.toISOString().split('T')[0]; // Formato YYYY-MM-DD
            
            const payload = {
                idcnab_pralog: id,
                usuario: nomeUsuario,
                acao: "Mudança de status",
                descricao: `${nomeUsuario} passou o ${nomeFavorecido}, com á id ${id}, para o status de inatividade, no dia ${dia} as ${horaFormatada}`,
                data_envio: `${dia_banco}T${horaFormatada}`
            };

            if (paymentMode === 'TED') {
                await cnabService.updateFavorecidoStatusTed(id, payload);
            } else {
                await cnabService.updateFavorecidoStatus(id, payload);
            }
            
            toast.success('Status do favorecido atualizado para Inativo.');
            loadFavorecidos(); // Recarrega a lista
        } catch (error) {
            console.error('Erro ao atualizar status:', error);
            toast.error('Erro ao atualizar status no servidor.');
        }
    };

    /**
     * Cria um novo favorecido
     * @param {Object} payload - Dados do favorecido
     */
    const handleCreate = async (payload) => {
        try {
            console.log('📤 [useFavorecidos] handleCreate chamado');
            console.log('   - Modo:', paymentMode);
            console.log('   - Payload recebido:', payload);
            
            const user = JSON.parse(localStorage.getItem('integra_user') || '{}');
            const metadata = {
                usuario: user.nome || "Usuário Sistema",
                acao: "Criacao",
                descricao: `Criação de favorecido realizada em ${new Date().toLocaleString()}`,
                data_envio: new Date().toISOString()
            };

            const fullPayload = { ...payload, ...metadata };
            console.log('   - Payload completo (com metadata):', fullPayload);

            if (paymentMode === 'TED') {
                console.log('   - Chamando createFavorecidoTed...');
                await cnabService.createFavorecidoTed(fullPayload);
            } else {
                console.log('   - Chamando createFavorecido...');
                await cnabService.createFavorecido(fullPayload);
            }
            
            console.log('✅ [useFavorecidos] Favorecido criado com sucesso');
            await loadFavorecidos(); // Recarrega a lista
        } catch (error) {
            console.error('❌ [useFavorecidos] Erro ao criar favorecido:', error);
            console.error('   - Detalhes:', error.response?.data || error.message);
            throw error;
        }
    };

    /**
     * Atualiza um favorecido existente
     * @param {Object} payload - Dados do favorecido (deve incluir o ID)
     */
    const handleUpdate = async (payload) => {
        try {
            const user = JSON.parse(localStorage.getItem('integra_user') || '{}');
            const metadata = {
                usuario: user.nome || "Usuário Sistema",
                acao: "Edicao",
                descricao: `Edição de favorecido realizada em ${new Date().toLocaleString()}`,
                data_envio: new Date().toISOString()
            };

            const fullPayload = { ...payload, ...metadata };

            if (paymentMode === 'TED') {
                await cnabService.updateFavorecidoTed(fullPayload);
            } else {
                await cnabService.updateFavorecido(fullPayload);
            }
            
            await loadFavorecidos(); // Recarrega a lista
        } catch (error) {
            console.error('Erro ao atualizar favorecido:', error);
            throw error;
        }
    };

    /**
     * Atualiza múltiplos favorecidos em massa
     * @param {Array<Object>} updates - Array de objetos com { id, ...campos }
     */
    const handleBulkUpdate = async (updates) => {
        if (!updates || updates.length === 0) {
            toast.error('Nenhuma alteração para salvar');
            return;
        }

        try {
            toast.loading(`Atualizando ${updates.length} favorecido(s)...`);
            const user = JSON.parse(localStorage.getItem('integra_user') || '{}');
            const metadata = {
                usuario: user.nome || "Usuário Sistema",
                acao: "Edicao em Massa",
                descricao: `Edição em massa de ${updates.length} favorecido(s) realizada em ${new Date().toLocaleString()}`,
                data_envio: new Date().toISOString()
            };

            // Atualiza cada favorecido individualmente
            const promises = updates.map(update => {
                const fullPayload = { ...update, ...metadata };
                return paymentMode === 'TED'
                    ? cnabService.updateFavorecidoTed(fullPayload)
                    : cnabService.updateFavorecido(fullPayload);
            });

            await Promise.all(promises);
            
            toast.dismiss();
            toast.success(`${updates.length} favorecido(s) atualizado(s) com sucesso!`);
            await loadFavorecidos(); // Recarrega a lista
        } catch (error) {
            console.error('Erro ao atualizar favorecidos em massa:', error);
            toast.dismiss();
            toast.error('Erro ao atualizar favorecidos. Alguns registros podem não ter sido atualizados.');
            throw error;
        }
    };

    /**
     * Exclui múltiplos favorecidos em massa
     * @param {Array<number|string>} ids - Array de IDs dos favorecidos a excluir
     */
    const handleBulkDelete = async (ids) => {
        if (!ids || ids.length === 0) {
            toast.error('Nenhum item selecionado');
            return;
        }

        if (!confirm(`Deseja realmente inativar ${ids.length} favorecido(s)?`)) {
            return;
        }

        try {
            toast.loading(`Inativando ${ids.length} favorecido(s)...`);
            const user = JSON.parse(localStorage.getItem('integra_user') || '{}');
            const nomeUsuario = user.nome || user.name || "Usuário Sistema";
            
            // Formata data e hora conforme o padrão do backend
            const agora = new Date();
            const dia = agora.toLocaleDateString('pt-BR', { 
                day: '2-digit', 
                month: '2-digit', 
                year: 'numeric' 
            });
            // Formata hora no formato HH:MM:SS
            const horaFormatada = String(agora.getHours()).padStart(2, '0') + ':' +
                                 String(agora.getMinutes()).padStart(2, '0') + ':' +
                                 String(agora.getSeconds()).padStart(2, '0');
            const dia_banco = agora.toISOString().split('T')[0]; // Formato YYYY-MM-DD

            // Inativa cada favorecido individualmente com descrição específica
            const promises = ids.map(id => {
                // Busca o favorecido para obter o nome
                const favorecido = favorecidos.find(f => 
                    f.idcnab_pralog === id || 
                    f.idfavorecido === id || 
                    f.id === id ||
                    f.ID === id
                );
                
                const nomeFavorecido = favorecido?.NOME_FAVORECIDO || 
                                       favorecido?.nome || 
                                       favorecido?.Nome || 
                                       'Favorecido';
                
                const payload = {
                    idcnab_pralog: id,
                    usuario: nomeUsuario,
                    acao: "Mudança de status",
                    descricao: `${nomeUsuario} passou o ${nomeFavorecido}, com á id ${id}, para o status de inatividade, no dia ${dia} as ${horaFormatada}`,
                    data_envio: `${dia_banco}T${horaFormatada}`
                };
                
                return paymentMode === 'TED'
                    ? cnabService.updateFavorecidoStatusTed(id, payload)
                    : cnabService.updateFavorecidoStatus(id, payload);
            });

            await Promise.all(promises);
            
            toast.dismiss();
            toast.success(`${ids.length} favorecido(s) inativado(s) com sucesso!`);
            await loadFavorecidos(); // Recarrega a lista
        } catch (error) {
            console.error('Erro ao excluir favorecidos em massa:', error);
            toast.dismiss();
            toast.error('Erro ao inativar favorecidos. Alguns registros podem não ter sido atualizados.');
            throw error;
        }
    };

    return {
        favorecidos: filteredFavorecidos,
        loading,
        searchTerm,
        setSearchTerm,
        selectedFavorecido,
        setSelectedFavorecido,
        historico,
        loadingHistorico,
        fetchHistorico,
        handleExport,
        handleDelete,
        handleCreate,
        handleUpdate,
        handleBulkUpdate,
        handleBulkDelete,
        refresh: loadFavorecidos
    };
};

