"use client";

import { useCallback, useEffect, useState } from "react";
import { getCustomers } from "@/services/customer-service";
import { getEquipment } from "@/services/equipment-service";
import {
  createScheduleEvent,
  deleteScheduleEvent,
  getScheduleEventById,
  getScheduleEvents,
  getScheduleStats,
  updateScheduleEvent,
} from "@/services/schedule-service";
import { Customer } from "@/types/customer";
import { Equipment } from "@/types/equipment";
import {
  CreateScheduleEventDTO,
  ScheduleEvent,
  ScheduleEventType,
  ScheduleFilterParams,
  ScheduleStats,
  UpdateScheduleEventDTO,
} from "@/types/schedule";

export function useSchedule() {
  const [events, setEvents] = useState<ScheduleEvent[]>([]);
  const [customers, setCustomersList] = useState<Customer[]>([]);
  const [equipmentList, setEquipmentList] = useState<Equipment[]>([]);

  const [stats, setStats] = useState<ScheduleStats>({
    totalEvents: 0,
    todayEvents: 0,
    scheduledDeliveries: 0,
    scheduledReturns: 0,
    pendingMaintenance: 0,
  });

  const [isLoading, setIsLoading] = useState(true);
  const [isSaving, setIsSaving] = useState(false);
  const [selectedEvent, setSelectedEvent] = useState<ScheduleEvent | null>(null);
  const [viewMode, setViewMode] = useState<"CALENDAR" | "LIST">("CALENDAR");

  const [filters, setFilters] = useState<ScheduleFilterParams>({
    search: "",
    type: "ALL",
    status: "ALL",
  });

  const loadData = useCallback(async () => {
    setIsLoading(true);
    try {
      const [eventsRes, statsData, custRes, eqRes] = await Promise.all([
        getScheduleEvents(filters),
        getScheduleStats(),
        getCustomers({ limit: 100 }),
        getEquipment({ limit: 100 }),
      ]);

      setEvents(eventsRes.items);
      setStats(statsData);
      setCustomersList(custRes.items);
      setEquipmentList(eqRes.items);
    } catch (err) {
      console.error("Erro ao carregar agenda operacional:", err);
    } finally {
      setIsLoading(false);
    }
  }, [filters]);

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

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

  const setTypeFilter = (type: ScheduleEventType | "ALL") => {
    setFilters((prev) => ({ ...prev, type }));
  };

  const setStatusFilter = (status: any) => {
    setFilters((prev) => ({ ...prev, status }));
  };

  const loadEventDetails = async (id: string) => {
    try {
      const details = await getScheduleEventById(id);
      setSelectedEvent(details);
    } catch (err) {
      console.error("Erro ao carregar detalhes do compromisso:", err);
    }
  };

  const handleCreateEvent = async (data: CreateScheduleEventDTO) => {
    setIsSaving(true);
    try {
      const created = await createScheduleEvent(data);
      await loadData();
      return created;
    } finally {
      setIsSaving(false);
    }
  };

  const handleUpdateEvent = async (id: string, data: UpdateScheduleEventDTO) => {
    setIsSaving(true);
    try {
      const updated = await updateScheduleEvent(id, data);
      await loadData();
      if (selectedEvent?.id === id) {
        setSelectedEvent((prev) => (prev ? { ...prev, ...updated } : null));
      }
      return updated;
    } finally {
      setIsSaving(false);
    }
  };

  const handleCompleteEvent = async (id: string) => {
    setIsSaving(true);
    try {
      await updateScheduleEvent(id, { status: "COMPLETED" });
      await loadData();
      if (selectedEvent?.id === id) {
        setSelectedEvent((prev) => (prev ? { ...prev, status: "COMPLETED" } : null));
      }
    } finally {
      setIsSaving(false);
    }
  };

  const handleDeleteEvent = async (id: string) => {
    try {
      await deleteScheduleEvent(id);
      if (selectedEvent?.id === id) {
        setSelectedEvent(null);
      }
      await loadData();
    } catch (err) {
      console.error("Erro ao excluir compromisso da agenda:", err);
      throw err;
    }
  };

  return {
    events,
    customers,
    equipmentList,
    stats,
    viewMode,
    filters,
    isLoading,
    isSaving,
    selectedEvent,
    setViewMode,
    setSelectedEvent,
    setSearch,
    setTypeFilter,
    setStatusFilter,
    loadData,
    loadEventDetails,
    createEvent: handleCreateEvent,
    updateEvent: handleUpdateEvent,
    completeEvent: handleCompleteEvent,
    deleteEvent: handleDeleteEvent,
  };
}