import { config as loadEnv } from "dotenv";
import { createHash } from "node:crypto";
import { access, mkdir, readFile, writeFile } from "node:fs/promises";
import { dirname, resolve } from "node:path";
import { fileURLToPath } from "node:url";
import { Prisma, PrismaClient } from "@prisma/client";
import { bottomCtas, destinations, heroSlides, themeCards } from "../../../src/content.ts";
import { DESTINATION_PAGE_CONFIG_ID, DESTINATION_RECOMMENDATION_LIMIT } from "../src/destination-page.ts";
import { createHomeModuleSnapshot, DEFAULT_HOME_MODULES } from "../src/home-module-defaults.ts";
import { DEFAULT_SEARCH_PAGE_CONFIG, SEARCH_PAGE_CONFIG_ID } from "../src/search-page.ts";
import { isManagedMediaUrl, mediaPublicBaseUrl } from "../src/media-storage.ts";

const rootDir = resolve(dirname(fileURLToPath(import.meta.url)), "../../..");
loadEnv({ path: resolve(rootDir, ".env") });

const prisma = new PrismaClient();

const SNAPSHOT_FORMAT_VERSION = 1 as const;
const RELEASE_TITLE_PREFIX = "content-release:";
const LEGACY_CAMPAIGN_SLUGS = ["classic-deal", "outdoor-deal", "mixed-route"] as const;
const LEGACY_HOME_MODULE_IDS = ["routes"] as const;

const DESTINATION_ALIASES: Record<string, string[]> = {
  贵阳: ["贵阳", "青岩", "花溪", "高坡", "天河潭"],
  黄果树: ["黄果树", "安顺", "坝陵河", "瀑布"],
  荔波小七孔: ["荔波", "小七孔", "茂兰", "水上森林"],
  西江苗寨: ["西江", "苗寨", "郎德", "雷山", "苗岭"],
  梵净山: ["梵净山", "铜仁", "云舍", "寨沙"],
  镇远: ["镇远", "青龙洞", "古城"],
  肇兴: ["肇兴", "侗寨", "堂安", "加榜", "黎平"],
  万峰林: ["万峰林", "万峰湖", "马岭河", "兴义", "黔西南"],
  织金洞: ["织金洞", "织金", "洞穴", "喀斯特"],
  赤水丹霞: ["赤水", "丹霞", "竹海", "丙安"],
  青岩古镇: ["青岩", "古镇", "屯堡"],
  百里杜鹃: ["百里杜鹃", "毕节", "花季"],
  乌蒙草原: ["乌蒙", "六盘水", "草原", "避暑"],
  中国天眼: ["中国天眼", "平塘", "观星", "科普"],
  遵义: ["遵义", "黔北", "红色文化"],
  茅台镇: ["茅台", "酱香", "酒旅"],
};

type SourceProduct = {
  id: number;
  title: string;
  price: string;
  tags: string[];
  image: string;
  summary?: string;
  destinationName?: string;
  priceUnit?: string;
  pricingTiers?: Array<{
    groupSize: number;
    adultPrice: number;
    child6PlusPrice: number;
    childUnder6Price: number;
  }>;
  images?: { url: string; alt?: string | null; sortOrder?: number }[];
  durationDays?: number | null;
  durationNights?: number | null;
  departureDates?: string[];
  remainingSpots?: number | null;
  recommendation?: string | null;
  keyFacts?: Array<{ label: string; value: string }>;
  contentBlocks?: Array<{ type: "title"; text: string } | { type: "image"; url: string; alt?: string | null }>;
  detailSections?: Array<{
    key: string;
    label: string;
    title?: string | null;
    blocks: Array<{ type: "text"; text: string } | { type: "image"; url: string; alt?: string | null }>;
  }>;
};

type ReleaseData = {
  releaseKey: string;
  contentHash: string;
  homeModules: typeof DEFAULT_HOME_MODULES;
  heroSlides: typeof heroSlides;
  destinations: typeof destinations;
  themeCards: typeof themeCards;
  ctaBanners: typeof bottomCtas;
  searchPage: typeof DEFAULT_SEARCH_PAGE_CONFIG;
  products: SourceProduct[];
  campaigns: Array<{
    slug: string;
    title: string;
    start: number;
    end: number;
    coverImage?: string;
  }>;
  mediaAssets: Array<{ url: string; group: string; name?: string }>;
};

type ReleaseManifest = {
  homeModuleIds: string[];
  heroSlideIds: string[];
  destinationIds: string[];
  themeCardIds: string[];
  ctaBannerIds: string[];
  productIds: string[];
  campaignIds: string[];
  mediaUrls: string[];
};

type ContentSnapshot = {
  formatVersion: typeof SNAPSHOT_FORMAT_VERSION;
  releaseKey: string;
  contentHash: string;
  createdAt: string;
  rows: {
    homeModules: unknown[];
    heroSlides: unknown[];
    destinations: unknown[];
    themeCards: unknown[];
    ctaBanners: unknown[];
    destinationPageConfig: unknown | null;
    searchPageConfig: unknown | null;
    products: unknown[];
    campaigns: unknown[];
    mediaAssets: unknown[];
    siteVersion: unknown | null;
  };
};

type DbClient = PrismaClient | Prisma.TransactionClient;

type DestinationWithAliases = Prisma.DestinationGetPayload<{ include: { aliases: true } }>;
type ProductWithImages = Prisma.ProductGetPayload<{ include: { images: true } }>;
type CampaignWithProducts = Prisma.CampaignGetPayload<{ include: { products: true } }>;

type ContentState = {
  homeModules: Awaited<ReturnType<DbClient["homeModule"]["findMany"]>>;
  heroSlides: Awaited<ReturnType<DbClient["heroSlide"]["findMany"]>>;
  destinations: DestinationWithAliases[];
  themeCards: Awaited<ReturnType<DbClient["themeCard"]["findMany"]>>;
  ctaBanners: Awaited<ReturnType<DbClient["ctaBanner"]["findMany"]>>;
  products: ProductWithImages[];
  campaigns: CampaignWithProducts[];
  destinationPageConfig: Awaited<ReturnType<DbClient["destinationPageConfig"]["findUnique"]>>;
  searchPageConfig: Awaited<ReturnType<DbClient["searchPageConfig"]["findUnique"]>>;
  mediaAssets: Awaited<ReturnType<DbClient["mediaAsset"]["findMany"]>>;
  siteVersion: Awaited<ReturnType<DbClient["siteVersion"]["findUnique"]>>;
};

