"use server";

import { randomUUID } from "crypto";
import { unlink } from "fs/promises";
import path from "path";
import { revalidatePath } from "next/cache";
import { getServerSession } from "next-auth";
import { z } from "zod";
import { authOptions } from "@/auth";
import { ADMIN_ROLES, CONTENT_ROLES, SALES_ROLES, hasAnyRole } from "@/lib/admin-auth";
import { prisma } from "@/lib/prisma";

const hasDatabaseUrl = Boolean(process.env.DATABASE_URL);
const inventoryStatusSchema = z.enum([
  "IN_STOCK",
  "LIMITED_STOCK",
  "OUT_OF_STOCK",
  "TEST_RIDE_ONLY",
  "COMING_SOON",
]);
const bookingStatusSchema = z.enum(["PENDING", "CONFIRMED", "COMPLETED", "CANCELLED"]);
const leadStatusSchema = z.enum(["NEW", "CONTACTED", "QUALIFIED", "CLOSED"]);
const assetStatusSchema = z.enum([
  "PENDING",
  "UPLOADED",
  "NEEDS_OPTIMIZATION",
  "OPTIMIZED",
  "PUBLISHED",
]);

async function requireAdmin(allowedRoles = ADMIN_ROLES) {
  const session = await getServerSession(authOptions);

  if (!session?.user || !hasAnyRole(session.user.role, allowedRoles)) {
    throw new Error("Unauthorized");
  }

  return session;
}

function slugify(value: string) {
  return value.toLowerCase().trim().replace(/[^a-z0-9]+/g, "-").replace(/(^-|-$)/g, "");
}

function createUniqueId(prefix: string, value: string) {
  return `${prefix}-${slugify(value)}-${randomUUID().slice(0, 8)}`;
}

function requiredValue(formData: FormData, key: string) {
  const value = String(formData.get(key) ?? "").trim();
  if (!value) {
    throw new Error(`Invalid ${key}`);
  }
  return value;
}

function revalidatePublicCatalog() {
  revalidatePath("/");
  revalidatePath("/scooters");
  revalidatePath("/brands");
  revalidatePath("/offers");
  revalidatePath("/parts");
  revalidatePath("/gallery");
}

async function deleteUploadedImageFile(fileUrl: string | null | undefined) {
  if (!fileUrl || !fileUrl.startsWith("/uploads/admin/images/")) {
    return;
  }

  const relative = fileUrl.replace(/^\/+/, "");
  const filepath = path.join(process.cwd(), "public", relative);

  try {
    await unlink(filepath);
  } catch {
    // Ignore missing files or cleanup errors.
  }
}

async function tableExists(tableName: string) {
  try {
    const rows = await prisma.$queryRaw<Array<{ exists: boolean }>>`
      SELECT EXISTS (
        SELECT 1
        FROM information_schema.tables
        WHERE table_schema = 'public'
          AND table_name = ${tableName}
      ) AS "exists"
    `;
    return Boolean(rows[0]?.exists);
  } catch {
    return false;
  }
}

function prismaSupportsBranchImage() {
  const model = (prisma as any)?._runtimeDataModel?.models?.Branch;
  const fields = Array.isArray(model?.fields) ? model.fields : [];
  return fields.some((field: { name?: string }) => field.name === "branchImage");
}

const productSchema = z.object({
  id: z.string().optional(),
  brandId: z.string().min(1),
  name: z.string().min(2),
  slug: z.string().min(2),
  shortDescription: z.string().min(5),
  longDescription: z.string().min(10),
  price: z.coerce.number().int().min(0),
  offerPrice: z.coerce.number().int().min(0),
  rangeKm: z.coerce.number().int().min(0),
  topSpeedKmph: z.coerce.number().int().min(0),
  chargingTime: z.string().min(1),
  battery: z.string().min(1),
  motorPower: z.string().min(1),
  warranty: z.string().min(1),
  colors: z.string().min(1),
  heroImage: z.string().min(1),
  thumbnailImage: z.string().min(1),
  posterImage: z.string().min(1),
  galleryImages: z.string().optional(),
  published: z.boolean().default(true),
});

