import { getAuthHeaders } from "./api-client";
import {
  BroadcastNotificationDTO,
  CreateTenantDTO,
  SaaSFinancialStats,
  SystemNotification,
  TenantCompany,
  TenantStatus,
} from "@/types/saas-admin";

const API_BASE = (process.env.NEXT_PUBLIC_API_URL || "http://localhost:3333").replace(/\/$/, "") + "/api";

const MOCK_TENANTS: TenantCompany[] = [];

let localTenants: TenantCompany[] = [...MOCK_TENANTS];
let localNotifications: SystemNotification[] = [];

export async function getTenantsList(): Promise<TenantCompany[]> {
  try {
    const res = await fetch(`${API_BASE}/saas-admin/tenants`, {
      headers: getAuthHeaders(),
      cache: "no-store",
    });
    if (res.ok) {
      const data = await res.json();
      if (Array.isArray(data) && data.length > 0) {
        return data;
      }
    }
  } catch {
    // fallback
  }

  return localTenants;
}

export async function getSaaSFinancialStats(): Promise<SaaSFinancialStats> {
  try {
    const res = await fetch(`${API_BASE}/saas-admin/stats`, {
      headers: getAuthHeaders(),
      cache: "no-store",
    });
    if (res.ok) {
      return await res.json();
    }
  } catch {
    // fallback
  }

  const activeTenants = localTenants.filter((t) => t.status === "ACTIVE").length;
  const suspendedTenants = localTenants.filter((t) => t.status === "SUSPENDED").length;
  const trialTenants = localTenants.filter((t) => t.status === "TRIAL").length;
  const mrr = localTenants.filter((t) => t.status === "ACTIVE").reduce((acc, t) => acc + t.monthlyFee, 0);

  return {
    totalTenants: localTenants.length,
    activeTenants,
    suspendedTenants,
    trialTenants,
    mrr,
    arr: mrr * 12,
    overdueRevenue: localTenants.filter((t) => t.lastPaymentStatus === "OVERDUE").reduce((acc, t) => acc + t.monthlyFee, 0),
  };
}

export async function createTenantCompany(data: CreateTenantDTO): Promise<TenantCompany> {
  try {
    const res = await fetch(`${API_BASE}/saas-admin/tenants`, {
      method: "POST",
      headers: getAuthHeaders(),
      body: JSON.stringify(data),
    });
    if (res.ok) {
      return await res.json();
    }
  } catch {
    // fallback
  }

  const newCompany: TenantCompany = {
    id: `comp-${Date.now()}`,
    legalName: data.legalName,
    tradeName: data.tradeName || data.legalName,
    document: data.document,
    email: data.email,
    phone: data.phone || null,
    status: data.status || "ACTIVE",
    plan: data.plan || "Pro Enterprise",
    monthlyFee: data.monthlyFee || 499.0,
    dueDay: data.dueDay || 10,
    lastPaymentStatus: "PAID",
    userCount: 1,
    users: [
      { id: `u-${Date.now()}`, name: data.adminName, email: data.adminEmail, role: "OWNER", active: true },
    ],
    createdAt: new Date().toISOString(),
    updatedAt: new Date().toISOString(),
  };

  localTenants = [newCompany, ...localTenants];
  return newCompany;
}

export async function toggleTenantStatus(id: string, status: TenantStatus): Promise<TenantCompany> {
  try {
    const res = await fetch(`${API_BASE}/saas-admin/tenants/${id}/status`, {
      method: "PATCH",
      headers: getAuthHeaders(),
      body: JSON.stringify({ status }),
    });
    if (res.ok) {
      return await res.json();
    }
  } catch {
    // fallback
  }

  const index = localTenants.findIndex((t) => t.id === id);
  if (index !== -1) {
    localTenants[index] = { ...localTenants[index], status };
    return localTenants[index];
  }
  throw new Error("Empresa não encontrada.");
}

export async function updateTenantBilling(
  id: string,
  data: { monthlyFee?: number; dueDay?: number; lastPaymentStatus?: "PAID" | "PENDENTE" | "OVERDUE" }
): Promise<TenantCompany> {
  try {
    const res = await fetch(`${API_BASE}/saas-admin/tenants/${id}/billing`, {
      method: "PATCH",
      headers: getAuthHeaders(),
      body: JSON.stringify(data),
    });
    if (res.ok) {
      return await res.json();
    }
  } catch {
    // fallback
  }

  const index = localTenants.findIndex((t) => t.id === id);
  if (index !== -1) {
    localTenants[index] = { ...localTenants[index], ...data };
    return localTenants[index];
  }
  throw new Error("Empresa não encontrada.");
}