function slugify(input: string) {
  return encodeURIComponent(input).replace(/%/g, "").toLowerCase();
}

function stableUuid(input: string) {
  const hex = createHash("sha256").update(input).digest("hex").slice(0, 32);
  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
}

function jsonClone<T>(value: T): T {
  return JSON.parse(JSON.stringify(value)) as T;
}

function asRecord(value: unknown): Record<string, unknown> | null {
  return value && typeof value === "object" && !Array.isArray(value) ? value as Record<string, unknown> : null;
}

function stringArray(value: unknown): string[] {
  return Array.isArray(value) ? value.filter((item): item is string => typeof item === "string") : [];
}

function emptyManifest(): ReleaseManifest {
  return {
    homeModuleIds: [],
    heroSlideIds: [],
    destinationIds: [],
    themeCardIds: [],
    ctaBannerIds: [],
    productIds: [],
    campaignIds: [],
    mediaUrls: [],
  };
}

function parseManifest(snapshot: unknown): ReleaseManifest | null {
  const root = asRecord(snapshot);
  const owned = asRecord(root?.owned);
  if (!owned) return null;
  return {
    homeModuleIds: stringArray(owned.homeModuleIds),
    heroSlideIds: stringArray(owned.heroSlideIds),
    destinationIds: stringArray(owned.destinationIds),
    themeCardIds: stringArray(owned.themeCardIds),
    ctaBannerIds: stringArray(owned.ctaBannerIds),
    productIds: stringArray(owned.productIds),
    campaignIds: stringArray(owned.campaignIds),
    mediaUrls: stringArray(owned.mediaUrls),
  };
}

function mergeStrings(...values: string[][]) {
  return [...new Set(values.flat())];
}

function destinationKey(name: string) {
  return slugify(name);
}

function heroKey(value: { title: string; targetType?: string | null; targetValue?: string | null }) {
  return value.targetValue ? `${value.targetType ?? ""}:${value.targetValue}` : `${value.targetType ?? ""}:${value.title}`;
}

function themeKey(value: { label: string; targetType?: string | null; targetValue?: string | null }) {
  return value.targetValue ? `${value.targetType ?? ""}:${value.targetValue}` : `${value.targetType ?? ""}:${value.label}`;
}

function ctaKey(value: { alt: string; targetType: string; targetValue?: string | null }) {
  return `${value.targetType}:${value.targetValue ?? ""}:${value.alt}`;
}

function packageOwnedHero(row: { id: string; title: string; targetType: string | null; targetValue: string | null }, previous: ReleaseManifest | null, baselineKeys: Set<string>) {
  return previous?.heroSlideIds.includes(row.id)
    || baselineKeys.has(heroKey(row));
}

function packageOwnedTheme(row: { id: string; label: string; targetType: string | null; targetValue: string | null }, previous: ReleaseManifest | null, baselineKeys: Set<string>) {
  return previous?.themeCardIds.includes(row.id)
    || baselineKeys.has(themeKey(row));
}

function packageOwnedCta(row: { id: string; alt: string; targetType: string; targetValue: string | null }, previous: ReleaseManifest | null, baselineKeys: Set<string>) {
  return previous?.ctaBannerIds.includes(row.id) || baselineKeys.has(ctaKey(row));
}

function packageOwnedDestination(row: { id: string; name: string; slug: string }, previous: ReleaseManifest | null, baselineSlugs: Set<string>) {
  return previous?.destinationIds.includes(row.id) || baselineSlugs.has(row.slug) || baselineSlugs.has(destinationKey(row.name));
}

function packageOwnedCampaign(row: { id: string; slug: string }, previous: ReleaseManifest | null, baselineSlugs: Set<string>) {
  return previous?.campaignIds.includes(row.id) || baselineSlugs.has(row.slug) || LEGACY_CAMPAIGN_SLUGS.includes(row.slug as typeof LEGACY_CAMPAIGN_SLUGS[number]);
}

function packageOwnedHomeModule(row: { id: string; isSystem: boolean }, previous: ReleaseManifest | null, baselineIds: Set<string>) {
  return previous?.homeModuleIds.includes(row.id) || baselineIds.has(row.id) || row.isSystem || LEGACY_HOME_MODULE_IDS.includes(row.id as typeof LEGACY_HOME_MODULE_IDS[number]);
}

function collectImageUrls(value: unknown, fieldName?: string): string[] {
  if (typeof value === "string") {
    return fieldName && new Set(["image", "coverImage", "url"]).has(fieldName) ? [value] : [];
  }
  if (Array.isArray(value)) return value.flatMap((item) => collectImageUrls(item));
  if (!value || typeof value !== "object") return [];
  return Object.entries(value).flatMap(([key, child]) => collectImageUrls(child, key));
}

function addMedia(map: Map<string, { url: string; group: string; name?: string }>, value: unknown, group: string, name?: string) {
  if (typeof value === "string") {
    if (value) map.set(value, { url: value, group, name });
    return;
  }
  for (const url of collectImageUrls(value)) {
    if (!url) continue;
    map.set(url, { url, group, name });
  }
}

function buildMediaAssets(data: Omit<ReleaseData, "mediaAssets" | "releaseKey" | "contentHash">) {
  const media = new Map<string, { url: string; group: string; name?: string }>();
  addMedia(media, data.homeModules, "home-module");
  addMedia(media, data.searchPage, "search-page");
  for (const item of data.heroSlides) addMedia(media, item.image, "hero", item.title);
  for (const item of data.destinations) addMedia(media, item.image, "destination", item.label);
  for (const item of data.themeCards) addMedia(media, item.image, "theme", item.label);
  for (const item of data.ctaBanners) addMedia(media, item.image, "cta", item.alt);
  for (const product of data.products) {
    addMedia(media, product.image, "product", product.title);
    addMedia(media, product.images, "product-gallery", product.title);
    addMedia(media, product.contentBlocks, "product-content", product.title);
    addMedia(media, product.detailSections, "product-detail", product.title);
  }
  for (const campaign of data.campaigns) addMedia(media, campaign.coverImage, "campaign", campaign.title);
  return [...media.values()];
}