export async function saveProductAction(values: z.infer<typeof productSchema>) {
  await requireAdmin(CONTENT_ROLES);
  const data = productSchema.parse(values);
  const galleryImages = (data.galleryImages ?? "")
    .split("\n")
    .map((item) => item.trim())
    .filter(Boolean);

  if (!hasDatabaseUrl) {
    return { ok: false, message: "Database is not configured." };
  }

  const id = data.id || `scooter-${data.slug}`;
  await prisma.scooter.upsert({
    where: { id },
    update: {
      brandId: data.brandId,
      name: data.name,
      slug: data.slug,
      shortDescription: data.shortDescription,
      longDescription: data.longDescription,
      price: data.price,
      offerPrice: data.offerPrice,
      rangeKm: data.rangeKm,
      topSpeedKmph: data.topSpeedKmph,
      chargingTime: data.chargingTime,
      battery: data.battery,
      motorPower: data.motorPower,
      warranty: data.warranty,
      colors: data.colors.split(",").map((item) => item.trim()).filter(Boolean),
      heroImage: data.heroImage,
      thumbnailImage: data.thumbnailImage,
      posterImage: data.posterImage,
      published: data.published,
      specs: [
        { label: "Range", value: `${data.rangeKm} km` },
        { label: "Top Speed", value: `${data.topSpeedKmph} kmph` },
        { label: "Charging", value: data.chargingTime },
      ],
    },
    create: {
      id,
      brandId: data.brandId,
      name: data.name,
      slug: data.slug,
      shortDescription: data.shortDescription,
      longDescription: data.longDescription,
      price: data.price,
      offerPrice: data.offerPrice,
      rangeKm: data.rangeKm,
      topSpeedKmph: data.topSpeedKmph,
      chargingTime: data.chargingTime,
      battery: data.battery,
      motorPower: data.motorPower,
      warranty: data.warranty,
      colors: data.colors.split(",").map((item) => item.trim()).filter(Boolean),
      heroImage: data.heroImage,
      thumbnailImage: data.thumbnailImage,
      posterImage: data.posterImage,
      published: data.published,
      arEnabled: false,
      isFeatured: false,
      specs: [
        { label: "Range", value: `${data.rangeKm} km` },
        { label: "Top Speed", value: `${data.topSpeedKmph} kmph` },
        { label: "Charging", value: data.chargingTime },
      ],
    },
  });

  await prisma.scooterImage.deleteMany({
    where: { scooterId: id },
  });

  if (galleryImages.length) {
    await prisma.scooterImage.createMany({
      data: galleryImages.map((url, index) => ({
        scooterId: id,
        url,
        alt: `${data.name} gallery image ${index + 1}`,
        sortOrder: index,
      })),
    });
  }

  revalidatePath("/admin/products");
  revalidatePublicCatalog();
  revalidatePath(`/scooters/${data.slug}`);
  return { ok: true, message: "Product saved." };
}

export async function deleteProductAction(formData: FormData) {
  await requireAdmin(CONTENT_ROLES);
  if (!hasDatabaseUrl) return;

  const id = requiredValue(formData, "id");
  const existing = await prisma.scooter.findUnique({ where: { id }, select: { slug: true } });

  await prisma.scooter.delete({ where: { id } });

  revalidatePath("/admin/products");
  revalidatePublicCatalog();
  if (existing?.slug) {
    revalidatePath(`/scooters/${existing.slug}`);
  }
}

export async function createBrandAction(formData: FormData) {
  await requireAdmin(CONTENT_ROLES);
  if (!hasDatabaseUrl) return;

  const name = requiredValue(formData, "name");
  const shortDescription = requiredValue(formData, "shortDescription");
  const logoImageUrl = String(formData.get("logoImageUrl") ?? "").trim();
  const logoText = String(formData.get("logoText") ?? "").trim();
  await prisma.brand.create({
    data: {
      id: createUniqueId("brand", name),
      name,
      slug: String(formData.get("slug") || slugify(name)),
      shortDescription,
      logoText: logoImageUrl || logoText || name.slice(0, 3).toUpperCase(),
      keyStrength: String(formData.get("keyStrength") ?? ""),
      popularModels: [],
      isFeatured: formData.get("isFeatured") === "on",
    },
  });
  revalidatePath("/admin/brands");
  revalidatePublicCatalog();
}

export async function createBranchAction(formData: FormData) {
  await requireAdmin(CONTENT_ROLES);
  if (!hasDatabaseUrl) return;

  const name = requiredValue(formData, "name");
  const slug = requiredValue(formData, "slug");
  const city = requiredValue(formData, "city");
  const district = requiredValue(formData, "district");
  const phone = requiredValue(formData, "phone");
  const whatsapp = requiredValue(formData, "whatsapp");
  const openingHours = requiredValue(formData, "openingHours");
  const mapLink = requiredValue(formData, "mapLink");
  const branchImage = String(formData.get("branchImage") ?? "").trim();
  const supportsBranchImage = prismaSupportsBranchImage();

  await prisma.branch.create({
    data: {
      id: `branch-${slugify(city)}-${slugify(district)}`,
      name,
      slug,
      type: String(formData.get("type") ?? "Branch"),
      city,
      district,
      phone,
      whatsapp,
      openingHours,
      mapLink,
      ...(supportsBranchImage ? { branchImage } : {}),
    },
  });

  revalidatePath("/admin/branches");
  revalidatePath("/contact");
  revalidatePath("/");
}

