import { useState, useMemo, useEffect } from 'react';
import { useToast } from './useToast';
import { extratoService } from '@/services/extratoService';
import { workspaceConciliacaoService } from '@/services/workspaceConciliacaoService';
import { conciliacaoService } from '@/services/conciliacaoService';
// import { processarReconciliacao, resetarTodasTransacoes } from '@/services/reconciliationEngine';
import api from '@/services/api';
import { formatDate } from '../utils/dateUtils';

// Mock Caixas
const MOCK_CAIXAS = [
    { id: 1, nome: 'Caixa Principal', descricao: 'Conta corrente principal', banco: 'Banco do Brasil', agencia: '1234-5', conta: '12345-6' },
    { id: 2, nome: 'Caixa Operacional', descricao: 'Conta para operações diárias', banco: 'Itaú', agencia: '5678-9', conta: '67890-1' },
    { id: 3, nome: 'Caixa Investimentos', descricao: 'Conta para investimentos', banco: 'Bradesco', agencia: '9012-3', conta: '90123-4' }
];

// Mock Categorias
const MOCK_CATEGORIAS = [
    { id: 1, nome: 'Fornecedores', descricao: 'Pagamentos a fornecedores', cor: '#ef4444' },
    { id: 2, nome: 'Salários', descricao: 'Pagamento de salários e encargos', cor: '#3b82f6' },
    { id: 3, nome: 'Impostos', descricao: 'Impostos e taxas', cor: '#f59e0b' },
    { id: 4, nome: 'Serviços', descricao: 'Serviços diversos', cor: '#10b981' },
    { id: 5, nome: 'Receitas', descricao: 'Recebimentos diversos', cor: '#8b5cf6' }
];

// Mock Regras
const MOCK_REGRAS = [
    { id: 1, nome: 'Pagamento Fornecedor ABC', condicao: 'descricao contém "FORNECEDOR ABC"', categoriaId: 1, caixaId: 1, beneficiario: 'Fornecedor ABC Ltda' },
    { id: 2, nome: 'Folha de Pagamento', condicao: 'descricao contém "FOLHA"', categoriaId: 2, caixaId: 1, beneficiario: 'RH' },
    { id: 3, nome: 'Imposto Federal', condicao: 'descricao contém "DARF"', categoriaId: 3, caixaId: 1, beneficiario: 'Receita Federal' },
    { id: 4, nome: 'Serviços TI', condicao: 'descricao contém "TI"', categoriaId: 4, caixaId: 1, beneficiario: 'Serviços TI Premium' }
];

// Mock Transações Conciliadas
const MOCK_TRANSACOES_CONCILIADAS = [
    { id: 1, data: '2026-01-15', descricao: 'PAGAMENTO FORNECEDOR ABC - FATURA 001', valor: -5000.00, tipo: 'DEBITO', caixaId: 1, categoriaId: 1, regraId: 1, beneficiario: 'Fornecedor ABC Ltda', status: 'CONCILIADA' },
    { id: 2, data: '2026-01-16', descricao: 'FOLHA DE PAGAMENTO JANEIRO/2026', valor: -25000.00, tipo: 'DEBITO', caixaId: 1, categoriaId: 2, regraId: 2, beneficiario: 'RH', status: 'CONCILIADA' },
    { id: 3, data: '2026-01-17', descricao: 'DARF - IMPOSTO DE RENDA', valor: -3500.00, tipo: 'DEBITO', caixaId: 1, categoriaId: 3, regraId: 3, beneficiario: 'Receita Federal', status: 'CONCILIADA' },
    { id: 4, data: '2026-01-18', descricao: 'SERVICOS TI - MENSALIDADE', valor: -2000.00, tipo: 'DEBITO', caixaId: 1, categoriaId: 4, regraId: 4, beneficiario: 'Serviços TI Premium', status: 'CONCILIADA' },
    { id: 5, data: '2026-01-19', descricao: 'RECEBIMENTO CLIENTE XYZ', valor: 15000.00, tipo: 'CREDITO', caixaId: 1, categoriaId: 5, regraId: null, beneficiario: 'Cliente XYZ', status: 'CONCILIADA' },
    { id: 6, data: '2026-01-20', descricao: 'PAGAMENTO FORNECEDOR ABC - FATURA 002', valor: -3000.00, tipo: 'DEBITO', caixaId: 1, categoriaId: 1, regraId: 1, beneficiario: 'Fornecedor ABC Ltda', status: 'CONCILIADA' }
];

// Mock Transações Não Categorizadas
const MOCK_TRANSACOES_NAO_CATEGORIZADAS = [
    { id: 101, data: '2026-01-21', descricao: 'TRANSFERENCIA BANCARIA - ORIGEM DESCONHECIDA', valor: -500.00, tipo: 'DEBITO', caixaId: 1, categoriaId: null, regraId: null, beneficiario: null, status: 'PENDENTE' },
    { id: 102, data: '2026-01-22', descricao: 'PIX RECEBIDO - SEM IDENTIFICACAO', valor: 1200.00, tipo: 'CREDITO', caixaId: 1, categoriaId: null, regraId: null, beneficiario: null, status: 'PENDENTE' },
    { id: 103, data: '2026-01-23', descricao: 'TARIFA BANCARIA MENSAL', valor: -25.00, tipo: 'DEBITO', caixaId: 1, categoriaId: null, regraId: null, beneficiario: null, status: 'PENDENTE' }
];

/**
 * Hook para gerenciar a lógica de Conciliação V2
 */