function assertBaseline(data: Omit<ReleaseData, "releaseKey" | "contentHash" | "mediaAssets">) {
  const productIds = data.products.map((product) => product.id);
  if (new Set(productIds).size !== productIds.length) throw new Error("内容包中的商品 sourceId 重复");
  if (data.products.some((product) => !Number.isInteger(Number(product.price)) || Number(product.price) < 0)) {
    throw new Error("内容包中存在非法商品价格");
  }

  const destinationLabels = data.destinations.map((item) => item.label);
  if (new Set(destinationLabels).size !== destinationLabels.length) throw new Error("内容包中的目的地名称重复");

  const mediaAssets = buildMediaAssets(data);
  if (!mediaPublicBaseUrl || mediaPublicBaseUrl === "https://.") {
    throw new Error("无法确定 OSS 公共地址，请配置 MEDIA_PUBLIC_BASE_URL 或 OSS_BUCKET_NAME/OSS_ENDPOINT");
  }
  const unmanaged = mediaAssets.filter((asset) => !isManagedMediaUrl(asset.url));
  if (unmanaged.length) {
    throw new Error(`内容包包含未托管的图片 URL：${unmanaged.slice(0, 5).map((item) => item.url).join(", ")}`);
  }
  return mediaAssets;
}

async function loadReleaseData(): Promise<ReleaseData> {
  const productFile = await readFile(resolve(rootDir, "src/generated-products.json"), "utf8");
  const products = JSON.parse(productFile) as SourceProduct[];
  const data = {
    homeModules: DEFAULT_HOME_MODULES,
    heroSlides,
    destinations,
    themeCards,
    ctaBanners: bottomCtas,
    searchPage: DEFAULT_SEARCH_PAGE_CONFIG,
    products,
    campaigns: [
      { slug: "classic-deal", title: "经典打卡特惠", start: 0, end: 8, coverImage: heroSlides[0]?.image },
      { slug: "outdoor-deal", title: "山野野咖特惠", start: 8, end: 16, coverImage: heroSlides[1]?.image },
      { slug: "mixed-route", title: "人文户外混搭", start: 16, end: 24, coverImage: heroSlides[2]?.image },
    ],
  };
  const mediaAssets = assertBaseline(data);
  const contentHash = createHash("sha256").update(JSON.stringify(data)).digest("hex");
  return {
    ...data,
    mediaAssets,
    contentHash,
    releaseKey: `miniapp-content-${contentHash.slice(0, 16)}`,
  };
}

async function latestRelease(db: DbClient) {
  return db.siteVersion.findFirst({
    where: { title: { startsWith: RELEASE_TITLE_PREFIX }, status: "published" },
    orderBy: { createdAt: "desc" },
  });
}

async function readContentState(db: DbClient, data: ReleaseData, previous: ReleaseManifest | null): Promise<ContentState> {
  const baselineHomeIds = new Set(data.homeModules.map((item) => item.id));
  const baselineHeroKeys = new Set(data.heroSlides.map((item) => heroKey(item)));
  const baselineThemeKeys = new Set(data.themeCards.map((item) => themeKey(item)));
  const baselineCtaKeys = new Set(data.ctaBanners.map((item) => ctaKey(item)));
  const baselineDestinationSlugs = new Set(data.destinations.map((item) => destinationKey(item.label)));
  const baselineCampaignSlugs = new Set(data.campaigns.map((item) => item.slug));
  const mediaUrls = mergeStrings(data.mediaAssets.map((item) => item.url), previous?.mediaUrls ?? []);

  const [allHomeModules, allHeroSlides, allDestinations, allThemeCards, allCtas, allProducts, allCampaigns, destinationPageConfig, searchPageConfig, mediaAssets, release] = await Promise.all([
    db.homeModule.findMany(),
    db.heroSlide.findMany(),
    db.destination.findMany({ include: { aliases: true } }),
    db.themeCard.findMany(),
    db.ctaBanner.findMany(),
    db.product.findMany({ include: { images: true } }),
    db.campaign.findMany({ include: { products: true } }),
    db.destinationPageConfig.findUnique({ where: { id: DESTINATION_PAGE_CONFIG_ID } }),
    db.searchPageConfig.findUnique({ where: { id: SEARCH_PAGE_CONFIG_ID } }),
    mediaUrls.length ? db.mediaAsset.findMany({ where: { url: { in: mediaUrls } } }) : Promise.resolve([]),
    db.siteVersion.findUnique({ where: { id: stableUuid(data.releaseKey) } }),
  ]);

  return {
    homeModules: allHomeModules.filter((row) => packageOwnedHomeModule(row, previous, baselineHomeIds)),
    heroSlides: allHeroSlides.filter((row) => packageOwnedHero(row, previous, baselineHeroKeys)),
    destinations: allDestinations.filter((row) => packageOwnedDestination(row, previous, baselineDestinationSlugs)),
    themeCards: allThemeCards.filter((row) => packageOwnedTheme(row, previous, baselineThemeKeys)),
    ctaBanners: allCtas.filter((row) => packageOwnedCta(row, previous, baselineCtaKeys)),
    products: allProducts.filter((row) => row.sourceId !== null || previous?.productIds.includes(row.id)),
    campaigns: allCampaigns.filter((row) => packageOwnedCampaign(row, previous, baselineCampaignSlugs)),
    destinationPageConfig,
    searchPageConfig,
    mediaAssets,
    siteVersion: release,
  };
}

function sourceProductFields(product: SourceProduct, destinationId: string | null, publishedAt: Date): Prisma.ProductUncheckedCreateInput {
  const summary = product.summary ?? product.tags.join(" · ");
  const priceAmount = Number(product.price);
  return {
    sourceId: product.id,
    title: product.title,
    subtitle: product.title.replace(/^【.*?】\s*/, "").split("·")[0],
    destinationId,
    priceAmount,
    priceUnit: product.priceUnit ?? "咨询价",
    pricingTiers: product.pricingTiers?.length ? product.pricingTiers as Prisma.InputJsonValue : Prisma.JsonNull,
    tags: product.tags,
    coverImage: product.image,
    summary,
    durationDays: product.durationDays ?? null,
    durationNights: product.durationNights ?? null,
    departureDates: product.departureDates ?? [],
    remainingSpots: product.remainingSpots ?? null,
    recommendation: product.recommendation ?? null,
    keyFacts: (product.keyFacts?.length ? product.keyFacts : defaultKeyFacts(product)) as Prisma.InputJsonValue,
    contentBlocks: product.contentBlocks?.length ? product.contentBlocks as Prisma.InputJsonValue : Prisma.JsonNull,
    detailSections: product.detailSections?.length ? product.detailSections as Prisma.InputJsonValue : Prisma.JsonNull,
    status: "published",
    sortWeight: product.id,
    publishedAt,
  };
}

