import { apiRequest } from "@/services/apiClient";
import type { ApiPaginatedResponse } from "@/types";
import type { Plan, PlanFormValues, PlanLimitationsMeta } from "@/types/plan";

function buildLimitations(values: Partial<PlanFormValues>): PlanLimitationsMeta {
  const idealFor = (values.idealForText ?? "")
    .split("\n")
    .map((s) => s.trim())
    .filter(Boolean);

  return {
    emoji: values.planningEmoji || undefined,
    planningPrice:
      values.monthlyPrice !== undefined ? Number(values.monthlyPrice) : undefined,
    planningPriceFrom: values.planningPriceFrom,
    screenEstimate: values.screenEstimate || undefined,
    structuralDescription: values.structuralDescription || undefined,
    planningNotice: values.planningNotice || undefined,
    planningTimeline: values.planningTimeline || undefined,
    idealFor: idealFor.length ? idealFor : undefined,
  };
}

function toPayload(values: Partial<PlanFormValues>) {
  const limitations = buildLimitations(values);
  return {
    name: values.name,
    slug: values.slug,
    shortDescription: values.shortDescription,
    fullDescription: values.fullDescription,
    monthlyPrice: values.monthlyPrice,
    yearlyPrice: values.yearlyPrice,
    compareAtMonthly:
      values.compareAtMonthly === "" || values.compareAtMonthly === undefined
        ? null
        : values.compareAtMonthly,
    compareAtYearly:
      values.compareAtYearly === "" || values.compareAtYearly === undefined
        ? null
        : values.compareAtYearly,
    setupFee: values.setupFee,
    featured: values.featured,
    badge: values.badge || null,
    buttonText: values.buttonText || null,
    buttonLink: values.buttonLink || null,
    icon: values.icon || null,
    active: values.active,
    seoTitle: values.seoTitle || null,
    seoDescription: values.seoDescription || null,
    limits: {
      apps: values.limitsApps ?? 1,
      users: values.limitsUsers ?? 3,
      support: values.limitsSupport ?? "E-mail",
    },
    limitations,
    planFeatures: values.planFeatures?.map((f, i) => ({
      feature: f.feature,
      highlight: f.highlight,
      icon: f.icon || null,
      sort_order: i + 1,
    })),
  };
}

export const adminPlansService = {
  async list(
    token: string,
    params?: {
      search?: string;
      active?: boolean;
      featured?: boolean;
      catalog?: string;
      page?: number;
      per_page?: number;
    },
  ) {
    const qs = new URLSearchParams();
    if (params?.catalog) qs.set("catalog", params.catalog);
    if (params?.search) qs.set("search", params.search);
    if (params?.active !== undefined) qs.set("active", String(params.active));
    if (params?.featured !== undefined) qs.set("featured", String(params.featured));
    if (params?.page) qs.set("page", String(params.page));
    if (params?.per_page) qs.set("per_page", String(params.per_page));
    const query = qs.toString();
    return apiRequest<Plan[]>(`/admin/plans${query ? `?${query}` : ""}`, { token }) as Promise<
      ApiPaginatedResponse<Plan>
    >;
  },

  async get(token: string, id: number) {
    return apiRequest<Plan>(`/admin/plans/${id}`, { token });
  },

  async create(token: string, values: PlanFormValues) {
    return apiRequest<Plan>("/admin/plans", {
      method: "POST",
      token,
      body: toPayload(values),
    });
  },

  async update(token: string, id: number, values: Partial<PlanFormValues>) {
    return apiRequest<Plan>(`/admin/plans/${id}`, {
      method: "PUT",
      token,
      body: toPayload(values),
    });
  },

  async patch(token: string, id: number, body: Record<string, unknown>) {
    return apiRequest<Plan>(`/admin/plans/${id}`, {
      method: "PUT",
      token,
      body,
    });
  },

  async remove(token: string, id: number) {
    return apiRequest<null>(`/admin/plans/${id}`, { method: "DELETE", token });
  },

  async reorder(token: string, orderedIds: number[]) {
    return apiRequest<null>("/admin/plans/reorder", {
      method: "POST",
      token,
      body: { orderedIds },
    });
  },

  async duplicate(token: string, id: number) {
    return apiRequest<Plan>(`/admin/plans/${id}/duplicate`, { method: "POST", token });
  },

  async toggle(token: string, id: number) {
    return apiRequest<Plan>(`/admin/plans/${id}/toggle`, { method: "POST", token });
  },
};