"use client";

import { useCallback, useEffect, useState } from "react";
import { getCustomers } from "@/services/customer-service";
import {
  createFinancialEntry,
  getCashFlow,
  getFinanceStats,
  getPayables,
  getReceivables,
  payPayable,
  payReceivable,
} from "@/services/finance-service";
import { Customer } from "@/types/customer";
import {
  AccountPayable,
  AccountReceivable,
  CashMovement,
  CreateFinancialEntryDTO,
  FinanceFilterParams,
  FinanceStats,
} from "@/types/finance";

export function useFinance() {
  const [receivables, setReceivables] = useState<AccountReceivable[]>([]);
  const [payables, setPayables] = useState<AccountPayable[]>([]);
  const [cashFlow, setCashFlow] = useState<CashMovement[]>([]);
  const [customers, setCustomersList] = useState<Customer[]>([]);

  const [stats, setStats] = useState<FinanceStats>({
    totalReceivable: 0,
    totalPayable: 0,
    netProjected: 0,
    overdueAmount: 0,
  });

  const [isLoading, setIsLoading] = useState(true);
  const [isSaving, setIsSaving] = useState(false);
  const [activeTab, setActiveTab] = useState<"RECEIVABLES" | "PAYABLES" | "CASH_FLOW">("RECEIVABLES");

  const [filters, setFilters] = useState<FinanceFilterParams>({
    search: "",
    status: "ALL",
    page: 1,
    limit: 10, // Menor limite para paginação ficar visível e funcional
  });

  const [recTotal, setRecTotal] = useState(0);
  const [recPages, setRecPages] = useState(1);
  const [payTotal, setPayTotal] = useState(0);
  const [payPages, setPayPages] = useState(1);
  const [cfTotal, setCfTotal] = useState(0);
  const [cfPages, setCfPages] = useState(1);

  const loadData = useCallback(async () => {
    setIsLoading(true);
    try {
      const [recRes, payRes, cfRes, statsData, custRes] = await Promise.all([
        getReceivables(filters),
        getPayables(filters),
        getCashFlow(filters),
        getFinanceStats(),
        getCustomers({ limit: 100 }),
      ]);

      setReceivables(recRes.items || []);
      setPayables(payRes.items || []);
      setCashFlow(Array.isArray(cfRes.items) ? cfRes.items : Array.isArray(cfRes) ? cfRes : []);
      setStats(statsData);
      setCustomersList(custRes.items || []);

      setRecTotal(recRes.total || 0);
      setRecPages(recRes.totalPages || 1);

      setPayTotal(payRes.total || 0);
      setPayPages(payRes.totalPages || 1);

      const cfCount = cfRes.total ?? (Array.isArray(cfRes.items) ? cfRes.items.length : Array.isArray(cfRes) ? cfRes.length : 0);
      setCfTotal(cfCount);
      setCfPages(cfRes.totalPages ?? 1);
    } catch (err) {
      console.error("Erro ao carregar dados financeiros:", err);
    } finally {
      setIsLoading(false);
    }
  }, [filters]);

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

  const totalItems =
    activeTab === "RECEIVABLES"
      ? recTotal
      : activeTab === "PAYABLES"
      ? payTotal
      : cfTotal;

  const totalPages =
    activeTab === "RECEIVABLES"
      ? recPages
      : activeTab === "PAYABLES"
      ? payPages
      : cfPages;

  const handleSetActiveTab = (tab: "RECEIVABLES" | "PAYABLES" | "CASH_FLOW") => {
    setActiveTab(tab);
    setFilters((prev) => ({ ...prev, page: 1 }));
  };

  const setSearch = (search: string) => {
    setFilters((prev) => ({ ...prev, search, page: 1 }));
  };

  const setStatusFilter = (status: any) => {
    setFilters((prev) => ({ ...prev, status, page: 1 }));
  };

  const setPage = (page: number) => {
    setFilters((prev) => ({ ...prev, page }));
  };

  const setLimit = (limit: number) => {
    setFilters((prev) => ({ ...prev, limit, page: 1 }));
  };

  const handleCreateEntry = async (data: CreateFinancialEntryDTO) => {
    setIsSaving(true);
    try {
      await createFinancialEntry(data);
      await loadData();
    } finally {
      setIsSaving(false);
    }
  };

  const handlePayReceivable = async (id: string, body?: { amountPaid?: number; paidAt?: string; newDueDate?: string }) => {
    setIsSaving(true);
    try {
      await payReceivable(id, body);
      await loadData();
    } finally {
      setIsSaving(false);
    }
  };

  const handlePayPayable = async (id: string, body?: { amountPaid?: number; paidAt?: string; newDueDate?: string }) => {
    setIsSaving(true);
    try {
      await payPayable(id, body);
      await loadData();
    } finally {
      setIsSaving(false);
    }
  };

  return {
    receivables,
    payables,
    cashFlow,
    customers,
    stats,
    activeTab,
    filters,
    isLoading,
    isSaving,
    totalItems,
    totalPages,
    currentPage: filters.page || 1,
    itemsPerPage: filters.limit || 10,
    setActiveTab: handleSetActiveTab,
    setSearch,
    setStatusFilter,
    setPage,
    setLimit,
    loadData,
    createEntry: handleCreateEntry,
    payReceivable: handlePayReceivable,
    payPayable: handlePayPayable,
  };
}