function defaultKeyFacts(product: SourceProduct) {
  const duration = product.title.match(/\d+天\d+晚/)?.[0];
  return [
    duration ? { label: "行程时长", value: duration } : null,
    product.tags[0] ? { label: "线路类型", value: product.tags[0] } : null,
    { label: "成团方式", value: "专属小包团" },
  ].filter((fact): fact is { label: string; value: string } => Boolean(fact));
}

function productImages(product: SourceProduct) {
  return product.images?.length ? product.images : [{ url: product.image, alt: product.title, sortOrder: 0 }];
}

function currentProductBySourceId(products: ProductWithImages[], sourceId: number) {
  const matches = products.filter((item) => item.sourceId === sourceId);
  if (matches.length > 1) throw new Error(`生产库存在重复的商品 sourceId：${sourceId}`);
  return matches[0];
}

function currentByKey<T>(rows: T[], key: (row: T) => string, target: string, label: string) {
  const matches = rows.filter((row) => key(row) === target);
  if (matches.length > 1) throw new Error(`生产库存在重复的${label}内容标识：${target}`);
  return matches[0];
}

function archivedPublishedConfig(value: Prisma.JsonValue | null) {
  const snapshot = asRecord(value);
  if (!snapshot) return undefined;
  return {
    ...snapshot,
    isActive: false,
    isDeleted: true,
  } as Prisma.InputJsonValue;
}

async function upsertMedia(db: Prisma.TransactionClient, media: ReleaseData["mediaAssets"]) {
  for (const item of media) {
    await db.mediaAsset.upsert({
      where: { url: item.url },
      update: { group: item.group, name: item.name },
      create: { url: item.url, group: item.group, name: item.name },
    });
  }
}

