import { useState, useEffect, useCallback } from 'react';
import { workspaceConciliacaoService } from '@/services/workspaceConciliacaoService';
import WorkspaceConciliacaoAPI from '@/services/workspaceConciliacaoAPI';
import { toast } from 'sonner';

export const useWorkspaceConciliacao = () => {
  const [activeTab, setActiveTab] = useState('pendencias');
  const [pendentes, setPendentes] = useState([]);
  const [cruzamentos, setCruzamentos] = useState([]);
  const [isLoading, setIsLoading] = useState(false);
  const [filtroCaixinha, setFiltroCaixinha] = useState(null);
  const [filtroMes, setFiltroMes] = useState(new Date().getMonth() + 1);
  const [filtroAno, setFiltroAno] = useState(new Date().getFullYear());
  const [searchTerm, setSearchTerm] = useState('');

  // Modal states
  const [isCategorizarModalOpen, setIsCategorizarModalOpen] = useState(false);
  const [isCriarRegraModalOpen, setIsCriarRegraModalOpen] = useState(false);
  const [selectedTransaction, setSelectedTransaction] = useState(null);
  const [isSubmitting, setIsSubmitting] = useState(false);

  // Data states
  const [categories, setCategories] = useState([]);
  const [caixinhas, setCaixinhas] = useState([]);
  const [rules, setRules] = useState([]);

  // KPIs
  const [kpis, setKpis] = useState({
    saldoBancario: 0,
    valorPendentes: 0,
    pendenciasCriticas: 0,
    totalPendentes: 0
  });

  // Load categories, caixinhas, and rules
  const loadMetadata = useCallback(async () => {
    try {
      const [cats, cax, rls] = await Promise.all([
        WorkspaceConciliacaoAPI.fetchCategories(),
        WorkspaceConciliacaoAPI.fetchCaixinhas(),
        WorkspaceConciliacaoAPI.fetchRules()
      ]);
      setCategories(cats);
      setCaixinhas(cax);
      setRules(rls);
    } catch (error) {
      console.error('Erro ao carregar metadados:', error);
      toast.error('Erro ao carregar categorias, caixinhas ou regras');
    }
  }, []);

  // Load pendentes
  const loadPendentes = useCallback(async () => {
    setIsLoading(true);
    try {
      const data = await workspaceConciliacaoService.fetchPendentes();
      setPendentes(data);
      
      // Calculate KPIs
      const valorPendentes = data.reduce((sum, t) => sum + (t.valor || 0), 0);
      const pendenciasCriticas = data.filter(t => {
        const daysDiff = Math.floor((new Date() - new Date(t.data)) / (1000 * 60 * 60 * 24));
        return daysDiff > 30;
      }).length;
      
      setKpis(prev => ({
        ...prev,
        valorPendentes,
        pendenciasCriticas,
        totalPendentes: data.length
      }));
    } catch (error) {
      console.error('Erro ao carregar pendentes:', error);
      toast.error('Erro ao carregar transações pendentes');
    } finally {
      setIsLoading(false);
    }
  }, []);

  // Load cruzamentos
  const loadCruzamentos = useCallback(async () => {
    setIsLoading(true);
    try {
      const filters = {};
      if (filtroCaixinha) filters.caixinha = filtroCaixinha;
      if (filtroMes) filters.mes = filtroMes;
      if (filtroAno) filters.ano = filtroAno;
      
      const data = await workspaceConciliacaoService.fetchCruzamentos(filters);
      setCruzamentos(data);
    } catch (error) {
      console.error('Erro ao carregar cruzamentos:', error);
      toast.error('Erro ao carregar cruzamentos');
    } finally {
      setIsLoading(false);
    }
  }, [filtroCaixinha, filtroMes, filtroAno]);

  // Open categorizar modal
  const handleOpenCategorizarModal = useCallback((transaction) => {
    setSelectedTransaction(transaction);
    setIsCategorizarModalOpen(true);
  }, []);

  // Open criar regra modal
  const handleOpenCriarRegraModal = useCallback((transaction) => {
    setSelectedTransaction(transaction);
    setIsCriarRegraModalOpen(true);
  }, []);

  // Close modals
  const handleCloseCategorizarModal = useCallback(() => {
    setIsCategorizarModalOpen(false);
    setSelectedTransaction(null);
  }, []);

  const handleCloseCriarRegraModal = useCallback(() => {
    setIsCriarRegraModalOpen(false);
    setSelectedTransaction(null);
  }, []);

  // Switch from categorizar to criar regra
  const handleSwitchToCriarRegra = useCallback((formData) => {
    setIsCategorizarModalOpen(false);
    // Store formData in selectedTransaction for the criar regra modal
    setSelectedTransaction(prev => ({
      ...prev,
      formData
    }));
    setIsCriarRegraModalOpen(true);
  }, []);

  // Submit categorizar transaction
  const handleSubmitCategorizar = useCallback(async (formData) => {
    setIsSubmitting(true);
    try {
      const { idextrato, categoria, caixinha, beneficiario_pagador } = formData;
      
      // Update category
      if (categoria) {
        await WorkspaceConciliacaoAPI.updateTransactionCategory(idextrato, categoria);
      }
      
      // Update caixinha
      if (caixinha && caixinha !== '0') {
        await WorkspaceConciliacaoAPI.updateTransactionBox(idextrato, caixinha);
      }
      
      // Update beneficiary
      if (beneficiario_pagador) {
        await WorkspaceConciliacaoAPI.updateTransactionBeneficiary(idextrato, beneficiario_pagador);
      }
      
      toast.success('Transação categorizada com sucesso!');
      handleCloseCategorizarModal();
      await loadPendentes();
      await loadCruzamentos();
    } catch (error) {
      console.error('Erro ao categorizar transação:', error);
      toast.error('Erro ao categorizar transação');
    } finally {
      setIsSubmitting(false);
    }
  }, [loadPendentes, loadCruzamentos, handleCloseCategorizarModal]);

  // Submit criar regra
  const handleSubmitCriarRegra = useCallback(async (formData) => {
    setIsSubmitting(true);
    try {
      const payload = {
        regra: formData.regra || formData.name || '',
        condicional: formData.condicional || formData.condition || '',
        categoria: formData.categoria || formData.categoryId || '',
        caixinha: formData.caixinha || '0',
        beneficiario_pagador: formData.beneficiario_pagador || formData.beneficiario || '0'
      };
      
      await WorkspaceConciliacaoAPI.createRule(payload);
      toast.success('Regra criada com sucesso!');
      handleCloseCriarRegraModal();
      await loadMetadata();
    } catch (error) {
      console.error('Erro ao criar regra:', error);
      toast.error('Erro ao criar regra');
    } finally {
      setIsSubmitting(false);
    }
  }, [loadMetadata, handleCloseCriarRegraModal]);

  // Initial load
  useEffect(() => {
    loadMetadata();
    loadPendentes();
  }, [loadMetadata, loadPendentes]);

  // Reload cruzamentos when filters change
  useEffect(() => {
    if (activeTab === 'cruzamento') {
      loadCruzamentos();
    }
  }, [activeTab, filtroCaixinha, filtroMes, filtroAno, loadCruzamentos]);

  return {
    state: {
      activeTab,
      pendentes,
      cruzamentos,
      isLoading,
      filtroCaixinha,
      filtroMes,
      filtroAno,
      searchTerm,
      kpis,
      // Modal states
      isCategorizarModalOpen,
      isCriarRegraModalOpen,
      selectedTransaction,
      isSubmitting,
      // Data
      categories,
      caixinhas,
      rules
    },
    actions: {
      setActiveTab,
      setFiltroCaixinha,
      setFiltroMes,
      setFiltroAno,
      setSearchTerm,
      loadPendentes,
      loadCruzamentos,
      loadMetadata,
      // Modal actions
      handleOpenCategorizarModal,
      handleOpenCriarRegraModal,
      handleCloseCategorizarModal,
      handleCloseCriarRegraModal,
      handleSwitchToCriarRegra,
      handleSubmitCategorizar,
      handleSubmitCriarRegra
    }
  };
};
