"use client";

import { useCallback, useEffect, useState } from "react";
import {
  createCustomer,
  deleteCustomer,
  getCustomerById,
  getCustomers,
  getCustomerStats,
  updateCustomer,
} from "@/services/customer-service";
import {
  CreateCustomerDTO,
  Customer,
  CustomerFilterParams,
  CustomerStats,
  CustomerStatus,
  UpdateCustomerDTO,
} from "@/types/customer";

export function useCustomers() {
  const [customers, setCustomers] = useState<Customer[]>([]);
  const [stats, setStats] = useState<CustomerStats>({
    total: 0,
    active: 0,
    inactive: 0,
    delinquent: 0,
    totalCreditLimit: 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 [selectedCustomer, setSelectedCustomer] = useState<Customer | null>(null);
  const [isDetailLoading, setIsDetailLoading] = useState(false);

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

  const loadData = useCallback(async () => {
    setIsLoading(true);
    try {
      const [res, statsData] = await Promise.all([
        getCustomers(filters),
        getCustomerStats(),
      ]);

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

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

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

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

  const setTypeFilter = (type: CustomerFilterParams["type"]) => {
    setFilters((prev) => ({ ...prev, type, page: 1 }));
  };

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

  const loadCustomerDetails = async (id: string) => {
    setIsDetailLoading(true);
    try {
      const details = await getCustomerById(id);
      setSelectedCustomer(details);
    } catch (err) {
      console.error("Erro ao carregar detalhes do cliente:", err);
    } finally {
      setIsDetailLoading(false);
    }
  };

  const handleCreateCustomer = async (data: CreateCustomerDTO) => {
    setIsSaving(true);
    try {
      const created = await createCustomer(data);
      await loadData();
      return created;
    } finally {
      setIsSaving(false);
    }
  };

  const handleUpdateCustomer = async (id: string, data: UpdateCustomerDTO) => {
    setIsSaving(true);
    try {
      const updated = await updateCustomer(id, data);
      await loadData();
      if (selectedCustomer?.id === id) {
        setSelectedCustomer((prev) => (prev ? { ...prev, ...updated } : null));
      }
      return updated;
    } finally {
      setIsSaving(false);
    }
  };

  const handleDeleteCustomer = async (id: string) => {
    try {
      await deleteCustomer(id);
      if (selectedCustomer?.id === id) {
        setSelectedCustomer(null);
      }
      await loadData();
    } catch (err) {
      console.error("Erro ao excluir cliente:", err);
      throw err;
    }
  };

  const handleToggleStatus = async (id: string, currentStatus: CustomerStatus) => {
    const nextStatus: CustomerStatus =
      currentStatus === "ACTIVE" ? "INACTIVE" : "ACTIVE";
    return handleUpdateCustomer(id, { status: nextStatus });
  };

  return {
    customers,
    stats,
    totalItems,
    totalPages,
    currentPage,
    filters,
    isLoading,
    isSaving,
    selectedCustomer,
    isDetailLoading,
    setSelectedCustomer,
    setSearch,
    setStatusFilter,
    setTypeFilter,
    setPage,
    loadData,
    loadCustomerDetails,
    createCustomer: handleCreateCustomer,
    updateCustomer: handleUpdateCustomer,
    deleteCustomer: handleDeleteCustomer,
    toggleStatus: handleToggleStatus,
  };
}