async function applyContent(db: Prisma.TransactionClient, data: ReleaseData, previous: ReleaseManifest | null) {
  const current = await readContentState(db, data, previous);
  const manifest = emptyManifest();
  const baselineHomeIds = new Set(data.homeModules.map((item) => item.id));
  const baselineHeroKeys = new Set(data.heroSlides.map((item) => heroKey(item)));
  const baselineThemeKeys = new Set(data.themeCards.map((item) => themeKey(item)));
  const baselineCtaKeys = new Set(data.ctaBanners.map((item) => ctaKey(item)));
  const baselineDestinationSlugs = new Set(data.destinations.map((item) => destinationKey(item.label)));
  const baselineCampaignSlugs = new Set(data.campaigns.map((item) => item.slug));
  const baselineProductSourceIds = new Set(data.products.map((item) => item.id));

  for (const module of data.homeModules) {
    const snapshot = createHomeModuleSnapshot(module);
    const row = await db.homeModule.upsert({
      where: { id: module.id },
      update: {
        label: module.label,
        templateType: module.templateType,
        content: module.content as Prisma.InputJsonValue,
        publishedConfig: snapshot as Prisma.InputJsonValue,
        sortOrder: module.sortOrder,
        isActive: module.isActive,
        isSystem: true,
        isDeleted: module.isDeleted,
      },
      create: {
        id: module.id,
        label: module.label,
        templateType: module.templateType,
        content: module.content as Prisma.InputJsonValue,
        publishedConfig: snapshot as Prisma.InputJsonValue,
        sortOrder: module.sortOrder,
        isActive: module.isActive,
        isSystem: true,
        isDeleted: module.isDeleted,
      },
    });
    manifest.homeModuleIds.push(row.id);
  }

  for (const row of current.homeModules) {
    if (!baselineHomeIds.has(row.id)) {
      await db.homeModule.update({
        where: { id: row.id },
        data: {
          isActive: false,
          isDeleted: true,
          publishedConfig: archivedPublishedConfig(row.publishedConfig),
        },
      });
    }
  }

  for (const [index, slide] of data.heroSlides.entries()) {
    const existing = currentByKey(current.heroSlides, heroKey, heroKey(slide), "轮播");
    const row = existing
      ? await db.heroSlide.update({
          where: { id: existing.id },
          data: {
            title: slide.title,
            kicker: slide.kicker,
            actionLabel: slide.action,
            image: slide.image,
            targetType: slide.targetType,
            targetValue: slide.targetValue,
            sortOrder: index,
            isActive: true,
          },
        })
      : await db.heroSlide.create({
          data: {
            title: slide.title,
            kicker: slide.kicker,
            actionLabel: slide.action,
            image: slide.image,
            targetType: slide.targetType,
            targetValue: slide.targetValue,
            sortOrder: index,
            isActive: true,
          },
        });
    manifest.heroSlideIds.push(row.id);
  }
  for (const row of current.heroSlides) {
    if (!baselineHeroKeys.has(heroKey(row))) {
      await db.heroSlide.update({ where: { id: row.id }, data: { isActive: false } });
    }
  }

  const destinationMap = new Map<string, string>();
  for (const [index, item] of data.destinations.entries()) {
    const slug = destinationKey(item.label);
    const existing = currentByKey(current.destinations, (row) => row.slug === slug || row.name === item.label ? "match" : "no-match", "match", "目的地");
    const row = existing
      ? await db.destination.update({
          where: { id: existing.id },
          data: {
            name: item.label,
            slug,
            image: item.image,
            isHot: index < 8,
            sortOrder: index,
            isActive: true,
          },
        })
      : await db.destination.create({
          data: {
            name: item.label,
            slug,
            image: item.image,
            isHot: index < 8,
            sortOrder: index,
            isActive: true,
          },
        });
    await db.destinationAlias.deleteMany({ where: { destinationId: row.id } });
    const aliases = DESTINATION_ALIASES[item.label] ?? [item.label];
    if (aliases.length) await db.destinationAlias.createMany({ data: aliases.map((alias) => ({ destinationId: row.id, alias })) });
    destinationMap.set(item.label, row.id);
    manifest.destinationIds.push(row.id);
  }
  for (const row of current.destinations) {
    if (!baselineDestinationSlugs.has(row.slug) && !baselineDestinationSlugs.has(destinationKey(row.name))) {
      await db.destination.update({ where: { id: row.id }, data: { isActive: false } });
    }
  }

  for (const [index, card] of data.themeCards.entries()) {
    const existing = currentByKey(current.themeCards, themeKey, themeKey(card), "主题卡片");
    const row = existing
      ? await db.themeCard.update({
          where: { id: existing.id },
          data: {
            label: card.label,
            image: card.image,
            targetType: card.targetType,
            targetValue: card.targetValue,
            sortOrder: index,
            isActive: true,
          },
        })
      : await db.themeCard.create({
          data: {
            label: card.label,
            image: card.image,
            targetType: card.targetType,
            targetValue: card.targetValue,
            sortOrder: index,
            isActive: true,
          },
        });
    manifest.themeCardIds.push(row.id);
  }
  for (const row of current.themeCards) {
    if (!baselineThemeKeys.has(themeKey(row))) await db.themeCard.update({ where: { id: row.id }, data: { isActive: false } });
  }

  for (const [index, cta] of data.ctaBanners.entries()) {
    const existing = currentByKey(current.ctaBanners, ctaKey, ctaKey(cta), "底部 CTA");
    const row = existing
      ? await db.ctaBanner.update({
          where: { id: existing.id },
          data: {
            alt: cta.alt,
            image: cta.image,
            targetType: cta.targetType,
            targetValue: cta.targetValue,
            sortOrder: index,
            isActive: true,
          },
        })
      : await db.ctaBanner.create({
          data: {
            alt: cta.alt,
            image: cta.image,
            targetType: cta.targetType,
            targetValue: cta.targetValue,
            sortOrder: index,
            isActive: true,
          },
        });
    manifest.ctaBannerIds.push(row.id);
  }
  for (const row of current.ctaBanners) {
    if (!baselineCtaKeys.has(ctaKey(row))) await db.ctaBanner.update({ where: { id: row.id }, data: { isActive: false } });
  }

  const productMap = new Map<number, string>();
  for (const product of data.products) {
    const matchedDestination = product.destinationName && destinationMap.has(product.destinationName)
      ? product.destinationName
      : [...destinationMap.keys()].find((label) => product.title.includes(label) || product.tags.includes(label));
    const existing = currentProductBySourceId(current.products, product.id);
    const publishedAt = existing?.status === "published" && existing.publishedAt ? existing.publishedAt : new Date();
    const fields = sourceProductFields(product, matchedDestination ? destinationMap.get(matchedDestination) ?? null : null, publishedAt);
    const row = existing
      ? await db.product.update({ where: { id: existing.id }, data: fields as Prisma.ProductUncheckedUpdateInput })
      : await db.product.create({ data: fields });
    await db.productImage.deleteMany({ where: { productId: row.id } });
    await db.productImage.createMany({
      data: productImages(product).map((image, index) => ({
        productId: row.id,
        url: image.url,
        alt: image.alt ?? product.title,
        sortOrder: image.sortOrder ?? index,
      })),
    });
    productMap.set(product.id, row.id);
    manifest.productIds.push(row.id);
  }
  for (const row of current.products) {
    if (row.sourceId === null || baselineProductSourceIds.has(row.sourceId)) continue;
    await db.product.update({ where: { id: row.id }, data: { status: "archived" } });
  }

  for (const seed of data.campaigns) {
    const existing = current.campaigns.find((campaign) => campaign.slug === seed.slug);
    const campaign = existing
      ? await db.campaign.update({
          where: { id: existing.id },
          data: {
            title: seed.title,
            description: "由当前 H5 万趣贵州小包团内容导入的活动专题。",
            coverImage: seed.coverImage,
            status: "published",
          },
        })
      : await db.campaign.create({
          data: {
            slug: seed.slug,
            title: seed.title,
            description: "由当前 H5 万趣贵州小包团内容导入的活动专题。",
            coverImage: seed.coverImage,
            status: "published",
          },
        });
    await db.campaignProduct.deleteMany({ where: { campaignId: campaign.id } });
    const linkedProducts = [...productMap.entries()]
      .filter(([sourceId]) => sourceId >= seed.start + 1 && sourceId <= seed.end)
      .sort(([left], [right]) => left - right);
    if (linkedProducts.length) {
      await db.campaignProduct.createMany({
        data: linkedProducts.map(([, productId], index) => ({ campaignId: campaign.id, productId, sortOrder: index })),
      });
    }
    manifest.campaignIds.push(campaign.id);
  }
  for (const row of current.campaigns) {
    if (!baselineCampaignSlugs.has(row.slug)) await db.campaign.update({ where: { id: row.id }, data: { status: "archived" } });
  }

  const recommendedProductIds = data.products
    .slice()
    .sort((left, right) => left.id - right.id)
    .map((product) => productMap.get(product.id))
    .filter((id): id is string => Boolean(id))
    .slice(0, DESTINATION_RECOMMENDATION_LIMIT);
  await db.destinationPageConfig.upsert({
    where: { id: DESTINATION_PAGE_CONFIG_ID },
    update: { recommendedProductIds: recommendedProductIds as Prisma.InputJsonValue },
    create: { id: DESTINATION_PAGE_CONFIG_ID, recommendedProductIds: recommendedProductIds as Prisma.InputJsonValue },
  });

  await db.searchPageConfig.upsert({
    where: { id: SEARCH_PAGE_CONFIG_ID },
    update: {
      title: data.searchPage.modules.seasonalInspiration.title,
      subtitle: data.searchPage.modules.seasonalInspiration.subtitle,
      placeholder: data.searchPage.placeholder,
      modules: data.searchPage.modules as Prisma.InputJsonValue,
      popularKeywords: data.searchPage.popularKeywords as Prisma.InputJsonValue,
      groups: data.searchPage.groups as Prisma.InputJsonValue,
    },
    create: {
      id: SEARCH_PAGE_CONFIG_ID,
      title: data.searchPage.modules.seasonalInspiration.title,
      subtitle: data.searchPage.modules.seasonalInspiration.subtitle,
      placeholder: data.searchPage.placeholder,
      modules: data.searchPage.modules as Prisma.InputJsonValue,
      popularKeywords: data.searchPage.popularKeywords as Prisma.InputJsonValue,
      groups: data.searchPage.groups as Prisma.InputJsonValue,
    },
  });

  await upsertMedia(db, data.mediaAssets);
  manifest.mediaUrls = data.mediaAssets.map((item) => item.url);

  const siteVersionId = stableUuid(data.releaseKey);
  await db.siteVersion.upsert({
    where: { id: siteVersionId },
    update: {
      title: `${RELEASE_TITLE_PREFIX}${data.releaseKey}`,
      status: "published",
      publishedAt: new Date(),
      snapshot: {
        formatVersion: SNAPSHOT_FORMAT_VERSION,
        releaseKey: data.releaseKey,
        contentHash: data.contentHash,
        owned: manifest,
        counts: {
          homeModules: data.homeModules.length,
          heroSlides: data.heroSlides.length,
          destinations: data.destinations.length,
          themeCards: data.themeCards.length,
          ctaBanners: data.ctaBanners.length,
          products: data.products.length,
          campaigns: data.campaigns.length,
          mediaAssets: data.mediaAssets.length,
        },
      } as Prisma.InputJsonValue,
    },
    create: {
      id: siteVersionId,
      title: `${RELEASE_TITLE_PREFIX}${data.releaseKey}`,
      status: "published",
      publishedAt: new Date(),
      snapshot: {
        formatVersion: SNAPSHOT_FORMAT_VERSION,
        releaseKey: data.releaseKey,
        contentHash: data.contentHash,
        owned: manifest,
        counts: {
          homeModules: data.homeModules.length,
          heroSlides: data.heroSlides.length,
          destinations: data.destinations.length,
          themeCards: data.themeCards.length,
          ctaBanners: data.ctaBanners.length,
          products: data.products.length,
          campaigns: data.campaigns.length,
          mediaAssets: data.mediaAssets.length,
        },
      } as Prisma.InputJsonValue,
    },
  });

  return { manifest, siteVersionId };
}

