"use client";

import { useCallback, useEffect, useState } from "react";
import { getCustomers } from "@/services/customer-service";
import { getEquipment } from "@/services/equipment-service";
import {
  convertReservationToRental,
  createReservation,
  deleteReservation,
  getReservationById,
  getReservations,
  getReservationStats,
  updateReservation,
} from "@/services/reservation-service";
import { Customer } from "@/types/customer";
import { Equipment } from "@/types/equipment";
import {
  CreateReservationDTO,
  Reservation,
  ReservationFilterParams,
  ReservationStats,
  ReservationStatus,
  UpdateReservationDTO,
} from "@/types/reservation";

export function useReservations() {
  const [reservations, setReservations] = useState<Reservation[]>([]);
  const [customers, setCustomersList] = useState<Customer[]>([]);
  const [equipmentList, setEquipmentList] = useState<Equipment[]>([]);

  const [stats, setStats] = useState<ReservationStats>({
    total: 0,
    confirmed: 0,
    pending: 0,
    converted: 0,
    totalDeposit: 0,
    conversionRate: 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 [selectedReservation, setSelectedReservation] = useState<Reservation | null>(null);
  const [isDetailLoading, setIsDetailLoading] = useState(false);

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

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

      setReservations(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 reservas:", err);
    } finally {
      setIsLoading(false);
    }
  }, [filters]);

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

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

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

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

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

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

  const loadReservationDetails = async (id: string) => {
    setIsDetailLoading(true);
    try {
      const details = await getReservationById(id);
      setSelectedReservation(details);
    } catch (err) {
      console.error("Erro ao carregar detalhes da reserva:", err);
    } finally {
      setIsDetailLoading(false);
    }
  };

  const handleCreateReservation = async (data: CreateReservationDTO) => {
    setIsSaving(true);
    try {
      const created = await createReservation(data);
      await loadData();
      return created;
    } finally {
      setIsSaving(false);
    }
  };

  const handleUpdateReservation = async (id: string, data: UpdateReservationDTO) => {
    setIsSaving(true);
    try {
      const updated = await updateReservation(id, data);
      await loadData();
      if (selectedReservation?.id === id) {
        setSelectedReservation((prev) => (prev ? { ...prev, ...updated } : null));
      }
      return updated;
    } finally {
      setIsSaving(false);
    }
  };

  const handleConvertToRental = async (id: string) => {
    setIsSaving(true);
    try {
      const updated = await convertReservationToRental(id);
      await loadData();
      if (selectedReservation?.id === id) {
        setSelectedReservation((prev) => (prev ? { ...prev, ...updated } : null));
      }
      return updated;
    } finally {
      setIsSaving(false);
    }
  };

  const handleDeleteReservation = async (id: string) => {
    try {
      await deleteReservation(id);
      if (selectedReservation?.id === id) {
        setSelectedReservation(null);
      }
      await loadData();
    } catch (err) {
      console.error("Erro ao excluir reserva:", err);
      throw err;
    }
  };

  return {
    reservations,
    customers,
    equipmentList,
    stats,
    totalItems,
    totalPages,
    currentPage,
    filters,
    isLoading,
    isSaving,
    selectedReservation,
    isDetailLoading,
    setSelectedReservation,
    setSearch,
    setStatusFilter,
    setCustomerFilter,
    setEquipmentFilter,
    setPage,
    loadData,
    loadReservationDetails,
    createReservation: handleCreateReservation,
    updateReservation: handleUpdateReservation,
    convertReservationToRental: handleConvertToRental,
    deleteReservation: handleDeleteReservation,
  };
}