export async function sendBroadcastNotification(data: BroadcastNotificationDTO): Promise<SystemNotification> {
  const payload = {
    ...data,
    companyId: !data.companyId || data.companyId === "all" ? null : data.companyId,
  };

  try {
    const res = await fetch(`${API_BASE}/saas-admin/broadcast`, {
      method: "POST",
      headers: getAuthHeaders(),
      body: JSON.stringify(payload),
    });
    if (res.ok) {
      const created = await res.json();
      localNotifications = [created, ...localNotifications];
      if (typeof window !== "undefined") {
        window.dispatchEvent(new CustomEvent("system-notification-created", { detail: created }));
        localStorage.setItem("latest_system_notification", JSON.stringify(created));
      }
      return created;
    }
  } catch {
    // fallback
  }

  const newNotification: SystemNotification = {
    id: `notif-${Date.now()}`,
    companyId: payload.companyId,
    title: payload.title,
    message: payload.message,
    type: payload.type || "INFO",
    active: true,
    createdAt: new Date().toISOString(),
  };

  localNotifications = [newNotification, ...localNotifications];
  if (typeof window !== "undefined") {
    window.dispatchEvent(new CustomEvent("system-notification-created", { detail: newNotification }));
    localStorage.setItem("latest_system_notification", JSON.stringify(newNotification));
  }
  return newNotification;
}

export async function getActiveNotifications(): Promise<SystemNotification[]> {
  try {
    const res = await fetch(`${API_BASE}/saas-admin/notifications`, {
      cache: "no-store",
    });
    if (res.ok) {
      const notifs = await res.json();
      if (Array.isArray(notifs) && notifs.length > 0) {
        return notifs;
      }
    }
  } catch {
    // fallback
  }

  if (typeof window !== "undefined") {
    const saved = localStorage.getItem("latest_system_notification");
    if (saved) {
      try {
        const parsed = JSON.parse(saved);
        if (parsed && !localNotifications.some((n) => n.id === parsed.id)) {
          localNotifications = [parsed, ...localNotifications];
        }
      } catch {}
    }
  }

  return localNotifications.filter((n) => n.active);
}

let localAdmins: any[] = [
  { id: "sa-1", name: "SuperAdmin RentX", email: "superadmin@rentx.local", role: "SUPERADMIN", active: true, createdAt: new Date().toISOString() }
];

export async function getSaaSAdmins(): Promise<any[]> {
  try {
    const res = await fetch(`${API_BASE}/saas-admin/users`, {
      cache: "no-store",
    });
    if (res.ok) {
      return await res.json();
    }
  } catch {
    // fallback
  }
  return localAdmins;
}

export async function createSaaSAdmin(data: { name: string; email: string }): Promise<any> {
  try {
    const res = await fetch(`${API_BASE}/saas-admin/users`, {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
      },
      body: JSON.stringify(data),
    });
    if (res.ok) {
      return await res.json();
    }
  } catch {
    // fallback
  }

  const newAdmin = {
    id: `sa-${Date.now()}`,
    name: data.name,
    email: data.email,
    role: "SUPERADMIN",
    active: true,
    createdAt: new Date().toISOString(),
  };
  localAdmins = [newAdmin, ...localAdmins];
  return newAdmin;
}

export async function deleteSaaSAdmin(id: string): Promise<boolean> {
  try {
    const res = await fetch(`${API_BASE}/saas-admin/users/${id}`, {
      method: "DELETE",
    });
    if (res.ok) {
      return true;
    }
  } catch {
    // fallback
  }

  localAdmins = localAdmins.filter((a) => a.id !== id);
  return true;
}

export async function updateSaaSAdmin(id: string, data: { name?: string; email?: string; password?: string }): Promise<any> {
  try {
    const res = await fetch(`${API_BASE}/saas-admin/users/${id}`, {
      method: "PATCH",
      headers: {
        "Content-Type": "application/json",
      },
      body: JSON.stringify(data),
    });
    if (res.ok) {
      return await res.json();
    }
  } catch {
    // fallback
  }

  const index = localAdmins.findIndex((a) => a.id === id);
  if (index !== -1) {
    localAdmins[index] = { ...localAdmins[index], ...data };
    return localAdmins[index];
  }
  throw new Error("Administrador não encontrado.");
}

export async function resetProductionDatabase() {
  try {
    const res = await fetch(`${API_BASE}/saas-admin/reset-database`, {
      method: "POST",
      headers: getAuthHeaders(),
    });
    if (res.ok) {
      return await res.json();
    }
  } catch {
    // fallback
  }

  localTenants = [];
  localNotifications = [];
  if (typeof window !== "undefined") {
    localStorage.removeItem("latest_system_notification");
    localStorage.removeItem("dismissed_notifications");
  }
  return { message: "Banco de dados zerado e configurado para produção com sucesso!" };
}