"use client";

import { useCallback, useEffect, useState } from "react";
import {
  createSupplier,
  deleteSupplier,
  getSupplierById,
  getSuppliers,
  getSupplierStats,
  updateSupplier,
} from "@/services/supplier-service";
import {
  CreateSupplierDTO,
  Supplier,
  SupplierFilterParams,
  SupplierStats,
  UpdateSupplierDTO,
} from "@/types/supplier";

export function useSuppliers() {
  const [suppliers, setSuppliers] = useState<Supplier[]>([]);

  const [stats, setStats] = useState<SupplierStats>({
    total: 0,
    activeWithPayables: 0,
    totalPayableAmount: 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 [selectedSupplier, setSelectedSupplier] = useState<Supplier | null>(null);
  const [isDetailLoading, setIsDetailLoading] = useState(false);

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

  const loadData = useCallback(async () => {
    setIsLoading(true);
    try {
      const [supRes, statsData] = await Promise.all([
        getSuppliers(filters),
        getSupplierStats(),
      ]);

      setSuppliers(supRes.items);
      setTotalItems(supRes.total);
      setTotalPages(supRes.totalPages);
      setCurrentPage(supRes.page);
      setStats(statsData);
    } catch (err) {
      console.error("Erro ao carregar fornecedores:", err);
    } finally {
      setIsLoading(false);
    }
  }, [filters]);

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

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

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

  const loadSupplierDetails = async (id: string) => {
    setIsDetailLoading(true);
    try {
      const details = await getSupplierById(id);
      setSelectedSupplier(details);
    } catch (err) {
      console.error("Erro ao carregar detalhes do fornecedor:", err);
    } finally {
      setIsDetailLoading(false);
    }
  };

  const handleCreateSupplier = async (data: CreateSupplierDTO) => {
    setIsSaving(true);
    try {
      const created = await createSupplier(data);
      await loadData();
      return created;
    } finally {
      setIsSaving(false);
    }
  };

  const handleUpdateSupplier = async (id: string, data: UpdateSupplierDTO) => {
    setIsSaving(true);
    try {
      const updated = await updateSupplier(id, data);
      await loadData();
      if (selectedSupplier?.id === id) {
        setSelectedSupplier((prev) => (prev ? { ...prev, ...updated } : null));
      }
      return updated;
    } finally {
      setIsSaving(false);
    }
  };

  const handleDeleteSupplier = async (id: string) => {
    try {
      await deleteSupplier(id);
      if (selectedSupplier?.id === id) {
        setSelectedSupplier(null);
      }
      await loadData();
    } catch (err) {
      console.error("Erro ao excluir fornecedor:", err);
      throw err;
    }
  };

  return {
    suppliers,
    stats,
    totalItems,
    totalPages,
    currentPage,
    filters,
    isLoading,
    isSaving,
    selectedSupplier,
    isDetailLoading,
    setSelectedSupplier,
    setSearch,
    setPage,
    loadData,
    loadSupplierDetails,
    createSupplier: handleCreateSupplier,
    updateSupplier: handleUpdateSupplier,
    deleteSupplier: handleDeleteSupplier,
  };
}