export function useConciliacaoV2(defaultView = 'conciliadas') {
    console.log('[useConciliacaoV2] Hook iniciado');
    
    const toast = useToast();
    console.log('[useConciliacaoV2] Toast inicializado');
    
    // Normalização de alias de rotas
    const normalizeSubView = (view) => {
        if (!view) return 'conciliadas';
        if (view === 'extrato' || view === 'extrato-completo') return 'extrato-completo'; 
        if (view === 'pendentes') return 'nao-categorizadas';
        return view;
    };

    const initialSubView = useMemo(() => normalizeSubView(defaultView), [defaultView]);

    const [activeSubView, setActiveSubView] = useState(initialSubView);
    
    // Atualizar view quando a prop mudar
    useEffect(() => {
        console.log('[useConciliacaoV2] defaultView mudou para:', defaultView);
        if (defaultView) {
            const normalized = normalizeSubView(defaultView);
            console.log('[useConciliacaoV2] Setando activeSubView para:', normalized);
            setActiveSubView(normalized);
        }
    }, [defaultView]);
    console.log('[useConciliacaoV2] Estados iniciais definidos');
    const [caixas, setCaixas] = useState([]);
    const [categorias, setCategorias] = useState([]);
    const [regras, setRegras] = useState([]);
    const [extratoCompleto, setExtratoCompleto] = useState([]);
    const [transacoesConciliadas, setTransacoesConciliadas] = useState([]);
    const [transacoesNaoCategorizadas, setTransacoesNaoCategorizadas] = useState([]);
    const [isLoading, setIsLoading] = useState(true);
    // const [isReconciliando, setIsReconciliando] = useState(false);
    // const [progressoReconciliacao, setProgressoReconciliacao] = useState({ processados: 0, total: 0 });
    
    // Filtros
    const [filtroCaixa, setFiltroCaixa] = useState(null);
    const [filtroAno, setFiltroAno] = useState(new Date().getFullYear());
    const [filtroMes, setFiltroMes] = useState(new Date().getMonth() + 1); // 1-12
    const [filtroCategoria, setFiltroCategoria] = useState(null);
    const [filtroRegra, setFiltroRegra] = useState(null);
    
    // Navegação hierárquica
    const [nivelNavegacao, setNivelNavegacao] = useState(0); // 0: Caixas, 1: Categorias, 2: Regras/Beneficiários, 3: Transações
    const [caminhoNavegacao, setCaminhoNavegacao] = useState([]);
    const [caixaSelecionado, setCaixaSelecionado] = useState(null);
    const [categoriaSelecionada, setCategoriaSelecionada] = useState(null);
    const [subgroupSelecionado, setSubgroupSelecionado] = useState(null);
    const [dadosNivelAtual, setDadosNivelAtual] = useState([]);
    const [backendNavData, setBackendNavData] = useState([]);
    const [isNavLoading, setIsNavLoading] = useState(false);

    // Função auxiliar para normalizar dados do backend (Base_Dados_API)
    const normalizeBackendData = (response) => {
        const raw = response?.data ?? response;
        let data = raw?.Base_Dados_API ?? raw;
        if (!Array.isArray(data)) {
            data = Object.values(data || {});
        }
        return data;
    };

    // Função auxiliar para recarregar dados
    const recarregarDados = async () => {
        try {
            setIsLoading(true);
            const extrato = (await workspaceConciliacaoService.fetchExtrato({ mes: filtroMes, ano: filtroAno })) || [];
            setExtratoCompleto(extrato);
            // Separar transações conciliadas e não categorizadas
            const conciliadas = extrato.filter(t => t?.status === 'CONCILIADA' && t?.categoriaId);
            const naoCategorizadas = extrato.filter(t => t?.status === 'PENDENTE' || !t?.categoriaId);
            
            setTransacoesConciliadas(conciliadas);
            setTransacoesNaoCategorizadas(naoCategorizadas);
        } catch (error) {
            console.error('[useConciliacaoV2] Erro ao recarregar dados:', error);
        } finally {
            setIsLoading(false);
        }
    };

    // Busca dados para o nível de navegação atual USANDO A NOVA ROTA HIERÁRQUICA
    const fetchNivelNavegacao = async (nivel, filters = {}) => {
        setIsNavLoading(true);
        console.log('[useConciliacaoV2] Buscando dados para nível:', nivel, filters);
        
        try {
            let data = [];
            
            if (nivel === 0) {
                // Nível 0: Caixas (Agora usando a rota detalhada para cada caixa para matar o 'cruzamentos')
                const sourceCaixas = (filters && filters.caixas) || caixas || [];
                
                // Buscar totais para cada caixa usando a rota detalhada em paralelo
                console.log('[useConciliacaoV2] Buscando totais detalhados para todas as caixas (Substituindo cruzamentos)...');
                const enrichedCaixas = await Promise.all(sourceCaixas.map(async (c) => {
                    try {
                        const detailed = await workspaceConciliacaoService.fetchExtratoDetalhado(c.id, { mes: filtroMes, ano: filtroAno });
                        
                        // Fallback: Calcular totais manualmente se o resumo não vier
                        const categorias = detailed.categorias || [];
                        const calcValor = categorias.reduce((acc, cat) => acc + (Number(cat.valor_total) || 0), 0);
                        const calcTransacoes = categorias.reduce((acc, cat) => {
                            const catTotal = cat.total_transacoes || (cat.beneficiarios || []).reduce((bAcc, ben) => bAcc + (ben.total_transacoes || 0), 0);
                            return acc + catTotal;
                        }, 0);

                        return {
                            ...c,
                            totalTransacoes: detailed.resumo?.total_transacoes || detailed.total_transacoes || calcTransacoes,
                            totalValor: detailed.valor_total || detailed.resumo?.valor_total || calcValor,
                            tipo: 'caixa'
                        };
                    } catch (e) {
                        console.warn(`Erro ao buscar detalhe da caixa ${c.id}:`, e);
                        return { ...c, totalTransacoes: 0, totalValor: 0, tipo: 'caixa' };
                    }
                }));
                data = enrichedCaixas;

            } else if (nivel === 1) {
                // Nível 1: Categorias (Vindo da API Detalhada da Caixinha)
                // Se filters for um objeto com id (o item clicado), usamos ele. Senão, tentamos pegar do estado ou do objeto filters
                const caixinhaId = filters?.id || filters?.caixinha?.id || filters?.caixa?.id || caixaSelecionado?.id;
                
                if (!caixinhaId) {
                    console.error('[useConciliacaoV2] Falha ao identificar ID da caixinha:', { filters, caixaSelecionado });
                    throw new Error('Caixinha não selecionada para nível 1');
                }

                console.log('[useConciliacaoV2] >>> ACESSANDO NOVA ROTA HIERÁRQUICA DO BACKEND <<<');
                console.log(`[useConciliacaoV2] Rota: /extrato/apresentar/caixinha/detalhado?caixinha=${caixinhaId}&mes=${filtroMes}&ano=${filtroAno}`);
                const detailedData = await workspaceConciliacaoService.fetchExtratoDetalhado(caixinhaId, { mes: filtroMes, ano: filtroAno });
                
                data = (detailedData.categorias || []).map(cat => {
                    // Preparamos as transações achatadas por precaução, mas agora usaremos subgrupos se existirem
                    const catTransacoes = cat.subgrupos 
                        ? cat.subgrupos.flatMap(sub => sub.transacoes || [])
                        : (cat.transacoes || []);
                    
                    const totalTransacoes = cat.total_transacoes || catTransacoes.length;
                    
                    return {
                        id: `cat_${cat.categoria}`,
                        nome: cat.categoria || 'Sem Categoria',
                        totalTransacoes: totalTransacoes,
                        totalValor: cat.valor_total || 0,
                        tipo: 'categoria',
                        subgrupos: cat.subgrupos || [],
                        transacoes: catTransacoes,
                        cor: categorias.find(c => c.nome === cat.categoria)?.cor || '#3b82f6'
                    };
                });

            } else if (nivel === 2) {
                // Nível 2: Subgrupos (Vindo da categoria selecionada)
                // Se o filtro for a própria categoria (passada diretamente), usamos ela. Senão, pegamos do estado.
                const categoriaItem = (filters?.subgrupos ? filters : filters?.categoria) || categoriaSelecionada;
                const rawSubgrupos = categoriaItem?.subgrupos || [];
                
                data = rawSubgrupos.map((sub, idx) => ({
                    id: `sub_${sub.nome_agrupamento}_${idx}`,
                    nome: sub.nome_agrupamento || 'Sem Identificação',
                    totalTransacoes: sub.total_transacoes || (sub.transacoes?.length || 0),
                    totalValor: sub.valor_total || 0,
                    tipo: 'subgrupo',
                    transacoes: sub.transacoes || [],
                    cor: '#94a3b8' // Slate 400
                }));

            } else if (nivel === 3) {
                // Nível 3: Transações (Vindo do item selecionado - pode ser categoria ou subgrupo)
                const itemPai = (filters?.transacoes ? filters : (filters?.subgrupo || subgroupSelecionado || filters?.categoria || categoriaSelecionada));
                const rawTransacoes = itemPai?.transacoes || [];
                
                data = rawTransacoes.map(t => ({
                    ...t,
                    id: t.id || t.idextrato || Math.random(),
                    data: t.data || t.dataEntrada || t.data_entrada || '',
                    valor: Number(t.valor || t.valor_total || 0),
                    descricao: t.descricao || t.historico || '',
                    beneficiario: t.beneficiario || t.beneficiario_pagador || ''
                }));
            }
            
            setBackendNavData(data);
            return data;
        } catch (error) {
            console.error('[useConciliacaoV2] Erro ao buscar dados de navegação:', error);
            setBackendNavData([]); // Limpar dados em caso de erro para evitar confusão visual
            toast.error('Erro ao navegar nos dados', 'Erro');
            return [];
        } finally {
            setIsNavLoading(false);
        }
    };

    // Navegação hierárquica usando dados do backend
    const navegarPara = async (tipo, item) => {
        console.log('[useConciliacaoV2] Navegando para:', tipo, item);
        
        // Limpa dados atuais para mostrar o loading logo
        setBackendNavData([]);
        
        let novoNivel = 0;
        if (tipo === 'caixa') {
            setCaixaSelecionado(item);
            setCategoriaSelecionada(null);
            setSubgroupSelecionado(null);
            novoNivel = 1;
            setCaminhoNavegacao([{ tipo: 'caixa', item }]);
        } else if (tipo === 'categoria') {
            setCategoriaSelecionada(item);
            setSubgroupSelecionado(null);
            novoNivel = 2;
            setCaminhoNavegacao(prev => [...prev, { tipo: 'categoria', item }]);
        } else if (tipo === 'subgrupo') {
            setSubgroupSelecionado(item);
            novoNivel = 3;
            setCaminhoNavegacao(prev => [...prev, { tipo: 'subgrupo', item }]);
        }

        setNivelNavegacao(novoNivel);
        await fetchNivelNavegacao(novoNivel, item);
    };

    const voltarNavegacao = async () => {
        if (nivelNavegacao === 0) return;
        
        const novoNivel = nivelNavegacao - 1;
        
        // Determina qual item passar como contexto para o filtro
        let itemContexto = null;
        if (novoNivel === 2) itemContexto = categoriaSelecionada;
        if (novoNivel === 1) itemContexto = caixaSelecionado;
        
        await fetchNivelNavegacao(novoNivel, itemContexto);
        
        if (nivelNavegacao === 3) setSubgroupSelecionado(null);
        if (nivelNavegacao === 2) setCategoriaSelecionada(null);
        if (nivelNavegacao === 1) setCaixaSelecionado(null);
        
        setNivelNavegacao(novoNivel);
        setCaminhoNavegacao(prev => prev.slice(0, novoNivel));
    };

    const navegarParaFrente = navegarPara;
    const navegarParaTras = voltarNavegacao;

    // Carregar dados iniciais do backend
    useEffect(() => {
        console.log('[useConciliacaoV2] useEffect executado - montando componente');
        
        const loadInitialData = async () => {
            console.log('[useConciliacaoV2] ========== INICIANDO CARREGAMENTO DE DADOS ==========');
            setIsLoading(true);
            
            try {
                // Buscar categorias, caixinhas e regras em paralelo
                console.log('[useConciliacaoV2] Chamando APIs em paralelo...');
                console.log('[useConciliacaoV2] - conciliacaoService.fetchCategories()');
                console.log('[useConciliacaoV2] - conciliacaoService.fetchCaixinhas()');
                console.log('[useConciliacaoV2] - conciliacaoService.fetchRules()');
                
                const [catRes, caiRes, regRes] = await Promise.all([
                    conciliacaoService.fetchCategories(),
                    conciliacaoService.fetchCaixinhas(),
                    conciliacaoService.fetchRules()
                ]);
                
                console.log('[useConciliacaoV2] ========== APIs RESPONDIDAS ==========');
                console.log('[useConciliacaoV2] Status das respostas:', {
                    catRes: catRes ? 'OK' : 'NULL',
                    caiRes: caiRes ? 'OK' : 'NULL',
                    regRes: regRes ? 'OK' : 'NULL'
                });

                console.log('[useConciliacaoV2] Respostas completas:', { 
                    catRes: catRes,
                    caiRes: caiRes,
                    regRes: regRes
                });
                
                console.log('[useConciliacaoV2] Tipo das respostas:', {
                    catResType: typeof catRes,
                    catResIsArray: Array.isArray(catRes),
                    catResKeys: catRes ? Object.keys(catRes) : null,
                    caiResType: typeof caiRes,
                    caiResIsArray: Array.isArray(caiRes),
                    caiResKeys: caiRes ? Object.keys(caiRes) : null
                });

                // Normalizar e mapear categorias
                const catData = normalizeBackendData(catRes);
                console.log('[useConciliacaoV2] Categorias normalizadas:', catData);
                const mappedCategorias = catData.map(item => {
                    const tipo = item.tipo ?? item.tipoMovimento ?? item.entrada_saida ?? 'saida';
                    return {
                        id: parseInt(item.idcategoria || item.id || 0),
                        nome: item.categoria || item.nome || 'Sem Categoria',
                        descricao: item.descricao || '',
                        cor: item.cor || '#3b82f6',
                        tipo,
                        tipoMovimento: tipo
                    };
                });
                setCategorias(mappedCategorias);
                console.log('[useConciliacaoV2] Categorias mapeadas:', mappedCategorias);

                // Normalizar e mapear caixinhas (caixas)
                const caiData = normalizeBackendData(caiRes);
                console.log('[useConciliacaoV2] Caixinhas normalizadas:', caiData);
                const mappedCaixas = caiData.map(item => ({
                    id: parseInt(item.idcaixinhas_financeiro || item.id || 0),
                    nome: item.caixinha || item.nome || 'Sem Nome',
                    descricao: item.descricao || '',
                    banco: item.banco || '',
                    agencia: item.agencia || '',
                    conta: item.conta || ''
                }));
                setCaixas(mappedCaixas);
                console.log('[useConciliacaoV2] Caixas mapeadas:', mappedCaixas);
                
                // Forçar carregamento do Nível 0 se a view ativa for 'conciliadas'
                if (initialSubView === 'conciliadas') {
                    console.log('[useConciliacaoV2] Carregando Nível 0 imediatamente após mapear caixas');
                    await fetchNivelNavegacao(0, { caixas: mappedCaixas });
                }

                // Normalizar e mapear regras
                const regData = normalizeBackendData(regRes);
                console.log('[useConciliacaoV2] Regras normalizadas:', regData);
                const mappedRegras = regData.map(item => ({
                    id: parseInt(item.idregras_financeiro || item.id || 0),
                    nome: item.regra || item.nome || item.condicional || 'Sem Nome',
                    condicao: item.condicional || item.condicao || '',
                    categoriaId: item.categoria ? parseInt(item.categoria) : null,
                    caixaId: item.caixinha ? parseInt(item.caixinha) : null,
                    beneficiario: item.beneficiario_pagador || item.beneficiario || null
                }));
                setRegras(mappedRegras);
                console.log('[useConciliacaoV2] Regras mapeadas:', mappedRegras);

                // Buscar transações apenas se for necessário ou se estiver na aba correta (Lazy Loading)
                if (initialSubView === 'extrato-completo' || initialSubView === 'nao-categorizadas') {
                    console.log('[useConciliacaoV2] Buscando extrato completo para visualização específica...');
                    const extrato = (await workspaceConciliacaoService.fetchExtrato({ mes: filtroMes, ano: filtroAno })) || [];
                    setExtratoCompleto(extrato);
                    const conciliadas = extrato.filter(t => t?.status === 'CONCILIADA' && t?.categoriaId);
                    const naoCategorizadas = extrato.filter(t => t?.status === 'PENDENTE' || !t?.categoriaId);
                    setTransacoesConciliadas(conciliadas);
                    setTransacoesNaoCategorizadas(naoCategorizadas);
                }

                console.log('[useConciliacaoV2] ========== CARREGAMENTO CONCLUÍDO COM SUCESSO ==========');

            } catch (error) {
                console.error('[useConciliacaoV2] ========== ERRO AO CARREGAR DADOS ==========');
                console.error('[useConciliacaoV2] Erro:', error);
                console.error('[useConciliacaoV2] Mensagem:', error.message);
                console.error('[useConciliacaoV2] Stack trace:', error.stack);
                console.error('[useConciliacaoV2] Response:', error.response);
                console.error('[useConciliacaoV2] Status:', error.response?.status);
                console.error('[useConciliacaoV2] Data:', error.response?.data);
                
                try {
                    toast.error('Erro ao carregar dados de conciliação', 'Erro');
                } catch (toastError) {
                    console.error('[useConciliacaoV2] Erro ao exibir toast:', toastError);
                }
                
                // Fallback para mocks em caso de erro
                console.log('[useConciliacaoV2] Usando dados mock como fallback');
                setCaixas(MOCK_CAIXAS);
                setCategorias(MOCK_CATEGORIAS);
                setRegras(MOCK_REGRAS);
                setTransacoesNaoCategorizadas(MOCK_TRANSACOES_NAO_CATEGORIZADAS);
                setTransacoesConciliadas(MOCK_TRANSACOES_CONCILIADAS);
                setExtratoCompleto([...MOCK_TRANSACOES_CONCILIADAS, ...MOCK_TRANSACOES_NAO_CATEGORIZADAS]);
            } finally {
                console.log('[useConciliacaoV2] Finalizando carregamento, setIsLoading(false)');
                setIsLoading(false);
            }
        };

        console.log('[useConciliacaoV2] Chamando loadInitialData()...');
        loadInitialData();
    }, []);

    // Atualizar visualização hierárquica quando filtros mudarem
    useEffect(() => {
        if (!isLoading && activeSubView === 'conciliadas' && nivelNavegacao === 0) {
            console.log('[useConciliacaoV2] Filtros mudaram, atualizando Nível 0...');
            fetchNivelNavegacao(0);
        }
    }, [filtroMes, filtroAno, activeSubView, isLoading, nivelNavegacao]);

    // Recarregar extrato quando filtros mudarem (apenas após carregamento inicial)
    const [hasInitialLoad, setHasInitialLoad] = useState(false);
    
    useEffect(() => {
        if (!isLoading && hasInitialLoad) {
            const loadExtrato = async () => {
                try {
                    console.log(`[useConciliacaoV2] Recarregando extrato devido a mudança de ${activeSubView === 'nao-categorizadas' ? 'aba' : 'filtros'}...`);
                    const extrato = (await workspaceConciliacaoService.fetchExtrato({ mes: filtroMes, ano: filtroAno })) || [];
                    setExtratoCompleto(extrato);
                    // Separar transações conciliadas e não categorizadas
                    const conciliadas = extrato.filter(t => t?.status === 'CONCILIADA' && t?.categoriaId);
                    const naoCategorizadas = extrato.filter(t => t?.status === 'PENDENTE' || !t?.categoriaId);
                    
                    setTransacoesConciliadas(conciliadas);
                    setTransacoesNaoCategorizadas(naoCategorizadas);
                } catch (error) {
                    console.error('[useConciliacaoV2] Erro ao recarregar extrato:', error);
                }
            };

            loadExtrato();
        } else if (!isLoading && !hasInitialLoad) {
            setHasInitialLoad(true);
        }
    }, [filtroAno, filtroMes, activeSubView, isLoading, hasInitialLoad]);

    // Transações filtradas e organizadas (MANTIDO APENAS SE NECESSÁRIO PARA COMPATIBILIDADE, MAS AGORA REDUNDANTE)
    const transacoesOrganizadas = useMemo(() => {
        // Agora o backend já retorna os dados organizados via fetchExtratoDetalhado
        // Retornamos vazio ou estrutura mínima para não quebrar componentes que ainda usem isso (se houver)
        return {};
    }, [transacoesConciliadas]);

    // KPIs
    const kpis = useMemo(() => {
        const totalConciliadas = transacoesConciliadas.length;
        const totalNaoCategorizadas = transacoesNaoCategorizadas.length;
        const valorConciliado = transacoesConciliadas.reduce((acc, t) => acc + Math.abs(t.valor), 0);
        const valorNaoCategorizado = transacoesNaoCategorizadas.reduce((acc, t) => acc + Math.abs(t.valor), 0);
        
        return {
            totalConciliadas,
            totalNaoCategorizadas,
            valorConciliado,
            valorNaoCategorizado,
            totalRegras: regras.length,
            totalCategorias: categorias.length,
            totalCaixas: caixas.length
        };
    }, [transacoesConciliadas, transacoesNaoCategorizadas, regras, categorias, caixas]);

    // Ações para Caixas
    const createCaixa = async (caixaData) => {
        if (!caixaData.nome?.trim()) {
            toast.error('Nome do caixa é obrigatório', 'Campos Obrigatórios');
            return null;
        }

        try {
            const response = await conciliacaoService.createCaixinha({
                caixinha: caixaData.nome,
                descricao: caixaData.descricao || '',
                ...caixaData
            });
            const raw = response?.data ?? response;
            const data = normalizeBackendData(raw);
            const newCaixa = {
                id: parseInt(data[0]?.idcaixinhas_financeiro || data[0]?.id || caixas.length + 1),
                nome: data[0]?.caixinha || caixaData.nome,
                descricao: data[0]?.descricao || caixaData.descricao || '',
                banco: caixaData.banco || '',
                agencia: caixaData.agencia || '',
                conta: caixaData.conta || ''
            };
            setCaixas(prev => [...prev, newCaixa]);
            toast.success('Caixa criado com sucesso!', 'Sucesso');
            return newCaixa;
        } catch (error) {
            toast.error('Erro ao criar caixa', 'Erro');
            return null;
        }
    };

    const updateCaixa = async (id, caixaData) => {
        if (!caixaData.nome?.trim()) {
            toast.error('Nome do caixa é obrigatório', 'Campos Obrigatórios');
            return;
        }

        try {
            await conciliacaoService.updateCaixinha({
                idcaixinhas_financeiro: id,
                caixinha: caixaData.nome,
                descricao: caixaData.descricao || '',
                ...caixaData
            });
            setCaixas(prev => prev.map(c => c.id === id ? { ...c, ...caixaData } : c));
            toast.success('Caixa atualizado com sucesso!', 'Sucesso');
        } catch (error) {
            toast.error('Erro ao atualizar caixa', 'Erro');
        }
    };

    const deleteCaixa = async (id) => {
        try {
            await conciliacaoService.deleteCaixinha(id);
            setCaixas(prev => prev.filter(c => c.id !== id));
            toast.success('Caixa excluído com sucesso!', 'Sucesso');
        } catch (error) {
            toast.error('Erro ao excluir caixa', 'Erro');
        }
    };

    // Ações para Categorias
    const createCategoria = async (categoriaData) => {
        if (!categoriaData.nome?.trim()) {
            toast.error('Nome da categoria é obrigatório', 'Campos Obrigatórios');
            return null;
        }

        const tipo = categoriaData.tipo ?? categoriaData.tipoMovimento ?? 'saida';
        try {
            const response = await conciliacaoService.createCategory({
                categoria: categoriaData.nome,
                descricao: categoriaData.descricao || '',
                cor: categoriaData.cor || '#3b82f6',
                tipo
            });
            const raw = response?.data ?? response;
            const data = normalizeBackendData(raw);
            const newCategoria = {
                id: parseInt(data[0]?.idcategoria || data[0]?.id || categorias.length + 1),
                nome: data[0]?.categoria || categoriaData.nome,
                descricao: data[0]?.descricao || categoriaData.descricao || '',
                cor: categoriaData.cor || '#3b82f6',
                tipo: data[0]?.tipo ?? tipo,
                tipoMovimento: data[0]?.tipo ?? tipo
            };
            setCategorias(prev => [...prev, newCategoria]);
            toast.success('Categoria criada com sucesso!', 'Sucesso');
            return newCategoria;
        } catch (error) {
            toast.error('Erro ao criar categoria', 'Erro');
            return null;
        }
    };

    const updateCategoria = async (id, categoriaData) => {
        if (!categoriaData.nome?.trim()) {
            toast.error('Nome da categoria é obrigatório', 'Campos Obrigatórios');
            return;
        }

        const tipo = categoriaData.tipo ?? categoriaData.tipoMovimento ?? 'saida';
        try {
            await conciliacaoService.updateCategory({
                idcategoria: id,
                categoria: categoriaData.nome,
                descricao: categoriaData.descricao || '',
                cor: categoriaData.cor || '#3b82f6',
                tipo
            });
            setCategorias(prev => prev.map(c => c.id === id ? { ...c, ...categoriaData, tipo, tipoMovimento: tipo } : c));
            toast.success('Categoria atualizada com sucesso!', 'Sucesso');
        } catch (error) {
            toast.error('Erro ao atualizar categoria', 'Erro');
        }
    };

    const deleteCategoria = async (id) => {
        try {
            await conciliacaoService.deleteCategory(id);
            setCategorias(prev => prev.filter(c => c.id !== id));
            toast.success('Categoria excluída com sucesso!', 'Sucesso');
        } catch (error) {
            toast.error('Erro ao excluir categoria', 'Erro');
        }
    };

    // Conciliação automática silenciosa (DESATIVADA - Lógica movida para backend)
    /*
    const executarConciliacaoSilenciosa = async () => {
        try {
            console.log('[useConciliacaoV2] Executando conciliação automática silenciosa...');
            
            const resultado = await processarReconciliacao({
                onProgress: () => {
                    // Sem feedback visual durante operações automáticas
                }
            });
            
            console.log('[useConciliacaoV2] Conciliação silenciosa concluída:', resultado);
            
            // Recarregar dados após conciliação
            await recarregarDados();
            
            if (resultado.atualizados > 0) {
                console.log(`[useConciliacaoV2] ${resultado.atualizados} transações atualizadas automaticamente`);
            }
            
            return resultado;
        } catch (error) {
            console.error('[useConciliacaoV2] Erro na conciliação silenciosa:', error);
            // Não mostra erro para o usuário em conciliações automáticas
            return { sucesso: false, erro: error };
        }
    };
    */

    // Ações para Regras
    const createRegra = async (regraData) => {
        const camposObrigatorios = [];
        if (!regraData.nome?.trim() && !regraData.condicao?.trim()) camposObrigatorios.push('Nome ou Condição da Regra');
        if (!regraData.categoriaId && !regraData.categoria) camposObrigatorios.push('Categoria');

        if (camposObrigatorios.length > 0) {
            toast.notifyFields(camposObrigatorios);
            return null;
        }

        try {
            const now = new Date();
            const data_envio = `${now.getFullYear()}-${now.getMonth() + 1}-${now.getDate()}`;
            const response = await conciliacaoService.createRule({
                regra: regraData.nome || regraData.condicao || '',
                condicional: regraData.condicao || regraData.nome || '',
                categoria: String(regraData.categoriaId || regraData.categoria || '0'),
                caixinha: String(regraData.caixaId || regraData.caixinha || '0'),
                beneficiario_pagador: regraData.beneficiario || '',
                data_envio
            });
            const raw = response?.data ?? response;
            const data = normalizeBackendData(raw);
            const newRegra = {
                id: parseInt(data[0]?.idregras_financeiro || data[0]?.id || regras.length + 1),
                nome: data[0]?.regra || regraData.nome || regraData.condicao || '',
                condicao: data[0]?.condicional || regraData.condicao || '',
                categoriaId: parseInt(data[0]?.categoria || regraData.categoriaId || 0),
                caixaId: parseInt(data[0]?.caixinha || regraData.caixaId || 0),
                beneficiario: data[0]?.beneficiario_pagador || regraData.beneficiario || null
            };
            setRegras(prev => [...prev, newRegra]);
            toast.success('Regra criada com sucesso!', 'Sucesso');
            
            // Executar conciliação automática após criar regra (DESATIVADO)
            /*
            console.log('[useConciliacaoV2] Regra criada, executando conciliação automática...');
            executarConciliacaoSilenciosa().catch(err => {
                console.error('[useConciliacaoV2] Erro ao executar conciliação após criar regra:', err);
            });
            */
            
            return newRegra;
        } catch (error) {
            toast.error('Erro ao criar regra', 'Erro');
            return null;
        }
    };

    const updateRegra = async (id, regraData) => {
        const camposObrigatorios = [];
        if (!regraData.nome?.trim() && !regraData.condicao?.trim()) camposObrigatorios.push('Nome ou Condição da Regra');
        if (!regraData.categoriaId && !regraData.categoria) camposObrigatorios.push('Categoria');

        if (camposObrigatorios.length > 0) {
            toast.notifyFields(camposObrigatorios);
            return;
        }

        try {
            await conciliacaoService.updateRule({
                idregras_financeiro: id,
                regra: regraData.nome || regraData.condicao || '',
                condicional: regraData.condicao || regraData.nome || '',
                categoria: String(regraData.categoriaId || regraData.categoria || '0'),
                caixinha: String(regraData.caixaId || regraData.caixinha || '0'),
                beneficiario_pagador: regraData.beneficiario || ''
            });
            setRegras(prev => prev.map(r => r.id === id ? { ...r, ...regraData } : r));
            toast.success('Regra atualizada com sucesso!', 'Sucesso');
            
            // Executar conciliação automática após atualizar regra (DESATIVADO)
            /*
            console.log('[useConciliacaoV2] Regra atualizada, executando conciliação automática para ajustar transações...');
            executarConciliacaoSilenciosa().catch(err => {
                console.error('[useConciliacaoV2] Erro ao executar conciliação após atualizar regra:', err);
            });
            */
        } catch (error) {
            toast.error('Erro ao atualizar regra', 'Erro');
        }
    };

    const deleteRegra = async (id) => {
        try {
            await conciliacaoService.deleteRule(id);
            setRegras(prev => prev.filter(r => r.id !== id));
            toast.success('Regra excluída com sucesso!', 'Sucesso');
        } catch (error) {
            toast.error('Erro ao excluir regra', 'Erro');
        }
    };

    // Conciliação automática com feedback visual (DESATIVADA)
    const executarConciliacaoAutomatica = async () => {
        // setIsReconciliando(true);
        // setProgressoReconciliacao({ processados: 0, total: 0 });
        
        try {
            console.log('[useConciliacaoV2] Conciliação automática agora é feita pelo backend.');
            toast.success('Conciliação automática delegada ao backend', 'Info');
            
            /*
            console.log('[useConciliacaoV2] Iniciando conciliação automática...');
            toast.success('Conciliação automática iniciada', 'Processando...');
            
            const resultado = await processarReconciliacao({
                onProgress: (processados, total) => {
                    setProgressoReconciliacao({ processados, total });
                }
            });
            
            console.log('[useConciliacaoV2] Conciliação concluída:', resultado);
            
            // Recarregar dados após conciliação
            await recarregarDados();
            
            toast.success(
                `Conciliação concluída! ${resultado.atualizados} transações atualizadas de ${resultado.processados} processadas.`,
                'Conciliação Concluída'
            );
            
            return resultado;
            */
           return { sucesso: true };
        } catch (error) {
            console.error('[useConciliacaoV2] Erro na conciliação automática:', error);
            toast.error('Erro ao executar conciliação automática', 'Erro');
            throw error;
        } finally {
            // setIsReconciliando(false);
            // setProgressoReconciliacao({ processados: 0, total: 0 });
        }
    };

    // Reset de todas as transações (DESATIVADO)
    const resetarTransacoes = async () => {
        if (!window.confirm('Esta ação não está mais disponível no frontend. Contate o suporte.')) {
            return;
        }
        
        /*
        setIsReconciliando(true);
        setProgressoReconciliacao({ processados: 0, total: 0 });
        
        try {
            console.log('[useConciliacaoV2] Iniciando reset de transações...');
            toast.success('Reset de transações iniciado', 'Processando...');
            
            const resultado = await resetarTodasTransacoes({
                onProgress: (processados, total) => {
                    setProgressoReconciliacao({ processados, total });
                }
            });
            
            console.log('[useConciliacaoV2] Reset concluído:', resultado);
            
            // Recarregar dados após reset
            await recarregarDados();
            
            toast.success(
                `Reset concluído! ${resultado.processados} transações resetadas.`,
                'Reset Concluído'
            );
            
            return resultado;
        } catch (error) {
            console.error('[useConciliacaoV2] Erro no reset:', error);
            toast.error('Erro ao resetar transações', 'Erro');
            throw error;
        } finally {
            setIsReconciliando(false);
            setProgressoReconciliacao({ processados: 0, total: 0 });
        }
        */
    };


    // Categorizar transação não categorizada
    const categorizarTransacao = async (transacaoId, dadosCategorizacao) => {
        // Tenta encontrar a transação em qualquer uma das listas
        const transacao = transacoesNaoCategorizadas.find(t => t.id === transacaoId) ||
                         transacoesConciliadas.find(t => t.id === transacaoId) ||
                         extratoCompleto.find(t => t.id === transacaoId);
                         
        if (!transacao) {
            console.warn('[categorizarTransacao] Transação não encontrada nas listas locais:', transacaoId);
            // Mesmo não encontrando localmente, vamos tentar enviar para o backend se tivermos o ID
            // Isso permite corrigir casos onde o estado local está desincronizado
        }

        try {
            // Atualizar transação no backend usando as rotas da lógica antiga
            const objeto = {
                idextrato: transacaoId,
                categoria: String(dadosCategorizacao.categoriaId || '0'),
                regra: '0',
                beneficiario_pagador: dadosCategorizacao.beneficiario || '',
                caixinha: String(dadosCategorizacao.caixaId || '0'),
                tag: dadosCategorizacao.tag || '',
                Resutl: true
            };

            // Executar updates em paralelo (conforme lógica antiga)
            // Nota: O código original usa "UPDATE" como método HTTP customizado
            await Promise.all([
                api.post('/regra_categoria/edit', objeto),
                api.request({
                    url: '/beneficiario_pagador/inserir',
                    method: 'UPDATE',
                    data: objeto
                }),
                api.request({
                    url: '/caixinha_extrato/inserir',
                    method: 'UPDATE',
                    data: objeto
                }),
                dadosCategorizacao.tag ? api.post('/tag/inserir', { idextrato: transacaoId, tag: dadosCategorizacao.tag }) : Promise.resolve()
            ]);

            // Recarregar extrato do backend
            const extrato = await workspaceConciliacaoService.fetchExtrato();
            setExtratoCompleto(Array.isArray(extrato) ? extrato : []);
            // Separar transações conciliadas e não categorizadas
            const conciliadas = extrato.filter(t => t.status === 'CONCILIADA' && t.categoriaId);
            const naoCategorizadas = extrato.filter(t => t.status === 'PENDENTE' || !t.categoriaId);
            
            setTransacoesConciliadas(conciliadas);
            setTransacoesNaoCategorizadas(naoCategorizadas);

            toast.success('Transação categorizada e movida para conciliadas', 'Categorização Concluída');
            
            // Executar conciliação automática após categorização manual (DESATIVADO)
            /*
            console.log('[useConciliacaoV2] Transação categorizada manualmente, executando conciliação automática...');
            executarConciliacaoSilenciosa().catch(err => {
                console.error('[useConciliacaoV2] Erro ao executar conciliação após categorizar transação:', err);
            });
            */
        } catch (error) {
            console.error('[useConciliacaoV2] Erro ao categorizar transação:', error);
            toast.error('Erro ao categorizar transação', 'Erro');
        }
    };


    const exportarPDF = async () => {
        try {
            toast.success('Gerando extrato PDF...', 'Processando');
            const blob = await extratoService.exportPDF();
            const url = window.URL.createObjectURL(blob);
            const a = document.createElement('a');
            a.href = url;
            a.download = `Extrato_${filtroMes}_${filtroAno}.pdf`;
            document.body.appendChild(a);
            a.click();
            document.body.removeChild(a);
            window.URL.revokeObjectURL(url);
            toast.success('Extrato exportado com sucesso!', 'Sucesso');
        } catch (err) {
            console.error('[useConciliacaoV2] Erro ao exportar PDF:', err);
            toast.error('Erro ao exportar extrato PDF', 'Erro');
        }
    };

    const fetchSomaCategorias = async (tipoOperacao) => {
        try {
            return await extratoService.getSomaPorCategoria({
                mes: filtroMes,
                ano: filtroAno,
                tipoOperacao
            });
        } catch (err) {
            console.error('[useConciliacaoV2] Erro ao buscar soma por categoria:', err);
            return [];
        }
    };

        return {
            state: {
                activeSubView,
                extratoCompleto,
                caixas,
                categorias,
                regras,
                transacoesConciliadas,
                transacoesNaoCategorizadas,
                transacoesOrganizadas,
                kpis,
                filtroCaixa,
                filtroAno,
                filtroMes,
                filtroCategoria,
                filtroRegra,
                nivelNavegacao,
                caminhoNavegacao,
                caixaSelecionado,
                categoriaSelecionada,
                subgroupSelecionado,
                isLoading,
                isNavLoading,
                backendNavData,
                isReconciliando: false, // Mock para compatibilidade
                progressoReconciliacao: { processados: 0, total: 0 } // Mock para compatibilidade
            },
            actions: {
                setActiveSubView,
                setFiltroCaixa,
                setFiltroAno,
                setFiltroMes,
                setFiltroCategoria,
                setFiltroRegra,
                createCaixa,
                updateCaixa,
                deleteCaixa,
                createCategoria,
                updateCategoria,
                deleteCategoria,
                createRegra,
                updateRegra,
                deleteRegra,
                categorizarTransacao,
                executarConciliacaoAutomatica,
                resetarTransacoes,
                navegarPara,
                voltarNavegacao,
                exportarPDF,
                fetchSomaCategorias,
                fetchNivelNavegacao
            }
        };
}
