"use client";

import { useCallback, useEffect, useState } from "react";
import { getCustomers } from "@/services/customer-service";
import {
  createContract,
  deleteContract,
  getContractById,
  getContracts,
  getContractStats,
  updateContract,
} from "@/services/contract-service";
import {
  Contract,
  ContractFilterParams,
  ContractStats,
  ContractStatus,
  CreateContractDTO,
  UpdateContractDTO,
} from "@/types/contract";
import { Customer } from "@/types/customer";

export function useContracts() {
  const [contracts, setContracts] = useState<Contract[]>([]);
  const [customers, setCustomersList] = useState<Customer[]>([]);

  const [stats, setStats] = useState<ContractStats>({
    total: 0,
    signed: 0,
    pendingSignature: 0,
    draft: 0,
    totalContractedValue: 0,
  });

  const [totalItems, setTotalItems] = useState(0);
  const [totalPages, setTotalPages] = useState(1);
  const [currentPage, setCurrentPage] = useState(1);

  const [isLoading, setIsLoading] = useState(true);
  const [isSaving, setIsSaving] = useState(false);
  const [selectedContract, setSelectedContract] = useState<Contract | null>(null);
  const [isDetailLoading, setIsDetailLoading] = useState(false);

  const [filters, setFilters] = useState<ContractFilterParams>({
    search: "",
    status: "ALL",
    customerId: "ALL",
    page: 1,
    limit: 10,
  });

  const loadData = useCallback(async () => {
    setIsLoading(true);
    try {
      const [res, statsData, custRes] = await Promise.all([
        getContracts(filters),
        getContractStats(),
        getCustomers({ limit: 100 }),
      ]);

      setContracts(res.items);
      setTotalItems(res.total);
      setTotalPages(res.totalPages);
      setCurrentPage(res.page);
      setStats(statsData);
      setCustomersList(custRes.items);
    } catch (err) {
      console.error("Erro ao carregar contratos:", err);
    } finally {
      setIsLoading(false);
    }
  }, [filters]);

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

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

  const setStatusFilter = (status: ContractStatus | "ALL") => {
    setFilters((prev) => ({ ...prev, status, page: 1 }));
  };

  const setCustomerFilter = (customerId: string | "ALL") => {
    setFilters((prev) => ({ ...prev, customerId, page: 1 }));
  };

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

  const loadContractDetails = async (id: string) => {
    setIsDetailLoading(true);
    try {
      const details = await getContractById(id);
      setSelectedContract(details);
    } catch (err) {
      console.error("Erro ao carregar detalhes do contrato:", err);
    } finally {
      setIsDetailLoading(false);
    }
  };

  const handleCreateContract = async (data: CreateContractDTO) => {
    setIsSaving(true);
    try {
      const created = await createContract(data);
      await loadData();
      return created;
    } finally {
      setIsSaving(false);
    }
  };

  const handleUpdateContract = async (id: string, data: UpdateContractDTO) => {
    setIsSaving(true);
    try {
      const updated = await updateContract(id, data);
      await loadData();
      if (selectedContract?.id === id) {
        setSelectedContract((prev) => (prev ? { ...prev, ...updated } : null));
      }
      return updated;
    } finally {
      setIsSaving(false);
    }
  };

  const handleDeleteContract = async (id: string) => {
    try {
      await deleteContract(id);
      if (selectedContract?.id === id) {
        setSelectedContract(null);
      }
      await loadData();
    } catch (err) {
      console.error("Erro ao excluir contrato:", err);
      throw err;
    }
  };

  return {
    contracts,
    customers,
    stats,
    totalItems,
    totalPages,
    currentPage,
    filters,
    isLoading,
    isSaving,
    selectedContract,
    isDetailLoading,
    setSelectedContract,
    setSearch,
    setStatusFilter,
    setCustomerFilter,
    setPage,
    loadData,
    loadContractDetails,
    createContract: handleCreateContract,
    updateContract: handleUpdateContract,
    deleteContract: handleDeleteContract,
  };
}