export async function updateBranchAction(formData: FormData) {
  await requireAdmin(CONTENT_ROLES);
  if (!hasDatabaseUrl) return;

  const id = requiredValue(formData, "id");
  const name = requiredValue(formData, "name");
  const slug = requiredValue(formData, "slug");
  const city = requiredValue(formData, "city");
  const district = requiredValue(formData, "district");
  const phone = requiredValue(formData, "phone");
  const whatsapp = requiredValue(formData, "whatsapp");
  const openingHours = requiredValue(formData, "openingHours");
  const mapLink = requiredValue(formData, "mapLink");
  const branchImage = String(formData.get("branchImage") ?? "").trim();
  const supportsBranchImage = prismaSupportsBranchImage();

  await prisma.branch.update({
    where: { id },
    data: {
      name,
      slug,
      type: String(formData.get("type") ?? "Branch"),
      city,
      district,
      phone,
      whatsapp,
      openingHours,
      mapLink,
      ...(supportsBranchImage ? { branchImage } : {}),
    },
  });

  revalidatePath("/admin/branches");
  revalidatePath("/contact");
  revalidatePath("/");
}

export async function deleteBranchAction(formData: FormData) {
  await requireAdmin(CONTENT_ROLES);
  if (!hasDatabaseUrl) return;
  const id = requiredValue(formData, "id");

  const [inventoryCount, offerCount, bookingCount, leadCount, galleryCount] = await Promise.all([
    prisma.inventory.count({ where: { branchId: id } }),
    prisma.offer.count({ where: { branchId: id } }),
    prisma.testRideBooking.count({ where: { branchId: id } }),
    prisma.lead.count({ where: { branchId: id } }),
    prisma.galleryImage.count({ where: { branchId: id } }),
  ]);

  if (inventoryCount + offerCount + bookingCount + leadCount + galleryCount > 0) {
    throw new Error("Cannot delete branch with related records.");
  }

  await prisma.branch.delete({ where: { id } });
  revalidatePath("/admin/branches");
  revalidatePath("/contact");
  revalidatePath("/");
}

export async function deleteBrandAction(formData: FormData) {
  await requireAdmin(CONTENT_ROLES);
  if (!hasDatabaseUrl) return;
  const id = requiredValue(formData, "id");
  const count = await prisma.scooter.count({ where: { brandId: id } });
  if (count === 0) {
    await prisma.brand.delete({ where: { id } });
  }
  revalidatePath("/admin/brands");
  revalidatePublicCatalog();
}

export async function updateBrandAction(formData: FormData) {
  await requireAdmin(CONTENT_ROLES);
  if (!hasDatabaseUrl) return;
  const id = requiredValue(formData, "id");
  const name = requiredValue(formData, "name");
  const slug = requiredValue(formData, "slug");
  const shortDescription = requiredValue(formData, "shortDescription");
  const logoImageUrl = String(formData.get("logoImageUrl") ?? "").trim();
  const logoText = String(formData.get("logoText") ?? "").trim();
  await prisma.brand.update({
    where: { id },
    data: {
      name,
      slug,
      shortDescription,
      logoText: logoImageUrl || logoText || name.slice(0, 3).toUpperCase(),
      keyStrength: String(formData.get("keyStrength") ?? ""),
      isFeatured: formData.get("isFeatured") === "on",
    },
  });
  revalidatePath("/admin/brands");
  revalidatePublicCatalog();
}

export async function createPartAction(formData: FormData) {
  await requireAdmin(CONTENT_ROLES);
  if (!hasDatabaseUrl) return;
  const name = requiredValue(formData, "name");
  const category = requiredValue(formData, "category");
  const stockStatus = inventoryStatusSchema.parse(
    String(formData.get("stockStatus") || "IN_STOCK"),
  );
  await prisma.part.create({
    data: {
      id: createUniqueId("part", name),
      name,
      category,
      price: Number(formData.get("price") ?? 0),
      image: String(formData.get("image") ?? "/images/parts/placeholder.png"),
      compatibility: String(formData.get("compatibility") ?? "Universal").split(",").map((item) => item.trim()),
      inquiryOnly: formData.get("inquiryOnly") === "on",
      stockStatus,
    },
  });
  revalidatePath("/admin/parts");
  revalidatePublicCatalog();
}