function without<T extends Record<string, unknown>>(row: T, keys: string[]) {
  const copy = { ...row };
  for (const key of keys) delete copy[key];
  return copy;
}

function restoreDates(row: Record<string, unknown>, fields: string[]) {
  const copy = { ...row };
  for (const field of fields) {
    if (typeof copy[field] === "string") copy[field] = new Date(copy[field] as string);
  }
  return copy;
}

async function restoreSnapshot(db: Prisma.TransactionClient, snapshot: ContentSnapshot) {
  const rows = snapshot.rows;

  for (const raw of rows.homeModules) {
    const row = raw as Record<string, unknown>;
    const data = restoreDates(without(row, ["id", "createdAt"]), ["updatedAt"]);
    await db.homeModule.upsert({
      where: { id: String(row.id) },
      update: data as Prisma.HomeModuleUncheckedUpdateInput,
      create: restoreDates(row, ["createdAt", "updatedAt"]) as Prisma.HomeModuleUncheckedCreateInput,
    });
  }
  for (const raw of rows.heroSlides) {
    const row = raw as Record<string, unknown>;
    const data = restoreDates(without(row, ["id", "createdAt"]), ["updatedAt"]);
    await db.heroSlide.upsert({
      where: { id: String(row.id) },
      update: data as Prisma.HeroSlideUncheckedUpdateInput,
      create: restoreDates(row, ["createdAt", "updatedAt"]) as Prisma.HeroSlideUncheckedCreateInput,
    });
  }
  for (const raw of rows.destinations) {
    const row = raw as Record<string, unknown>;
    const aliases = Array.isArray(row.aliases) ? row.aliases as Record<string, unknown>[] : [];
    const data = restoreDates(without(row, ["id", "createdAt", "aliases"]), ["updatedAt"]);
    await db.destination.upsert({
      where: { id: String(row.id) },
      update: data as Prisma.DestinationUncheckedUpdateInput,
      create: restoreDates(without(row, ["aliases"]), ["createdAt", "updatedAt"]) as Prisma.DestinationUncheckedCreateInput,
    });
    await db.destinationAlias.deleteMany({ where: { destinationId: String(row.id) } });
    if (aliases.length) {
      await db.destinationAlias.createMany({
        data: aliases.map((alias) => restoreDates(alias, ["createdAt", "updatedAt"]) as Prisma.DestinationAliasUncheckedCreateInput),
      });
    }
  }
  for (const raw of rows.themeCards) {
    const row = raw as Record<string, unknown>;
    const data = restoreDates(without(row, ["id", "createdAt"]), ["updatedAt"]);
    await db.themeCard.upsert({
      where: { id: String(row.id) },
      update: data as Prisma.ThemeCardUncheckedUpdateInput,
      create: restoreDates(row, ["createdAt", "updatedAt"]) as Prisma.ThemeCardUncheckedCreateInput,
    });
  }
  for (const raw of rows.ctaBanners) {
    const row = raw as Record<string, unknown>;
    const data = restoreDates(without(row, ["id", "createdAt"]), ["updatedAt"]);
    await db.ctaBanner.upsert({
      where: { id: String(row.id) },
      update: data as Prisma.CtaBannerUncheckedUpdateInput,
      create: restoreDates(row, ["createdAt", "updatedAt"]) as Prisma.CtaBannerUncheckedCreateInput,
    });
  }
  for (const raw of rows.products) {
    const row = raw as Record<string, unknown>;
    const images = Array.isArray(row.images) ? row.images as Record<string, unknown>[] : [];
    const data = restoreDates(without(row, ["id", "createdAt", "images"]), ["updatedAt", "publishedAt"]);
    await db.product.upsert({
      where: { id: String(row.id) },
      update: data as Prisma.ProductUncheckedUpdateInput,
      create: restoreDates(without(row, ["images"]), ["createdAt", "updatedAt", "publishedAt"]) as Prisma.ProductUncheckedCreateInput,
    });
    await db.productImage.deleteMany({ where: { productId: String(row.id) } });
    if (images.length) {
      await db.productImage.createMany({
        data: images.map((image) => restoreDates(image, ["createdAt", "updatedAt"]) as Prisma.ProductImageUncheckedCreateInput),
      });
    }
  }
  for (const raw of rows.campaigns) {
    const row = raw as Record<string, unknown>;
    const products = Array.isArray(row.products) ? row.products as Record<string, unknown>[] : [];
    const data = restoreDates(without(row, ["id", "createdAt", "products"]), ["updatedAt", "startsAt", "endsAt"]);
    await db.campaign.upsert({
      where: { id: String(row.id) },
      update: data as Prisma.CampaignUncheckedUpdateInput,
      create: restoreDates(without(row, ["products"]), ["createdAt", "updatedAt", "startsAt", "endsAt"]) as Prisma.CampaignUncheckedCreateInput,
    });
    await db.campaignProduct.deleteMany({ where: { campaignId: String(row.id) } });
    if (products.length) {
      await db.campaignProduct.createMany({
        data: products.map((product) => product as Prisma.CampaignProductUncheckedCreateInput),
      });
    }
  }

  if (rows.destinationPageConfig) {
    const row = rows.destinationPageConfig as Record<string, unknown>;
    await db.destinationPageConfig.upsert({
      where: { id: String(row.id) },
      update: restoreDates(without(row, ["id", "createdAt"]), ["updatedAt"]),
      create: restoreDates(row, ["createdAt", "updatedAt"]) as Prisma.DestinationPageConfigUncheckedCreateInput,
    });
  } else {
    await db.destinationPageConfig.deleteMany({ where: { id: DESTINATION_PAGE_CONFIG_ID } });
  }
  if (rows.searchPageConfig) {
    const row = rows.searchPageConfig as Record<string, unknown>;
    await db.searchPageConfig.upsert({
      where: { id: String(row.id) },
      update: restoreDates(without(row, ["id", "createdAt"]), ["updatedAt"]),
      create: restoreDates(row, ["createdAt", "updatedAt"]) as Prisma.SearchPageConfigUncheckedCreateInput,
    });
  } else {
    await db.searchPageConfig.deleteMany({ where: { id: SEARCH_PAGE_CONFIG_ID } });
  }

  for (const raw of rows.mediaAssets) {
    const row = raw as Record<string, unknown>;
    await db.mediaAsset.upsert({
      where: { id: String(row.id) },
      update: restoreDates(without(row, ["id", "createdAt"]), ["updatedAt"]),
      create: restoreDates(row, ["createdAt", "updatedAt"]) as Prisma.MediaAssetUncheckedCreateInput,
    });
  }
  if (rows.siteVersion) {
    const row = rows.siteVersion as Record<string, unknown>;
    await db.siteVersion.upsert({
      where: { id: String(row.id) },
      update: restoreDates(without(row, ["id", "createdAt"]), ["updatedAt", "publishedAt"]),
      create: restoreDates(row, ["createdAt", "publishedAt"]) as Prisma.SiteVersionUncheckedCreateInput,
    });
  } else {
    await db.siteVersion.deleteMany({ where: { id: stableUuid(snapshot.releaseKey) } });
  }
}

