"use client";

import { useCallback, useEffect, useState } from "react";
import {
  createCategory,
  deleteCategory,
  getCategories,
  getCategoryById,
  getCategoryStats,
  updateCategory,
} from "@/services/category-service";
import {
  Category,
  CategoryFilterParams,
  CategoryStats,
  CreateCategoryDTO,
  UpdateCategoryDTO,
} from "@/types/category";

export function useCategories() {
  const [categories, setCategories] = useState<Category[]>([]);
  const [stats, setStats] = useState<CategoryStats>({
    totalCategories: 0,
    totalEquipment: 0,
    topCategory: null,
  });

  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 [selectedCategory, setSelectedCategory] = useState<Category | null>(null);
  const [isDetailLoading, setIsDetailLoading] = useState(false);

  const [filters, setFilters] = useState<CategoryFilterParams>({
    search: "",
    page: 1,
    limit: 12,
  });

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

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

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

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

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

  const loadCategoryDetails = async (id: string) => {
    setIsDetailLoading(true);
    try {
      const details = await getCategoryById(id);
      setSelectedCategory(details);
    } catch (err) {
      console.error("Erro ao carregar detalhes da categoria:", err);
    } finally {
      setIsDetailLoading(false);
    }
  };

  const handleCreateCategory = async (data: CreateCategoryDTO) => {
    setIsSaving(true);
    try {
      const created = await createCategory(data);
      await loadData();
      return created;
    } finally {
      setIsSaving(false);
    }
  };

  const handleUpdateCategory = async (id: string, data: UpdateCategoryDTO) => {
    setIsSaving(true);
    try {
      const updated = await updateCategory(id, data);
      await loadData();
      if (selectedCategory?.id === id) {
        setSelectedCategory((prev) => (prev ? { ...prev, ...updated } : null));
      }
      return updated;
    } finally {
      setIsSaving(false);
    }
  };

  const handleDeleteCategory = async (id: string) => {
    try {
      await deleteCategory(id);
      if (selectedCategory?.id === id) {
        setSelectedCategory(null);
      }
      await loadData();
    } catch (err) {
      console.error("Erro ao excluir categoria:", err);
      throw err;
    }
  };

  return {
    categories,
    stats,
    totalItems,
    totalPages,
    currentPage,
    filters,
    isLoading,
    isSaving,
    selectedCategory,
    isDetailLoading,
    setSelectedCategory,
    setSearch,
    setPage,
    loadData,
    loadCategoryDetails,
    createCategory: handleCreateCategory,
    updateCategory: handleUpdateCategory,
    deleteCategory: handleDeleteCategory,
  };
}