export async function updatePartAction(formData: FormData) {
  await requireAdmin(CONTENT_ROLES);
  if (!hasDatabaseUrl) return;
  const id = requiredValue(formData, "id");
  const name = requiredValue(formData, "name");
  const category = requiredValue(formData, "category");
  const stockStatus = inventoryStatusSchema.parse(
    String(formData.get("stockStatus") || "IN_STOCK"),
  );
  await prisma.part.update({
    where: { id },
    data: {
      name,
      category,
      price: Number(formData.get("price") ?? 0),
      image: String(formData.get("image") ?? ""),
      compatibility: String(formData.get("compatibility") ?? "Universal").split(",").map((item) => item.trim()),
      inquiryOnly: formData.get("inquiryOnly") === "on",
      stockStatus,
    },
  });
  revalidatePath("/admin/parts");
  revalidatePublicCatalog();
}

export async function createOfferAction(formData: FormData) {
  await requireAdmin(CONTENT_ROLES);
  if (!hasDatabaseUrl) return;
  const title = requiredValue(formData, "title");
  const description = requiredValue(formData, "description");
  const discountLabel = requiredValue(formData, "discountLabel");
  await prisma.offer.create({
    data: {
      id: createUniqueId("offer", title),
      category: String(formData.get("category") ?? "General"),
      title,
      description,
      discountLabel,
      startsAt: formData.get("startsAt") ? new Date(String(formData.get("startsAt"))) : null,
      validUntil: new Date(String(formData.get("validUntil") || new Date().toISOString())),
      active: formData.get("active") === "on",
      brandId: String(formData.get("brandId") || "") || null,
      scooterId: String(formData.get("scooterId") || "") || null,
      branchId: String(formData.get("branchId") || "") || null,
    },
  });
  revalidatePath("/admin/offers");
  revalidatePublicCatalog();
}

export async function updateOfferAction(formData: FormData) {
  await requireAdmin(CONTENT_ROLES);
  if (!hasDatabaseUrl) return;
  const id = requiredValue(formData, "id");
  const title = requiredValue(formData, "title");
  const description = requiredValue(formData, "description");
  const discountLabel = requiredValue(formData, "discountLabel");
  await prisma.offer.update({
    where: { id },
    data: {
      category: String(formData.get("category") ?? "General"),
      title,
      description,
      discountLabel,
      startsAt: formData.get("startsAt") ? new Date(String(formData.get("startsAt"))) : null,
      validUntil: new Date(String(formData.get("validUntil") || new Date().toISOString())),
      active: formData.get("active") === "on",
      brandId: String(formData.get("brandId") || "") || null,
      scooterId: String(formData.get("scooterId") || "") || null,
      branchId: String(formData.get("branchId") || "") || null,
    },
  });
  revalidatePath("/admin/offers");
  revalidatePublicCatalog();
}

export async function deleteOfferAction(formData: FormData) {
  await requireAdmin(CONTENT_ROLES);
  if (!hasDatabaseUrl) return;
  const id = requiredValue(formData, "id");
  await prisma.offer.delete({ where: { id } });
  revalidatePath("/admin/offers");
  revalidatePublicCatalog();
}

export async function createGalleryImageAction(formData: FormData) {
  await requireAdmin(CONTENT_ROLES);
  if (!hasDatabaseUrl) return;
  const title = requiredValue(formData, "title");
  const image = requiredValue(formData, "image");
  await prisma.galleryImage.create({
    data: {
      id: createUniqueId("gallery", title),
      category: String(formData.get("category") ?? "Showroom"),
      title,
      image,
      alt: String(formData.get("alt") || title),
      featured: formData.get("featured") === "on",
      branchId: String(formData.get("branchId") || "") || null,
      scooterId: String(formData.get("scooterId") || "") || null,
    },
  });
  revalidatePath("/admin/gallery");
  revalidatePublicCatalog();
}

export async function updateGalleryImageAction(formData: FormData) {
  await requireAdmin(CONTENT_ROLES);
  if (!hasDatabaseUrl) return;
  const id = requiredValue(formData, "id");
  const title = requiredValue(formData, "title");
  const image = requiredValue(formData, "image");
  await prisma.galleryImage.update({
    where: { id },
    data: {
      category: String(formData.get("category") ?? "Showroom"),
      title,
      image,
      alt: String(formData.get("alt") ?? ""),
      featured: formData.get("featured") === "on",
      branchId: String(formData.get("branchId") || "") || null,
      scooterId: String(formData.get("scooterId") || "") || null,
    },
  });
  revalidatePath("/admin/gallery");
  revalidatePublicCatalog();
}