async function archiveNewRows(db: Prisma.TransactionClient, snapshot: ContentSnapshot, currentManifest: ReleaseManifest | null) {
  if (!currentManifest) return;
  const oldIds = {
    home: new Set(snapshot.rows.homeModules.map((row) => String((row as Record<string, unknown>).id))),
    hero: new Set(snapshot.rows.heroSlides.map((row) => String((row as Record<string, unknown>).id))),
    destination: new Set(snapshot.rows.destinations.map((row) => String((row as Record<string, unknown>).id))),
    theme: new Set(snapshot.rows.themeCards.map((row) => String((row as Record<string, unknown>).id))),
    cta: new Set(snapshot.rows.ctaBanners.map((row) => String((row as Record<string, unknown>).id))),
    product: new Set(snapshot.rows.products.map((row) => String((row as Record<string, unknown>).id))),
    campaign: new Set(snapshot.rows.campaigns.map((row) => String((row as Record<string, unknown>).id))),
  };
  for (const id of currentManifest.homeModuleIds.filter((item) => !oldIds.home.has(item))) {
    const row = await db.homeModule.findUnique({ where: { id } });
    await db.homeModule.update({
      where: { id },
      data: {
        isActive: false,
        isDeleted: true,
        publishedConfig: archivedPublishedConfig(row?.publishedConfig ?? null) ?? ({
          label: row?.label ?? "已归档模块",
          sortOrder: row?.sortOrder ?? 0,
          isActive: false,
          templateType: row?.templateType ?? "explore",
          content: { items: [] },
          isDeleted: true,
        } as Prisma.InputJsonValue),
      },
    });
  }
  for (const id of currentManifest.heroSlideIds.filter((item) => !oldIds.hero.has(item))) {
    await db.heroSlide.update({ where: { id }, data: { isActive: false } });
  }
  for (const id of currentManifest.destinationIds.filter((item) => !oldIds.destination.has(item))) {
    await db.destination.update({ where: { id }, data: { isActive: false } });
  }
  for (const id of currentManifest.themeCardIds.filter((item) => !oldIds.theme.has(item))) {
    await db.themeCard.update({ where: { id }, data: { isActive: false } });
  }
  for (const id of currentManifest.ctaBannerIds.filter((item) => !oldIds.cta.has(item))) {
    await db.ctaBanner.update({ where: { id }, data: { isActive: false } });
  }
  for (const id of currentManifest.productIds.filter((item) => !oldIds.product.has(item))) {
    await db.product.update({ where: { id }, data: { status: "archived" } });
  }
  for (const id of currentManifest.campaignIds.filter((item) => !oldIds.campaign.has(item))) {
    await db.campaign.update({ where: { id }, data: { status: "archived" } });
  }
}

async function rollbackContent(db: Prisma.TransactionClient, snapshot: ContentSnapshot) {
  const release = await db.siteVersion.findUnique({ where: { id: stableUuid(snapshot.releaseKey) } });
  if (!release) throw new Error(`找不到发布记录 ${snapshot.releaseKey}，为避免误回滚已停止`);
  const currentManifest = parseManifest(release?.snapshot);
  await archiveNewRows(db, snapshot, currentManifest);
  await restoreSnapshot(db, snapshot);
  if (currentManifest) {
    const snapshotMedia = new Set(snapshot.rows.mediaAssets.map((row) => String((row as Record<string, unknown>).url)));
    for (const url of currentManifest.mediaUrls.filter((item) => !snapshotMedia.has(item))) {
      await db.mediaAsset.deleteMany({ where: { url } });
    }
  }
}

function defaultBackupPath(releaseKey: string) {
  const stamp = new Date().toISOString().replace(/[-:]/g, "").replace(/\.\d{3}Z$/, "Z");
  return resolve(rootDir, "artifacts", `content-release-${releaseKey}-${stamp}.json`);
}

async function writeSnapshot(path: string, snapshot: ContentSnapshot) {
  await mkdir(dirname(path), { recursive: true });
  try {
    await access(path);
    throw new Error(`备份文件已存在，为避免覆盖请更换路径：${path}`);
  } catch (error) {
    if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
  }
  await writeFile(path, `${JSON.stringify(snapshot, null, 2)}\n`, { encoding: "utf8", mode: 0o600, flag: "wx" });
}

