"use client";

import { useCallback, useEffect, useState } from "react";
import { getEquipment } from "@/services/equipment-service";
import {
  createServiceOrder,
  deleteServiceOrder,
  getServiceOrderById,
  getServiceOrders,
  getServiceOrderStats,
  updateServiceOrder,
} from "@/services/maintenance-service";
import { getSuppliers } from "@/services/supplier-service";
import { Equipment } from "@/types/equipment";
import { Supplier } from "@/types/supplier";
import {
  CreateServiceOrderDTO,
  MaintenanceFilters,
  MaintenanceStatus,
  ServiceOrder,
  ServiceOrderStats,
  UpdateServiceOrderDTO,
} from "@/types/maintenance";

export function useMaintenance() {
  const [serviceOrders, setServiceOrders] = useState<ServiceOrder[]>([]);
  const [equipmentList, setEquipmentList] = useState<Equipment[]>([]);
  const [suppliersList, setSuppliersList] = useState<Supplier[]>([]);

  const [stats, setStats] = useState<ServiceOrderStats>({
    total: 0,
    open: 0,
    inProgress: 0,
    done: 0,
    canceled: 0,
    totalCost: 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 [selectedServiceOrder, setSelectedServiceOrder] = useState<ServiceOrder | null>(null);
  const [isDetailLoading, setIsDetailLoading] = useState(false);

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

  const loadData = useCallback(async () => {
    setIsLoading(true);
    try {
      const [soRes, statsData, equipRes, suppRes] = await Promise.all([
        getServiceOrders(filters),
        getServiceOrderStats(),
        getEquipment({ limit: 100 }),
        getSuppliers(),
      ]);

      setServiceOrders(soRes.items);
      setTotalItems(soRes.total);
      setTotalPages(soRes.totalPages);
      setCurrentPage(soRes.page);
      setStats(statsData);
      setEquipmentList(equipRes.items);
      setSuppliersList(suppRes.items);
    } catch (err) {
      console.error("Erro ao carregar ordens de serviço:", err);
    } finally {
      setIsLoading(false);
    }
  }, [filters]);

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

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

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

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

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

  const loadServiceOrderDetails = async (id: string) => {
    setIsDetailLoading(true);
    try {
      const details = await getServiceOrderById(id);
      setSelectedServiceOrder(details);
    } catch (err) {
      console.error("Erro ao carregar detalhes da ordem de serviço:", err);
    } finally {
      setIsDetailLoading(false);
    }
  };

  const handleCreateServiceOrder = async (data: CreateServiceOrderDTO) => {
    setIsSaving(true);
    try {
      const created = await createServiceOrder(data);
      await loadData();
      return created;
    } finally {
      setIsSaving(false);
    }
  };

  const handleUpdateServiceOrder = async (id: string, data: UpdateServiceOrderDTO) => {
    setIsSaving(true);
    try {
      const updated = await updateServiceOrder(id, data);
      await loadData();
      if (selectedServiceOrder?.id === id) {
        setSelectedServiceOrder((prev) => (prev ? { ...prev, ...updated } : null));
      }
      return updated;
    } finally {
      setIsSaving(false);
    }
  };

  const handleDeleteServiceOrder = async (id: string) => {
    try {
      await deleteServiceOrder(id);
      if (selectedServiceOrder?.id === id) {
        setSelectedServiceOrder(null);
      }
      await loadData();
    } catch (err) {
      console.error("Erro ao excluir ordem de serviço:", err);
      throw err;
    }
  };

  return {
    serviceOrders,
    equipmentList,
    suppliersList,
    stats,
    totalItems,
    totalPages,
    currentPage,
    filters,
    isLoading,
    isSaving,
    selectedServiceOrder,
    isDetailLoading,
    setSelectedServiceOrder,
    setSearch,
    setStatusFilter,
    setEquipmentFilter,
    setPage,
    loadData,
    loadServiceOrderDetails,
    createServiceOrder: handleCreateServiceOrder,
    updateServiceOrder: handleUpdateServiceOrder,
    deleteServiceOrder: handleDeleteServiceOrder,
  };
}