export async function deleteGalleryImageAction(formData: FormData) {
  await requireAdmin(CONTENT_ROLES);
  if (!hasDatabaseUrl) return;
  const id = requiredValue(formData, "id");
  await prisma.galleryImage.delete({ where: { id } });
  revalidatePath("/admin/gallery");
  revalidatePublicCatalog();
}

export async function deletePartAction(formData: FormData) {
  await requireAdmin(CONTENT_ROLES);
  if (!hasDatabaseUrl) return;
  const id = requiredValue(formData, "id");
  await prisma.part.delete({ where: { id } });
  revalidatePath("/admin/parts");
  revalidatePublicCatalog();
}

export async function saveAsset3DAction(formData: FormData) {
  await requireAdmin(CONTENT_ROLES);
  if (!hasDatabaseUrl) return;

  const scooterId = requiredValue(formData, "scooterId");
  const status = assetStatusSchema.parse(String(formData.get("status") ?? "PENDING"));
  const glbUrl = String(formData.get("glbUrl") ?? "").trim() || null;
  const usdzUrl = String(formData.get("usdzUrl") ?? "").trim() || null;
  const arEnabled = formData.get("arEnabled") === "on";
  const posterImage = String(formData.get("posterImage") ?? "").trim();

  await prisma.scooterAsset3D.upsert({
    where: { scooterId },
    update: { glbUrl, usdzUrl, status },
    create: {
      scooterId,
      glbUrl,
      usdzUrl,
      status,
    },
  });

  await prisma.scooter.update({
    where: { id: scooterId },
    data: {
      arEnabled,
      ...(posterImage ? { posterImage } : {}),
    },
  });

  revalidatePath("/admin/3d-assets");
  revalidatePath("/admin/products");
  revalidatePath("/scooters");
}

export async function deleteAsset3DAction(formData: FormData) {
  await requireAdmin(CONTENT_ROLES);
  if (!hasDatabaseUrl) return;
  const id = requiredValue(formData, "id");
  await prisma.scooterAsset3D.delete({ where: { id } });
  revalidatePath("/admin/3d-assets");
  revalidatePath("/admin/products");
  revalidatePath("/scooters");
}

export async function updateBookingStatusAction(formData: FormData) {
  await requireAdmin(SALES_ROLES);
  if (!hasDatabaseUrl) return;
  const id = requiredValue(formData, "id");
  const status = bookingStatusSchema.parse(String(formData.get("status") ?? "PENDING"));
  await prisma.testRideBooking.update({
    where: { id },
    data: { status },
  });
  revalidatePath("/admin/test-rides");
}

export async function deleteBookingAction(formData: FormData) {
  await requireAdmin(SALES_ROLES);
  if (!hasDatabaseUrl) return;
  const id = requiredValue(formData, "id");
  await prisma.testRideBooking.delete({ where: { id } });
  revalidatePath("/admin/test-rides");
}

export async function updateLeadStatusAction(formData: FormData) {
  await requireAdmin(SALES_ROLES);
  if (!hasDatabaseUrl) return;
  const id = requiredValue(formData, "id");
  const status = leadStatusSchema.parse(String(formData.get("status") ?? "NEW"));
  await prisma.lead.update({
    where: { id },
    data: {
      status,
      notes: String(formData.get("notes") ?? ""),
    },
  });
  revalidatePath("/admin/leads");
}

export async function deleteLeadAction(formData: FormData) {
  await requireAdmin(SALES_ROLES);
  if (!hasDatabaseUrl) return;
  const id = requiredValue(formData, "id");
  await prisma.lead.delete({ where: { id } });
  revalidatePath("/admin/leads");
}

