import { useState, useEffect, useMemo } from 'react';
import { workspaceDespesasService } from '@/services/workspaceDespesasService';
import { toast } from 'sonner';

/**
 * Hook para gerenciar a lógica de Despesas do Workspace
 * Integra com workspaceDespesasService e gerencia estado de contas a pagar e extrato
 * 
 * Baseado na lógica antiga do financeiro vanilla, adaptado para React e o novo visual
 */
export const useWorkspaceDespesas = () => {
  // Estados de dados
  const [contasAPagar, setContasAPagar] = useState([]);
  const [extratoSaidas, setExtratoSaidas] = useState([]);
  const [fluxoCaixa, setFluxoCaixa] = useState([]);
  const [categorias, setCategorias] = useState([]);
  
  // Estados de loading e erro
  const [isLoadingContas, setIsLoadingContas] = useState(false);
  const [isLoadingExtrato, setIsLoadingExtrato] = useState(false);
  const [isLoadingFluxo, setIsLoadingFluxo] = useState(false);
  const [error, setError] = useState(null);
  
  // Filtros
  const [filtroMes, setFiltroMes] = useState(new Date().getMonth() + 1);
  const [filtroAno, setFiltroAno] = useState(new Date().getFullYear());

  /**
   * Carrega contas a pagar planejadas
   * Rota: /contas_a_pagar/apresentar
   */
  const loadContasAPagar = async () => {
    setIsLoadingContas(true);
    setError(null);
    
    try {
      const data = await workspaceDespesasService.fetchContasAPagar();
      setContasAPagar(Array.isArray(data) ? data : []);
    } catch (err) {
      console.error('Erro ao carregar contas a pagar:', err);
      setError(err.message || 'Erro ao carregar contas a pagar');
      toast.error('Erro ao carregar contas a pagar');
      setContasAPagar([]);
    } finally {
      setIsLoadingContas(false);
    }
  };

  /**
   * Carrega extrato de saídas (tipoOperacao === "D")
   * Rota: /extrato/apresentar (filtrado por tipoOperacao === "D")
   */
  const loadExtratoSaidas = async () => {
    setIsLoadingExtrato(true);
    setError(null);
    
    try {
      const data = await workspaceDespesasService.fetchExtratoSaidas();
      setExtratoSaidas(Array.isArray(data) ? data : []);
    } catch (err) {
      console.error('Erro ao carregar extrato de saídas:', err);
      setError(err.message || 'Erro ao carregar extrato de saídas');
      toast.error('Erro ao carregar extrato de saídas');
      setExtratoSaidas([]);
    } finally {
      setIsLoadingExtrato(false);
    }
  };

  /**
   * Carrega fluxo de caixa mensal/anual
   * Rota: /extrato/fluxo (retorna { mensal: [...] })
   */
  const loadFluxoCaixa = async () => {
    setIsLoadingFluxo(true);
    setError(null);
    
    try {
      const data = await workspaceDespesasService.fetchFluxoCaixa();
      setFluxoCaixa(Array.isArray(data) ? data : []);
    } catch (err) {
      console.error('Erro ao carregar fluxo de caixa:', err);
      setError(err.message || 'Erro ao carregar fluxo de caixa');
      toast.error('Erro ao carregar fluxo de caixa');
      setFluxoCaixa([]);
    } finally {
      setIsLoadingFluxo(false);
    }
  };

  /**
   * Carrega categorias para gráfico de despesas
   * Rota: /categorias/apresentar
   */
  const loadCategorias = async () => {
    try {
      const data = await workspaceDespesasService.fetchCategoriasDespesas();
      setCategorias(Array.isArray(data) ? data : []);
    } catch (err) {
      console.error('Erro ao carregar categorias:', err);
      // Não mostra erro para categorias, usa dados mock
      setCategorias([]);
    }
  };

  /**
   * Carrega todos os dados iniciais
   */
  useEffect(() => {
    loadContasAPagar();
    loadExtratoSaidas();
    loadFluxoCaixa();
    loadCategorias();
    // eslint-disable-next-line react-hooks/exhaustive-deps
  }, []);

  /**
   * Recarrega dados quando filtros mudam
   */
  useEffect(() => {
    // Se houver filtros no backend, recarregar aqui
    // Por enquanto, os filtros são apenas visuais (client-side)
    // eslint-disable-next-line react-hooks/exhaustive-deps
  }, [filtroMes, filtroAno]);

  /**
   * Contas a pagar filtradas por período (client-side)
   * Baseado na lógica antiga: filtra por data_vencimento
   */
  const contasFiltradas = useMemo(() => {
    return contasAPagar.filter(conta => {
      if (!conta.data_vencimento) return true;
      
      try {
        const dataVenc = new Date(conta.data_vencimento);
        const mesConta = dataVenc.getMonth() + 1;
        const anoConta = dataVenc.getFullYear();
        
        return mesConta === filtroMes && anoConta === filtroAno;
      } catch {
        return true; // Se data inválida, inclui na lista
      }
    });
  }, [contasAPagar, filtroMes, filtroAno]);

  /**
   * Extrato filtrado por período (client-side)
   * Baseado na lógica antiga: filtra por dataEntrada
   */
  const extratoFiltrado = useMemo(() => {
    return extratoSaidas.filter(item => {
      if (!item.data) return true;
      
      try {
        const dataItem = new Date(item.data);
        const mesItem = dataItem.getMonth() + 1;
        const anoItem = dataItem.getFullYear();
        
        return mesItem === filtroMes && anoItem === filtroAno;
      } catch {
        return true; // Se data inválida, inclui na lista
      }
    });
  }, [extratoSaidas, filtroMes, filtroAno]);

  /**
   * KPIs calculados
   * Baseado na lógica antiga: Total Planejado, Total Executado, Diferença
   */
  const kpis = useMemo(() => {
    // Lado planejado desativado no Workspace:
    // qualquer métrica de "planejado" deve permanecer zerada até que
    // as funcionalidades de planejamento sejam implementadas de fato.
    const totalPlanejado = 0;
    const totalExecutado = extratoFiltrado.reduce((acc, e) => acc + (Number(e.valor) || 0), 0);
    // Como não há planejamento ativo, também zeramos a diferença
    // para evitar interpretações equivocadas.
    const diferenca = 0;

    return {
      totalPlanejado,
      totalExecutado,
      diferenca
    };
  }, [contasFiltradas, extratoFiltrado]);

  /**
   * Dados de comparação para gráfico (Planejado vs Executado)
   * Baseado na lógica antiga: agrupa por mês
   */
  const dadosComparacao = useMemo(() => {
    // Agrupa por mês
    const agrupado = fluxoCaixa.reduce((acc, item) => {
      const mes = item.mes || item.name || '';
      if (!acc[mes]) {
        acc[mes] = { name: mes, planejado: 0, executado: 0 };
      }
      // Mantém planejado sempre 0 no Workspace enquanto não houver
      // funcionalidades reais de planejamento.
      acc[mes].planejado = 0;
      acc[mes].executado += Number(item.executado || item.saida || 0);
      return acc;
    }, {});

    return Object.values(agrupado);
  }, [fluxoCaixa]);

  /**
   * Dados de categorias para gráfico
   * Baseado na lógica antiga: agrupa extrato por categoria
   */
  const dadosCategorias = useMemo(() => {
    // Agrupa extrato por categoria
    const agrupado = extratoFiltrado.reduce((acc, item) => {
      const cat = item.categoria || 'Outros';
      if (!acc[cat]) {
        acc[cat] = { name: cat, value: 0 };
      }
      acc[cat].value += Number(item.valor || 0);
      return acc;
    }, {});

    return Object.values(agrupado);
  }, [extratoFiltrado]);

  return {
    state: {
      contasAPagar: contasFiltradas,
      extratoSaidas: extratoFiltrado,
      fluxoCaixa: dadosComparacao,
      categorias: dadosCategorias.length > 0 ? dadosCategorias : categorias,
      kpis,
      isLoading: isLoadingContas || isLoadingExtrato || isLoadingFluxo,
      error,
      filtroMes,
      filtroAno
    },
    actions: {
      setFiltroMes,
      setFiltroAno,
      loadContasAPagar,
      loadExtratoSaidas,
      loadFluxoCaixa
    }
  };
};
