"use client";

import { useCallback, useEffect, useState } from "react";
import {
  createTenantCompany,
  getSaaSFinancialStats,
  getTenantsList,
  sendBroadcastNotification,
  toggleTenantStatus,
  updateTenantBilling,
  getSaaSAdmins,
  createSaaSAdmin,
  deleteSaaSAdmin,
  updateSaaSAdmin,
  resetProductionDatabase,
} from "@/services/saas-admin-service";
import {
  BroadcastNotificationDTO,
  CreateTenantDTO,
  SaaSFinancialStats,
  TenantCompany,
  TenantStatus,
} from "@/types/saas-admin";

export function useSaaSAdmin() {
  const [tenants, setTenants] = useState<TenantCompany[]>([]);
  const [stats, setStats] = useState<SaaSFinancialStats>({
    totalTenants: 0,
    activeTenants: 0,
    suspendedTenants: 0,
    trialTenants: 0,
    mrr: 0,
    arr: 0,
    overdueRevenue: 0,
  });
  const [admins, setAdmins] = useState<any[]>([]);

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

  const [search, setSearch] = useState("");
  const [statusFilter, setStatusFilter] = useState<string>("ALL");
  const [selectedTenant, setSelectedTenant] = useState<TenantCompany | null>(null);

  const loadData = useCallback(async () => {
    setIsLoading(true);
    try {
      const [tenantsRes, statsRes, adminsRes] = await Promise.all([
        getTenantsList(),
        getSaaSFinancialStats(),
        getSaaSAdmins(),
      ]);

      setTenants(tenantsRes);
      setStats(statsRes);
      setAdmins(adminsRes);
    } catch (err) {
      console.error("Erro ao carregar dados do SuperAdmin SaaS:", err);
    } finally {
      setIsLoading(false);
    }
  }, []);

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

  const handleCreateTenant = async (data: CreateTenantDTO) => {
    setIsSaving(true);
    try {
      const created = await createTenantCompany(data);
      await loadData();
      return created;
    } finally {
      setIsSaving(false);
    }
  };

  const handleToggleStatus = async (id: string, status: TenantStatus) => {
    setIsSaving(true);
    try {
      const updated = await toggleTenantStatus(id, status);
      await loadData();
      if (selectedTenant?.id === id) {
        setSelectedTenant((prev) => (prev ? { ...prev, status } : null));
      }
      return updated;
    } finally {
      setIsSaving(false);
    }
  };

  const handleUpdateBilling = async (
    id: string,
    data: { monthlyFee?: number; dueDay?: number; lastPaymentStatus?: "PAID" | "PENDENTE" | "OVERDUE" }
  ) => {
    setIsSaving(true);
    try {
      const updated = await updateTenantBilling(id, data);
      await loadData();
      if (selectedTenant?.id === id) {
        setSelectedTenant((prev) => (prev ? { ...prev, ...data } : null));
      }
      return updated;
    } finally {
      setIsSaving(false);
    }
  };

  const handleSendBroadcast = async (data: BroadcastNotificationDTO) => {
    setIsSaving(true);
    try {
      const notification = await sendBroadcastNotification(data);
      return notification;
    } finally {
      setIsSaving(false);
    }
  };

  const handleCreateAdmin = async (data: { name: string; email: string }) => {
    setIsSaving(true);
    try {
      const created = await createSaaSAdmin(data);
      await loadData();
      return created;
    } finally {
      setIsSaving(false);
    }
  };

  const handleDeleteAdmin = async (id: string) => {
    setIsSaving(true);
    try {
      await deleteSaaSAdmin(id);
      await loadData();
    } finally {
      setIsSaving(false);
    }
  };

  const handleUpdateAdmin = async (id: string, data: { name?: string; email?: string; password?: string }) => {
    setIsSaving(true);
    try {
      const updated = await updateSaaSAdmin(id, data);
      await loadData();
      return updated;
    } finally {
      setIsSaving(false);
    }
  };

  const filteredTenants = tenants.filter((tenant) => {
    const matchesSearch =
      tenant.legalName.toLowerCase().includes(search.toLowerCase()) ||
      tenant.tradeName.toLowerCase().includes(search.toLowerCase()) ||
      tenant.document.includes(search) ||
      tenant.email.toLowerCase().includes(search.toLowerCase());

    const matchesStatus = statusFilter === "ALL" || tenant.status === statusFilter;

    return matchesSearch && matchesStatus;
  });

  const handleResetDatabase = async () => {
    setIsSaving(true);
    try {
      const res = await resetProductionDatabase();
      await loadData();
      return res;
    } finally {
      setIsSaving(false);
    }
  };

  return {
    tenants: filteredTenants,
    stats,
    admins,
    isLoading,
    isSaving,
    search,
    statusFilter,
    selectedTenant,
    setSelectedTenant,
    setSearch,
    setStatusFilter,
    loadData,
    createTenant: handleCreateTenant,
    toggleTenantStatus: handleToggleStatus,
    updateTenantBilling: handleUpdateBilling,
    sendBroadcast: handleSendBroadcast,
    createAdmin: handleCreateAdmin,
    deleteAdmin: handleDeleteAdmin,
    updateAdmin: handleUpdateAdmin,
    resetDatabase: handleResetDatabase,
  };
}