export async function saveNewsPopupAction(formData: FormData) {
  await requireAdmin(CONTENT_ROLES);
  if (!hasDatabaseUrl) return;

  const id = String(formData.get("id") ?? "").trim();
  const title = requiredValue(formData, "title");
  const description = requiredValue(formData, "description");
  const imageUrl = String(formData.get("imageUrl") ?? "").trim() || null;
  const ctaLabel = String(formData.get("ctaLabel") ?? "").trim() || null;
  const ctaUrl = String(formData.get("ctaUrl") ?? "").trim() || null;
  const startsAtValue = String(formData.get("startsAt") ?? "").trim();
  const endsAtValue = String(formData.get("endsAt") ?? "").trim();

  const data = {
    title,
    description,
    imageUrl,
    ctaLabel,
    ctaUrl,
    isActive: formData.get("isActive") === "on",
    showOnce: formData.get("showOnce") === "on",
    startsAt: startsAtValue ? new Date(startsAtValue) : null,
    endsAt: endsAtValue ? new Date(endsAtValue) : null,
  };

  const newsPopupModel = (prisma as any).newsPopup;

  if (newsPopupModel) {
    if (id) {
      await newsPopupModel.update({
        where: { id },
        data,
      });
    } else {
      await newsPopupModel.create({ data });
    }
  } else if (id) {
    await prisma.$executeRaw`
      UPDATE "NewsPopup"
      SET
        "title" = ${data.title},
        "description" = ${data.description},
        "imageUrl" = ${data.imageUrl},
        "ctaLabel" = ${data.ctaLabel},
        "ctaUrl" = ${data.ctaUrl},
        "isActive" = ${data.isActive},
        "showOnce" = ${data.showOnce},
        "startsAt" = ${data.startsAt},
        "endsAt" = ${data.endsAt},
        "updatedAt" = NOW()
      WHERE "id" = ${id}
    `;
  } else {
    await prisma.$executeRaw`
      INSERT INTO "NewsPopup" (
        "id",
        "title",
        "description",
        "imageUrl",
        "ctaLabel",
        "ctaUrl",
        "isActive",
        "startsAt",
        "endsAt",
        "showOnce",
        "createdAt",
        "updatedAt"
      ) VALUES (
        ${randomUUID()},
        ${data.title},
        ${data.description},
        ${data.imageUrl},
        ${data.ctaLabel},
        ${data.ctaUrl},
        ${data.isActive},
        ${data.startsAt},
        ${data.endsAt},
        ${data.showOnce},
        NOW(),
        NOW()
      )
    `;
  }

  revalidatePath("/admin/news-popup");
  revalidatePath("/");
}

export async function deleteNewsPopupAction(formData: FormData) {
  await requireAdmin(CONTENT_ROLES);
  if (!hasDatabaseUrl) return;
  const id = requiredValue(formData, "id");
  const newsPopupModel = (prisma as any).newsPopup;
  if (newsPopupModel) {
    await newsPopupModel.delete({ where: { id } });
  } else {
    await prisma.$executeRaw`DELETE FROM "NewsPopup" WHERE "id" = ${id}`;
  }
  revalidatePath("/admin/news-popup");
  revalidatePath("/");
}

export async function saveHomepageBannerAction(formData: FormData) {
  await requireAdmin(CONTENT_ROLES);
  if (!hasDatabaseUrl) return;

  const imageUrl = requiredValue(formData, "imageUrl");
  const altText = requiredValue(formData, "altText");
  const ctaUrl = String(formData.get("ctaUrl") ?? "").trim() || null;
  const isActive = formData.get("isActive") === "on";

  const homepageBannerModel = (prisma as any).homepageBanner;
  if (homepageBannerModel) {
    const existing = await homepageBannerModel.findFirst({
      orderBy: [{ updatedAt: "desc" }],
    });

    if (existing) {
      if (existing.imageUrl && existing.imageUrl !== imageUrl) {
        await deleteUploadedImageFile(existing.imageUrl);
      }
      await homepageBannerModel.update({
        where: { id: existing.id },
        data: { imageUrl, altText, ctaUrl, isActive },
      });
    } else {
      await homepageBannerModel.create({
        data: { imageUrl, altText, ctaUrl, isActive },
      });
    }
  } else {
    const exists = await tableExists("HomepageBanner");
    if (!exists) {
      return;
    }

    const existing = (
      await prisma.$queryRaw<Array<Record<string, any>>>`
        SELECT *
        FROM "HomepageBanner"
        ORDER BY "updatedAt" DESC
        LIMIT 1
      `
    )[0];

    if (existing) {
      if (existing.imageUrl && existing.imageUrl !== imageUrl) {
        await deleteUploadedImageFile(String(existing.imageUrl));
      }
      await prisma.$executeRaw`
        UPDATE "HomepageBanner"
        SET
          "imageUrl" = ${imageUrl},
          "altText" = ${altText},
          "ctaUrl" = ${ctaUrl},
          "isActive" = ${isActive},
          "updatedAt" = NOW()
        WHERE "id" = ${String(existing.id)}
      `;
    } else {
      await prisma.$executeRaw`
        INSERT INTO "HomepageBanner" (
          "id",
          "imageUrl",
          "altText",
          "ctaUrl",
          "isActive",
          "createdAt",
          "updatedAt"
        ) VALUES (
          ${randomUUID()},
          ${imageUrl},
          ${altText},
          ${ctaUrl},
          ${isActive},
          NOW(),
          NOW()
        )
      `;
    }
  }

  revalidatePath("/admin/settings");
  revalidatePath("/");
}