async function readSnapshot(path: string): Promise<ContentSnapshot> {
  const snapshot = JSON.parse(await readFile(path, "utf8")) as ContentSnapshot;
  if (snapshot.formatVersion !== SNAPSHOT_FORMAT_VERSION || !snapshot.releaseKey || !snapshot.rows) {
    throw new Error(`备份文件格式不受支持：${path}`);
  }
  return snapshot;
}

function planSummary(data: ReleaseData, current: ContentState, previous: ReleaseManifest | null) {
  const currentHome = new Set(current.homeModules.map((row) => row.id));
  const currentProducts = new Set(current.products.map((row) => row.sourceId).filter((id): id is number => id !== null));
  const currentDestinations = new Set(current.destinations.map((row) => row.slug));
  const currentCampaigns = new Set(current.campaigns.map((row) => row.slug));
  const baselineHome = new Set(data.homeModules.map((item) => item.id));
  const baselineDestinations = new Set(data.destinations.map((item) => destinationKey(item.label)));
  const baselineCampaigns = new Set(data.campaigns.map((item) => item.slug));
  const baselineProducts = new Set(data.products.map((item) => item.id));
  const count = (source: Set<string | number>, target: Set<string | number>) => ({
    create: [...target].filter((item) => !source.has(item)).length,
    update: [...target].filter((item) => source.has(item)).length,
    archive: [...source].filter((item) => !target.has(item)).length,
  });
  return {
    releaseKey: data.releaseKey,
    contentHash: data.contentHash,
    previousReleaseFound: Boolean(previous),
    baseline: {
      homeModules: data.homeModules.length,
      heroSlides: data.heroSlides.length,
      destinations: data.destinations.length,
      themeCards: data.themeCards.length,
      ctaBanners: data.ctaBanners.length,
      products: data.products.length,
      campaigns: data.campaigns.length,
      mediaAssets: data.mediaAssets.length,
    },
    ownedRows: {
      homeModules: current.homeModules.length,
      heroSlides: current.heroSlides.length,
      destinations: current.destinations.length,
      themeCards: current.themeCards.length,
      ctaBanners: current.ctaBanners.length,
      products: current.products.length,
      campaigns: current.campaigns.length,
      mediaAssets: current.mediaAssets.length,
    },
    changes: {
      homeModules: count(currentHome, baselineHome),
      destinations: count(currentDestinations, baselineDestinations),
      products: count(currentProducts, baselineProducts),
      campaigns: count(currentCampaigns, baselineCampaigns),
    },
    preserved: "生产中未被本发布包识别的内容和所有业务数据",
  };
}

function parseMode(argv: string[]) {
  const mode = argv.find((arg) => !arg.startsWith("--")) ?? "plan";
  if (mode !== "validate" && mode !== "plan" && mode !== "apply" && mode !== "rollback") throw new Error(`未知模式：${mode}，可选 validate、plan、apply、rollback`);
  const backupArg = argv.find((arg) => arg.startsWith("--backup-file="));
  return { mode, backupPath: backupArg ? resolve(rootDir, backupArg.slice("--backup-file=".length)) : undefined } as const;
}

async function main() {
  const { mode, backupPath: suppliedBackupPath } = parseMode(process.argv.slice(2));
  if (mode === "rollback" && !suppliedBackupPath) throw new Error("rollback 必须指定 --backup-file=...，避免误用错误快照");

  if (mode === "rollback") {
    const snapshot = await readSnapshot(suppliedBackupPath as string);
    await prisma.$transaction((tx) => rollbackContent(tx, snapshot), {
      maxWait: 10_000,
      timeout: 120_000,
      isolationLevel: Prisma.TransactionIsolationLevel.Serializable,
    });
    console.log(JSON.stringify({ mode, releaseKey: snapshot.releaseKey, backupFile: suppliedBackupPath, status: "rolled-back" }, null, 2));
    return;
  }

  const data = await loadReleaseData();
  if (mode === "validate") {
    console.log(JSON.stringify({
      mode,
      status: "valid",
      releaseKey: data.releaseKey,
      contentHash: data.contentHash,
      counts: {
        homeModules: data.homeModules.length,
        heroSlides: data.heroSlides.length,
        destinations: data.destinations.length,
        themeCards: data.themeCards.length,
        ctaBanners: data.ctaBanners.length,
        products: data.products.length,
        campaigns: data.campaigns.length,
        mediaAssets: data.mediaAssets.length,
      },
    }, null, 2));
    return;
  }
  const previousRow = await latestRelease(prisma);
  const previous = parseManifest(previousRow?.snapshot);
  const current = await readContentState(prisma, data, previous);
  if (mode === "plan") {
    console.log(JSON.stringify(planSummary(data, current, previous), null, 2));
    return;
  }

  const backupPath = suppliedBackupPath ?? defaultBackupPath(data.releaseKey);
  const result = await prisma.$transaction(async (tx) => {
    const txPreviousRow = await latestRelease(tx);
    const txPrevious = parseManifest(txPreviousRow?.snapshot);
    const before = await readContentState(tx, data, txPrevious);
    const snapshot: ContentSnapshot = {
      formatVersion: SNAPSHOT_FORMAT_VERSION,
      releaseKey: data.releaseKey,
      contentHash: data.contentHash,
      createdAt: new Date().toISOString(),
      rows: jsonClone({
        homeModules: before.homeModules,
        heroSlides: before.heroSlides,
        destinations: before.destinations,
        themeCards: before.themeCards,
        ctaBanners: before.ctaBanners,
        destinationPageConfig: before.destinationPageConfig,
        searchPageConfig: before.searchPageConfig,
        products: before.products,
        campaigns: before.campaigns,
        mediaAssets: before.mediaAssets,
        siteVersion: before.siteVersion,
      }),
    };
    await writeSnapshot(backupPath, snapshot);
    const applied = await applyContent(tx, data, txPrevious);
    return { ...applied, backupPath };
  }, {
    maxWait: 10_000,
    timeout: 120_000,
    isolationLevel: Prisma.TransactionIsolationLevel.Serializable,
  });

  console.log(JSON.stringify({
    mode,
    status: "applied",
    releaseKey: data.releaseKey,
    contentHash: data.contentHash,
    backupFile: result.backupPath,
    rollback: `npm run db:content:release -- rollback --backup-file=${result.backupPath}`,
    siteVersionId: result.siteVersionId,
  }, null, 2));
}

main()
  .catch((error) => {
    console.error(error);
    process.exitCode = 1;
  })
  .finally(async () => {
    await prisma.$disconnect();
  });