"use client";

import { useCallback, useEffect, useState } from "react";
import { getCustomers } from "@/services/customer-service";
import { getEquipment } from "@/services/equipment-service";
import {
  createRental,
  deleteRental,
  getRentalById,
  getRentals,
  getRentalStats,
  updateRental,
} from "@/services/rental-service";
import { Customer } from "@/types/customer";
import { Equipment } from "@/types/equipment";
import {
  CreateRentalDTO,
  Rental,
  RentalFilterParams,
  RentalStats,
  RentalStatus,
  UpdateRentalDTO,
} from "@/types/rental";

export function useRentals() {
  const [rentals, setRentals] = useState<Rental[]>([]);
  const [customers, setCustomersList] = useState<Customer[]>([]);
  const [equipmentList, setEquipmentList] = useState<Equipment[]>([]);

  const [stats, setStats] = useState<RentalStats>({
    total: 0,
    inProgress: 0,
    quote: 0,
    finished: 0,
    reserved: 0,
    canceled: 0,
    totalRevenue: 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 [selectedRental, setSelectedRental] = useState<Rental | null>(null);
  const [isDetailLoading, setIsDetailLoading] = useState(false);

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

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

      setRentals(res.items);
      setTotalItems(res.total);
      setTotalPages(res.totalPages);
      setCurrentPage(res.page);
      setStats(statsData);
      setCustomersList(custRes.items);
      setEquipmentList(equipRes.items);
    } catch (err) {
      console.error("Erro ao carregar locações:", err);
    } finally {
      setIsLoading(false);
    }
  }, [filters]);

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

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

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

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

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

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

  const handleCreateRental = async (data: CreateRentalDTO) => {
    setIsSaving(true);
    try {
      const created = await createRental(data);
      await loadData();
      return created;
    } finally {
      setIsSaving(false);
    }
  };

  const handleUpdateRental = async (id: string, data: UpdateRentalDTO) => {
    setIsSaving(true);
    try {
      const updated = await updateRental(id, data);
      await loadData();
      if (selectedRental?.id === id) {
        setSelectedRental((prev) => (prev ? { ...prev, ...updated } : null));
      }
      return updated;
    } finally {
      setIsSaving(false);
    }
  };

  const handleDeleteRental = async (id: string) => {
    try {
      await deleteRental(id);
      if (selectedRental?.id === id) {
        setSelectedRental(null);
      }
      await loadData();
    } catch (err) {
      console.error("Erro ao excluir contrato de locação:", err);
      throw err;
    }
  };

  const handleUpdateStatus = async (id: string, newStatus: RentalStatus) => {
    return handleUpdateRental(id, { status: newStatus });
  };

  return {
    rentals,
    customers,
    equipmentList,
    stats,
    totalItems,
    totalPages,
    currentPage,
    filters,
    isLoading,
    isSaving,
    selectedRental,
    isDetailLoading,
    setSelectedRental,
    setSearch,
    setStatusFilter,
    setCustomerFilter,
    setPage,
    loadData,
    loadRentalDetails,
    createRental: handleCreateRental,
    updateRental: handleUpdateRental,
    deleteRental: handleDeleteRental,
    updateStatus: handleUpdateStatus,
  };
}