export async function deleteHomepageBannerAction() {
  await requireAdmin(CONTENT_ROLES);
  if (!hasDatabaseUrl) return;

  const homepageBannerModel = (prisma as any).homepageBanner;
  if (homepageBannerModel) {
    const existing = await homepageBannerModel.findFirst({
      orderBy: [{ updatedAt: "desc" }],
    });

    if (existing) {
      await deleteUploadedImageFile(existing.imageUrl);
      await homepageBannerModel.delete({ where: { id: existing.id } });
    }
  } else {
    const exists = await tableExists("HomepageBanner");
    if (!exists) {
      return;
    }

    const existing = (
      await prisma.$queryRaw<Array<Record<string, any>>>`
        SELECT *
        FROM "HomepageBanner"
        ORDER BY "updatedAt" DESC
        LIMIT 1
      `
    )[0];

    if (existing) {
      await deleteUploadedImageFile(String(existing.imageUrl ?? ""));
      await prisma.$executeRaw`DELETE FROM "HomepageBanner" WHERE "id" = ${String(existing.id)}`;
    }
  }

  revalidatePath("/admin/settings");
  revalidatePath("/");
}

const cmsPages = ["scooters", "brands", "offers", "about", "parts", "gallery", "contact"] as const;

async function upsertCmsSetting(key: string, value: unknown) {
  const jsonValue = JSON.stringify(value);
  const cmsSettingModel = (prisma as any).cmsSetting;
  if (cmsSettingModel) {
    await cmsSettingModel.upsert({
      where: { key },
      update: { value: value as any },
      create: { key, value: value as any },
    });
    return;
  }

  const existing = (
    await prisma.$queryRaw<Array<Record<string, any>>>`
      SELECT *
      FROM "CmsSetting"
      WHERE "key" = ${key}
      LIMIT 1
    `
  )[0];

  if (existing) {
    await prisma.$executeRaw`
      UPDATE "CmsSetting"
      SET "value" = ${jsonValue}::jsonb, "updatedAt" = NOW()
      WHERE "key" = ${key}
    `;
    return;
  }

  await prisma.$executeRaw`
    INSERT INTO "CmsSetting" ("id", "key", "value", "createdAt", "updatedAt")
    VALUES (${randomUUID()}, ${key}, ${jsonValue}::jsonb, NOW(), NOW())
  `;
}

export async function saveCmsPageHeroImagesAction(formData: FormData) {
  await requireAdmin(CONTENT_ROLES);
  if (!hasDatabaseUrl) return;

  for (const page of cmsPages) {
    const imageUrl = String(formData.get(`heroImage_${page}`) ?? "").trim();
    if (!imageUrl) continue;
    await upsertCmsSetting(`hero_image_${page}`, { imageUrl });
  }

  revalidatePath("/admin/cms");
  revalidatePath("/scooters");
  revalidatePath("/brands");
  revalidatePath("/offers");
  revalidatePath("/about");
  revalidatePath("/parts");
  revalidatePath("/gallery");
  revalidatePath("/contact");
}

export async function saveCmsFinanceSettingAction(formData: FormData) {
  await requireAdmin(CONTENT_ROLES);
  if (!hasDatabaseUrl) return;

  const enabled = formData.get("financeEnabled") === "on";
  await upsertCmsSetting("finance_enabled", { enabled });

  revalidatePath("/admin/cms");
  revalidatePath("/offers");
  revalidatePath("/scooters");
  revalidatePath("/");
}

export async function saveCmsSiteProfileAction(formData: FormData) {
  await requireAdmin(CONTENT_ROLES);
  if (!hasDatabaseUrl) return;

  const siteProfile = {
    siteName: String(formData.get("siteName") ?? "").trim() || "Bashista Auto",
    tagline: String(formData.get("tagline") ?? "").trim() || "Drive the Future",
    primaryPhone: String(formData.get("primaryPhone") ?? "").trim(),
    secondaryPhone: String(formData.get("secondaryPhone") ?? "").trim(),
    mainBranch: String(formData.get("mainBranch") ?? "").trim(),
    secondBranch: String(formData.get("secondBranch") ?? "").trim(),
    supportEmail: String(formData.get("supportEmail") ?? "").trim(),
    facebookUrl: String(formData.get("facebookUrl") ?? "").trim(),
    instagramUrl: String(formData.get("instagramUrl") ?? "").trim(),
    youtubeUrl: String(formData.get("youtubeUrl") ?? "").trim(),
    tiktokUrl: String(formData.get("tiktokUrl") ?? "").trim(),
    whatsappUrl: String(formData.get("whatsappUrl") ?? "").trim(),
    openingHoursWeek: String(formData.get("openingHoursWeek") ?? "").trim(),
    openingHoursSat: String(formData.get("openingHoursSat") ?? "").trim(),
    holidayNote: String(formData.get("holidayNote") ?? "").trim(),
  };

  await upsertCmsSetting("site_profile", siteProfile);

  revalidatePath("/admin/cms");
  revalidatePath("/");
  revalidatePath("/contact");
  revalidatePath("/about");
  revalidatePath("/offers");
}

