"use client";

import { useCallback, useEffect, useState } from "react";
import {
  createRoleGroup,
  createUser,
  deleteRoleGroup,
  deleteUser,
  getCompanyProfile,
  getRoleGroups,
  getSystemPreferences,
  getUsersList,
  resetRoleGroups,
  updateCompanyProfile,
  updateRoleGroup,
  updateSystemPreferences,
  updateUser,
} from "@/services/settings-service";
import {
  CompanyProfile,
  RoleGroup,
  SettingsTabType,
  SystemPreferences,
  UserProfile,
} from "@/types/settings";

export function useSettings() {
  const [activeTab, setActiveTab] = useState<SettingsTabType>("company");

  const [company, setCompany] = useState<CompanyProfile | null>(null);
  const [users, setUsers] = useState<UserProfile[]>([]);
  const [roles, setRoles] = useState<RoleGroup[]>([]);
  const [preferences, setPreferences] = useState<SystemPreferences | null>(null);

  const [isLoading, setIsLoading] = useState(true);
  const [isSaving, setIsSaving] = useState(false);

  const loadData = useCallback(async () => {
    setIsLoading(true);
    try {
      const [compRes, usersRes, rolesRes, prefRes] = await Promise.all([
        getCompanyProfile(),
        getUsersList(),
        getRoleGroups(),
        getSystemPreferences(),
      ]);

      setCompany(compRes);
      setUsers(usersRes);
      setRoles(rolesRes);
      setPreferences(prefRes);
    } catch (err) {
      console.error("Erro ao carregar configurações:", err);
    } finally {
      setIsLoading(false);
    }
  }, []);

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

  const handleUpdateCompany = async (data: Partial<CompanyProfile>) => {
    setIsSaving(true);
    try {
      const updated = await updateCompanyProfile(data);
      setCompany(updated);
      if (typeof window !== "undefined") {
        window.dispatchEvent(new CustomEvent("company-profile-updated", { detail: updated }));
      }
      return updated;
    } finally {
      setIsSaving(false);
    }
  };

  const handleCreateUser = async (data: Partial<UserProfile>) => {
    setIsSaving(true);
    try {
      const created = await createUser(data);
      await loadData();
      return created;
    } finally {
      setIsSaving(false);
    }
  };

  const handleUpdateUser = async (id: string, data: Partial<UserProfile>) => {
    setIsSaving(true);
    try {
      const updated = await updateUser(id, data);
      await loadData();
      return updated;
    } finally {
      setIsSaving(false);
    }
  };

  const handleDeleteUser = async (id: string) => {
    await deleteUser(id);
    await loadData();
  };

  const handleCreateRole = async (data: { name: string; description: string; permissions: any[] }) => {
    setIsSaving(true);
    try {
      const created = await createRoleGroup(data);
      await loadData();
      return created;
    } finally {
      setIsSaving(false);
    }
  };

  const handleUpdateRole = async (id: string, data: Partial<RoleGroup>) => {
    setIsSaving(true);
    try {
      const updated = await updateRoleGroup(id, data);
      await loadData();
      return updated;
    } finally {
      setIsSaving(false);
    }
  };

  const handleDeleteRole = async (id: string) => {
    await deleteRoleGroup(id);
    await loadData();
  };

  const handleResetRoles = async () => {
    setIsSaving(true);
    try {
      await resetRoleGroups();
      await loadData();
    } finally {
      setIsSaving(false);
    }
  };

  const handleUpdatePreferences = async (data: Partial<SystemPreferences>) => {
    setIsSaving(true);
    try {
      const updated = await updateSystemPreferences(data);
      setPreferences(updated);
      return updated;
    } finally {
      setIsSaving(false);
    }
  };

  return {
    activeTab,
    company,
    users,
    roles,
    preferences,
    isLoading,
    isSaving,
    setActiveTab,
    loadData,
    updateCompany: handleUpdateCompany,
    createUser: handleCreateUser,
    updateUser: handleUpdateUser,
    deleteUser: handleDeleteUser,
    createRole: handleCreateRole,
    updateRole: handleUpdateRole,
    deleteRole: handleDeleteRole,
    resetRoles: handleResetRoles,
    updatePreferences: handleUpdatePreferences,
  };
}