export async function saveCmsHomeBannerProductAction(formData: FormData) {
  await requireAdmin(CONTENT_ROLES);
  if (!hasDatabaseUrl) return;

  const scooterId = String(formData.get("homeBannerScooterId") ?? "").trim();
  if (!scooterId) return;

  await upsertCmsSetting("home_banner_scooter_id", { scooterId });
  revalidatePath("/admin/cms");
  revalidatePath("/");
}

export async function saveCmsHomeBannerProductImageAction(formData: FormData) {
  await requireAdmin(CONTENT_ROLES);
  if (!hasDatabaseUrl) return;

  const imageUrl = String(formData.get("homeBannerProductImage") ?? "").trim();
  if (!imageUrl) return;

  await upsertCmsSetting("home_banner_product_image", { imageUrl });
  revalidatePath("/admin/cms");
  revalidatePath("/");
}

const cmsPageImageControlKeys = [
  "scooters_banner_product_image",
  "brands_banner_product_image",
  "brands_cta_product_image",
  "offers_banner_product_image",
  "about_banner_product_image",
  "about_story_image",
  "about_cta_image",
  "parts_banner_product_image",
  "parts_support_image",
  "gallery_banner_product_image",
  "contact_banner_product_image",
  "contact_cta_image",
] as const;

export async function saveCmsPageImageControlsAction(formData: FormData) {
  await requireAdmin(CONTENT_ROLES);
  if (!hasDatabaseUrl) return;

  for (const key of cmsPageImageControlKeys) {
    const imageUrl = String(formData.get(key) ?? "").trim();
    if (!imageUrl) continue;
    await upsertCmsSetting(key, { imageUrl });
  }

  revalidatePath("/admin/cms");
  revalidatePath("/scooters");
  revalidatePath("/brands");
  revalidatePath("/offers");
  revalidatePath("/about");
  revalidatePath("/parts");
  revalidatePath("/gallery");
  revalidatePath("/contact");
}

const cmsContentPages = ["scooters", "brands", "offers", "about", "parts", "gallery", "contact"] as const;

export async function saveCmsPageContentAction(formData: FormData) {
  await requireAdmin(CONTENT_ROLES);
  if (!hasDatabaseUrl) return;

  for (const page of cmsContentPages) {
    const payload = {
      heroTitle: String(formData.get(`${page}_heroTitle`) ?? "").trim(),
      heroSubtitle: String(formData.get(`${page}_heroSubtitle`) ?? "").trim(),
      heroDescription: String(formData.get(`${page}_heroDescription`) ?? "").trim(),
    };
    await upsertCmsSetting(`page_content_${page}`, payload);
  }

  revalidatePath("/admin/cms");
  revalidatePath("/scooters");
  revalidatePath("/brands");
  revalidatePath("/offers");
  revalidatePath("/about");
  revalidatePath("/parts");
  revalidatePath("/gallery");
  revalidatePath("/contact");
}

export async function saveCmsPageSectionsAction(formData: FormData) {
  await requireAdmin(CONTENT_ROLES);
  if (!hasDatabaseUrl) return;

  for (const page of cmsContentPages) {
    const payload = {
      section1: formData.get(`${page}_section1`) === "on",
      section2: formData.get(`${page}_section2`) === "on",
      section3: formData.get(`${page}_section3`) === "on",
      section4: formData.get(`${page}_section4`) === "on",
      section5: formData.get(`${page}_section5`) === "on",
      section6: formData.get(`${page}_section6`) === "on",
    };
    await upsertCmsSetting(`page_sections_${page}`, payload);
  }

  revalidatePath("/admin/cms");
  revalidatePath("/scooters");
  revalidatePath("/brands");
  revalidatePath("/offers");
  revalidatePath("/about");
  revalidatePath("/parts");
  revalidatePath("/gallery");
  revalidatePath("/contact");
}