import "server-only";

import { and, asc, eq, inArray, sql } from "drizzle-orm";

import { getDb } from "@/db";
import {
  artifactGroups,
  artifactProfiles,
  artifactRecommendations,
  catalogArtifacts,
  catalogCharacters,
  catalogWeapons,
  constellationConditions,
  constellationRecommendations,
  extraSectionRows,
  extraSections,
  guides,
  guidePosterBleeding,
  guideSections,
  media,
  outboxEvents,
  teamCompositions,
  teamConditions,
  teamMembers,
  weaponRecommendations,
  weaponConditions,
} from "@/db/schema";
import {
  artifactSectionSchema,
  constellationSectionSchema,
  createExtraSectionSchema,
  createGuideSchema,
  extraSectionSchema,
  reorderExtraSectionsSchema,
  saveExtraSectionSchema,
  slugFromCharacterName,
  teamSectionSchema,
  updateGuideSchema,
  weaponSectionSchema,
} from "@/lib/guides/schemas";
import { processCatalogSync } from "@/lib/catalog/sync";
import { normalizeExtraRichText } from "@/lib/rich-text";

const DEFAULT_SECTIONS = [
  { kind: "weapon", slug: "weapon", title: "Weapons", sortOrder: 0 },
  { kind: "artifact", slug: "artifact", title: "Artifacts & Stats", sortOrder: 1 },
  { kind: "constellations", slug: "constellations", title: "Constellations", sortOrder: 2 },
  { kind: "team", slug: "team", title: "Team Calc", sortOrder: 3 },
] as const;

export class GuideVersionConflictError extends Error {
  constructor(readonly currentVersion: number) {
    super("ข้อมูลถูกแก้ไขจากแท็บอื่น กด Save now เพื่อบันทึก Local draft ทับเวอร์ชันล่าสุด");
    this.name = "GuideVersionConflictError";
  }
}

async function emitGuideEvents(tx: Parameters<Parameters<ReturnType<typeof getDb>["transaction"]>[0]>[0], guideId: string, version: number, directoryChanged = false) {
  await tx.insert(outboxEvents).values([
    ...(directoryChanged
      ? [{ topic: "directory", aggregateId: guideId, eventType: "directory.updated", payload: { id: guideId, version } }]
      : []),
    { topic: `page:${guideId}`, aggregateId: guideId, eventType: "page.updated", payload: { id: guideId, version } },
    { topic: "admin", aggregateId: guideId, eventType: "admin.updated", payload: { id: guideId, version } },
  ]);
}

export async function createGuide(input: unknown) {
  const parsed = createGuideSchema.parse(input);
  const db = getDb();
  const [character] = await db.select().from(catalogCharacters).where(eq(catalogCharacters.key, parsed.characterKey)).limit(1);
  if (!character) throw new Error("ไม่พบตัวละครใน Catalog");
  const [cover] = await db.select().from(media).where(and(eq(media.id, parsed.coverMediaId), eq(media.status, "ready"))).limit(1);
  if (!cover) throw new Error("กรุณาอัปโหลดภาพ Guide ให้สำเร็จ");
  const baseSlug = slugFromCharacterName(character.name, character.key);
  const [slugCollision] = await db.select({ id: guides.id }).from(guides).where(eq(guides.slug, baseSlug)).limit(1);
  const slug = slugCollision ? `${baseSlug}-${character.key.toLowerCase()}` : baseSlug;

  return db.transaction(async (tx) => {
    const [guide] = await tx.insert(guides).values({
      characterKey: character.key,
      slug,
      name: character.name,
      overview: parsed.overview,
      coverMediaId: parsed.coverMediaId,
    }).returning();
    await tx.insert(guideSections).values(DEFAULT_SECTIONS.map((section) => ({ ...section, guideId: guide.id })));
    await tx.insert(artifactGroups).values([
      { guideId: guide.id, name: "Late Game", sortOrder: 0 },
      { guideId: guide.id, name: "Early Game", sortOrder: 1 },
    ]);
    await tx.insert(artifactProfiles).values({ guideId: guide.id });
    await tx.update(media).set({ currentReferenceCount: sql`${media.currentReferenceCount} + 1` }).where(eq(media.id, parsed.coverMediaId));
    await emitGuideEvents(tx, guide.id, guide.version, true);
    return guide;
  });
}

async function advanceGuideVersion(tx: Parameters<Parameters<ReturnType<typeof getDb>["transaction"]>[0]>[0], guideId: string, expectedVersion: number, directoryChanged = false) {
  const [guide] = await tx.update(guides).set({ version: expectedVersion + 1 }).where(and(eq(guides.id, guideId), eq(guides.version, expectedVersion), sql`${guides.trashedAt} is null`)).returning();
  if (!guide) {
    const [current] = await tx.select({ version: guides.version }).from(guides).where(eq(guides.id, guideId)).limit(1);
    if (current) throw new GuideVersionConflictError(current.version);
    throw new Error("ไม่พบ Guide");
  }
  await emitGuideEvents(tx, guide.id, guide.version, directoryChanged);
  return guide;
}

export async function saveWeapons(guideId: string, input: unknown) {
  const data = weaponSectionSchema.parse(input);
  const [guide] = await getDb().select().from(guides).where(eq(guides.id, guideId)).limit(1);
  if (!guide) throw new Error("ไม่พบ Guide");
  return getDb().transaction(async (tx) => {
    const updated = await advanceGuideVersion(tx, guideId, data.expectedVersion);
    await tx.update(guideSections).set({ note: data.note }).where(and(eq(guideSections.guideId, guideId), eq(guideSections.slug, "weapon")));
    await tx.delete(weaponConditions).where(eq(weaponConditions.guideId, guideId));
    for (const [sortOrder, group] of data.groups.entries()) {
      const [created] = await tx.insert(weaponConditions).values({ guideId, note: group.note, sortOrder }).returning();
      if (group.rows.length) await tx.insert(weaponRecommendations).values(group.rows.map((row, rowOrder) => ({ ...row, refinement: row.refinement, overallPercent: row.overallPercent?.toString() ?? null, personalPercent: row.personalPercent?.toString() ?? null, conditionId: created.id, sortOrder: rowOrder })));
    }
    return updated;
  });
}

export async function updateGuideBasics(guideId: string, input: unknown) {
  const data = updateGuideSchema.parse(input);
  const [current] = await getDb().select().from(guides).where(eq(guides.id, guideId)).limit(1);
  if (!current) throw new Error("ไม่พบ Guide");
  const [cover] = await getDb().select().from(media).where(and(eq(media.id, data.coverMediaId), eq(media.status, "ready"))).limit(1);
  if (!cover) throw new Error("ไม่พบภาพ Guide ที่อัปโหลดแล้ว");
  return getDb().transaction(async (tx) => {
    const posterArtMediaId = data.posterArtMediaId === undefined
      ? current.posterArtMediaId
      : data.posterArtMediaId;
    if (posterArtMediaId) {
      const [poster] = await tx
        .select({ id: media.id })
        .from(media)
        .where(and(eq(media.id, posterArtMediaId), eq(media.status, "ready")))
        .limit(1);
      if (!poster) throw new Error("ไม่พบภาพตัวละครที่อัปโหลดแล้ว");
    }
    if (data.posterBleeding !== undefined) {
      const bleedingMediaIds = [...new Set(data.posterBleeding.map((layer) => layer.mediaId))];
      const bleedingMedia = bleedingMediaIds.length
        ? await tx.select({ id: media.id }).from(media).where(and(inArray(media.id, bleedingMediaIds), eq(media.status, "ready")))
        : [];
      if (bleedingMedia.length !== bleedingMediaIds.length) throw new Error("ไม่พบภาพ Bleeding ที่อัปโหลดแล้ว");
    }
    const updated = await advanceGuideVersion(tx, guideId, data.expectedVersion, true);
    await tx.update(guides).set({
      overview: data.overview,
      coverMediaId: data.coverMediaId,
      youtubeUrls: data.youtubeUrls,
      ...(data.posterArtMediaId !== undefined ? { posterArtMediaId } : {}),
      ...(data.posterArtOffsetX !== undefined ? { posterArtOffsetX: Math.round(data.posterArtOffsetX) } : {}),
      ...(data.posterArtOffsetY !== undefined ? { posterArtOffsetY: Math.round(data.posterArtOffsetY) } : {}),
      ...(data.posterArtScale !== undefined ? { posterArtScale: Math.round(data.posterArtScale) } : {}),
      ...(data.posterTopColors !== undefined ? { posterTopColors: data.posterTopColors } : {}),
      ...(data.posterBottomColors !== undefined ? { posterBottomColors: data.posterBottomColors } : {}),
    }).where(eq(guides.id, guideId));
    if (data.posterBleeding !== undefined) {
      const previous = await tx.select({ mediaId: guidePosterBleeding.mediaId }).from(guidePosterBleeding).where(eq(guidePosterBleeding.guideId, guideId));
      for (const layer of previous) {
        await tx.update(media).set({ currentReferenceCount: sql`greatest(${media.currentReferenceCount} - 1, 0)` }).where(eq(media.id, layer.mediaId));
      }
      await tx.delete(guidePosterBleeding).where(eq(guidePosterBleeding.guideId, guideId));
      if (data.posterBleeding.length) {
        await tx.insert(guidePosterBleeding).values(data.posterBleeding.map((layer, sortOrder) => ({
          guideId,
          mediaId: layer.mediaId,
          amount: Math.round(layer.amount),
          scale: Math.round(layer.scale),
          blendMode: layer.blendMode,
          sortOrder,
        })));
        for (const layer of data.posterBleeding) {
          await tx.update(media).set({ currentReferenceCount: sql`${media.currentReferenceCount} + 1` }).where(eq(media.id, layer.mediaId));
        }
      }
    }
    if (current.coverMediaId !== data.coverMediaId) {
      await tx.update(media).set({ currentReferenceCount: sql`greatest(${media.currentReferenceCount} - 1, 0)` }).where(eq(media.id, current.coverMediaId));
      await tx.update(media).set({ currentReferenceCount: sql`${media.currentReferenceCount} + 1` }).where(eq(media.id, data.coverMediaId));
    }
    if (current.posterArtMediaId !== posterArtMediaId) {
      if (current.posterArtMediaId) {
        await tx.update(media).set({ currentReferenceCount: sql`greatest(${media.currentReferenceCount} - 1, 0)` }).where(eq(media.id, current.posterArtMediaId));
      }
      if (posterArtMediaId) {
        await tx.update(media).set({ currentReferenceCount: sql`${media.currentReferenceCount} + 1` }).where(eq(media.id, posterArtMediaId));
      }
    }
    return updated;
  });
}

export async function saveArtifacts(guideId: string, input: unknown) {
  const data = artifactSectionSchema.parse(input);
  const [guide] = await getDb().select().from(guides).where(eq(guides.id, guideId)).limit(1);
  if (!guide) throw new Error("ไม่พบ Guide");
  return getDb().transaction(async (tx) => {
    const updated = await advanceGuideVersion(tx, guideId, data.expectedVersion);
    await tx.delete(artifactGroups).where(eq(artifactGroups.guideId, guideId));
    for (const [sortOrder, group] of data.groups.entries()) {
      const [created] = await tx.insert(artifactGroups).values({ guideId, name: group.name, sortOrder }).returning();
      if (group.rows.length) await tx.insert(artifactRecommendations).values(group.rows.map((row, rowOrder) => ({ ...row, percent: row.percent.toString(), groupId: created.id, sortOrder: rowOrder })));
    }
    await tx.insert(artifactProfiles).values({ guideId, sands: data.sands, goblet: data.goblet, circlet: data.circlet, substats: data.substats, targets: data.targetGroups[0]?.rows ?? [], targetConditions: data.targetGroups, talents: data.talents, note: data.note }).onConflictDoUpdate({ target: artifactProfiles.guideId, set: { sands: data.sands, goblet: data.goblet, circlet: data.circlet, substats: data.substats, targets: data.targetGroups[0]?.rows ?? [], targetConditions: data.targetGroups, talents: data.talents, note: data.note } });
    return updated;
  });
}

export async function saveConstellations(guideId: string, input: unknown) {
  const data = constellationSectionSchema.parse(input);
  return getDb().transaction(async (tx) => {
    const updated = await advanceGuideVersion(tx, guideId, data.expectedVersion);
    await tx.update(guideSections).set({ note: data.note }).where(and(eq(guideSections.guideId, guideId), eq(guideSections.slug, "constellations")));
    await tx.delete(constellationConditions).where(eq(constellationConditions.guideId, guideId));
    for (const [sortOrder, group] of data.groups.entries()) {
      const [created] = await tx.insert(constellationConditions).values({ guideId, note: group.note, sortOrder }).returning();
      if (group.rows.length) await tx.insert(constellationRecommendations).values(group.rows.map((row) => ({ ...row, cumulativePercent: row.cumulativePercent.toString(), conditionId: created.id })));
    }
    return updated;
  });
}

export async function saveTeams(guideId: string, input: unknown) {
  const data = teamSectionSchema.parse(input);
  const [guide] = await getDb().select().from(guides).where(eq(guides.id, guideId)).limit(1);
  if (!guide) throw new Error("ไม่พบ Guide");
  const members = data.groups.flatMap((group) => group.teams.flatMap((team) => team.members));
  const characterKeys = [...new Set(members.map((member) => member.characterKey))];
  const weaponKeys = [...new Set(members.map((member) => member.weaponKey).filter((key): key is string => Boolean(key)))];
  const artifactKeys = [...new Set(members.flatMap((member) => [member.artifactKey, member.secondArtifactKey]).filter((key): key is string => Boolean(key)))];
  const [characters, weapons, artifacts] = await Promise.all([
    characterKeys.length ? getDb().select().from(catalogCharacters).where(inArray(catalogCharacters.key, characterKeys)) : [],
    weaponKeys.length ? getDb().select().from(catalogWeapons).where(inArray(catalogWeapons.key, weaponKeys)) : [],
    artifactKeys.length ? getDb().select().from(catalogArtifacts).where(inArray(catalogArtifacts.key, artifactKeys)) : [],
  ]);
  if (characters.length !== characterKeys.length) throw new Error("ไม่พบตัวละครบางรายการใน Catalog");
  if (weapons.length !== weaponKeys.length) throw new Error("ไม่พบอาวุธบางรายการใน Catalog");
  if (artifacts.length !== artifactKeys.length) throw new Error("ไม่พบ Artifact บางรายการใน Catalog");
  for (const member of members) {
    const character = characters.find((item) => item.key === member.characterKey);
    const weapon = weapons.find((item) => item.key === member.weaponKey);
    if (weapon && weapon.weaponType !== character?.weaponType) {
      throw new Error(`${weapon.name} ไม่รองรับ ${character?.name ?? "ตัวละครนี้"}`);
    }
  }
  return getDb().transaction(async (tx) => {
    const updated = await advanceGuideVersion(tx, guideId, data.expectedVersion);
    await tx.delete(teamConditions).where(eq(teamConditions.guideId, guideId));
    for (const [groupOrder, group] of data.groups.entries()) {
      const [condition] = await tx.insert(teamConditions).values({ guideId, note: group.note, sortOrder: groupOrder }).returning();
      for (const [sortOrder, team] of group.teams.entries()) {
        const [created] = await tx.insert(teamCompositions).values({ guideId, conditionId: condition.id, title: team.title, rotationSeconds: team.rotationSeconds.toString(), combo: team.combo, sortOrder }).returning();
        await tx.insert(teamMembers).values(team.members.map((member, position) => ({ ...member, teamId: created.id, position, damage: member.damage.toString() })));
      }
    }
    return updated;
  });
}

export async function saveExtraSections(guideId: string, input: unknown) {
  const data = extraSectionSchema.parse(input);
  return getDb().transaction(async (tx) => {
    const updated = await advanceGuideVersion(tx, guideId, data.expectedVersion);
    await tx.delete(guideSections).where(and(eq(guideSections.guideId, guideId), eq(guideSections.kind, "extra")));
    for (const [sortOrder, section] of data.sections.entries()) {
      const [createdSection] = await tx.insert(guideSections).values({ guideId, kind: "extra", slug: `extra-${sortOrder + 1}`, title: section.title, enabled: true, sortOrder: 4 + sortOrder }).returning();
      await tx.insert(extraSections).values({ sectionId: createdSection.id });
      if (section.rows.length) await tx.insert(extraSectionRows).values(section.rows.map((row, rowOrder) => ({
        ...row,
        body: normalizeExtraRichText(row.body, row.highlights),
        highlights: [],
        percent: row.percent?.toString() ?? null,
        sectionId: createdSection.id,
        sortOrder: rowOrder,
      })));
    }
    return updated;
  });
}

export async function createExtraSection(guideId: string, input: unknown) {
  const data = createExtraSectionSchema.parse(input);
  return getDb().transaction(async (tx) => {
    const existing = await tx
      .select({ slug: guideSections.slug, sortOrder: guideSections.sortOrder })
      .from(guideSections)
      .where(and(eq(guideSections.guideId, guideId), eq(guideSections.kind, "extra")))
      .orderBy(asc(guideSections.sortOrder));
    if (existing.length >= 20) throw new Error("Guide มี Extra sections ได้สูงสุด 20 ส่วน");

    const [updated] = await tx
      .update(guides)
      .set({ version: sql`${guides.version} + 1` })
      .where(and(eq(guides.id, guideId), sql`${guides.trashedAt} is null`))
      .returning();
    if (!updated) throw new Error("ไม่พบ Guide");

    const suffix = existing.reduce((highest, section) => {
      const match = /^extra-(\d+)$/u.exec(section.slug);
      return match ? Math.max(highest, Number(match[1])) : highest;
    }, 0) + 1;
    const sortOrder = Math.max(3, ...existing.map((section) => section.sortOrder)) + 1;
    const [section] = await tx
      .insert(guideSections)
      .values({
        guideId,
        kind: "extra",
        slug: `extra-${suffix}`,
        title: data.title,
        enabled: true,
        sortOrder,
      })
      .returning();
    await tx.insert(extraSections).values({ sectionId: section.id });
    await emitGuideEvents(tx, guideId, updated.version);
    return { ...section, version: updated.version };
  });
}

export async function saveExtraSection(
  guideId: string,
  sectionId: string,
  input: unknown,
) {
  const data = saveExtraSectionSchema.parse(input);
  return getDb().transaction(async (tx) => {
    const [target] = await tx
      .select({ id: guideSections.id })
      .from(guideSections)
      .where(and(
        eq(guideSections.id, sectionId),
        eq(guideSections.guideId, guideId),
        eq(guideSections.kind, "extra"),
      ))
      .limit(1);
    if (!target) throw new Error("ไม่พบ Extra section");

    const updated = await advanceGuideVersion(tx, guideId, data.expectedVersion);
    await tx
      .update(guideSections)
      .set({ title: data.section.title })
      .where(eq(guideSections.id, sectionId));
    await tx.delete(extraSectionRows).where(eq(extraSectionRows.sectionId, sectionId));
    if (data.section.rows.length) {
      await tx.insert(extraSectionRows).values(data.section.rows.map((row, sortOrder) => ({
        ...row,
        body: normalizeExtraRichText(row.body, row.highlights),
        highlights: [],
        percent: row.percent?.toString() ?? null,
        sectionId,
        sortOrder,
      })));
    }
    return updated;
  });
}

export async function deleteExtraSection(guideId: string, sectionId: string) {
  return getDb().transaction(async (tx) => {
    const [target] = await tx
      .select({ id: guideSections.id })
      .from(guideSections)
      .where(and(
        eq(guideSections.id, sectionId),
        eq(guideSections.guideId, guideId),
        eq(guideSections.kind, "extra"),
      ))
      .limit(1);
    if (!target) throw new Error("ไม่พบ Extra section");

    const [updated] = await tx
      .update(guides)
      .set({ version: sql`${guides.version} + 1` })
      .where(and(eq(guides.id, guideId), sql`${guides.trashedAt} is null`))
      .returning();
    if (!updated) throw new Error("ไม่พบ Guide");
    await tx.delete(guideSections).where(eq(guideSections.id, sectionId));
    await emitGuideEvents(tx, guideId, updated.version);
    return updated;
  });
}

export async function reorderExtraSections(guideId: string, input: unknown) {
  const data = reorderExtraSectionsSchema.parse(input);
  return getDb().transaction(async (tx) => {
    const existing = await tx
      .select({ id: guideSections.id })
      .from(guideSections)
      .where(and(eq(guideSections.guideId, guideId), eq(guideSections.kind, "extra")));
    const existingIds = new Set(existing.map((section) => section.id));
    if (
      existingIds.size !== data.sectionIds.length ||
      data.sectionIds.some((sectionId) => !existingIds.has(sectionId))
    ) {
      throw new Error("รายการ Extra sections ไม่ตรงกับข้อมูลล่าสุด");
    }

    const updated = await advanceGuideVersion(tx, guideId, data.expectedVersion);
    for (const [index, sectionId] of data.sectionIds.entries()) {
      await tx
        .update(guideSections)
        .set({ sortOrder: 4 + index })
        .where(eq(guideSections.id, sectionId));
    }
    return updated;
  });
}

export async function trashGuide(guideId: string) {
  return getDb().transaction(async (tx) => {
    const [guide] = await tx.update(guides).set({ trashedAt: new Date(), version: sql`${guides.version} + 1` }).where(eq(guides.id, guideId)).returning();
    if (!guide) throw new Error("ไม่พบ Guide");
    await emitGuideEvents(tx, guide.id, guide.version, true);
    return guide;
  });
}

export async function restoreGuide(guideId: string) {
  return getDb().transaction(async (tx) => {
    const [guide] = await tx.update(guides).set({ trashedAt: null, version: sql`${guides.version} + 1` }).where(eq(guides.id, guideId)).returning();
    if (!guide) throw new Error("ไม่พบ Guide");
    await emitGuideEvents(tx, guide.id, guide.version, true);
    return guide;
  });
}

export async function setGuideVisibility(guideId: string, isPublic: boolean) {
  return getDb().transaction(async (tx) => {
    const [guide] = await tx
      .update(guides)
      .set({ isPublic, version: sql`${guides.version} + 1` })
      .where(and(eq(guides.id, guideId), sql`${guides.trashedAt} is null`))
      .returning();
    if (!guide) throw new Error("ไม่พบ Guide");
    await emitGuideEvents(tx, guide.id, guide.version, true);
    return guide;
  });
}

export async function permanentlyDeleteGuide(guideId: string) {
  return getDb().transaction(async (tx) => {
    const [guide] = await tx.select().from(guides).where(eq(guides.id, guideId)).limit(1);
    if (!guide?.trashedAt) throw new Error("Guide ต้องอยู่ในถังขยะก่อนลบถาวร");
    const bleeding = await tx.select({ mediaId: guidePosterBleeding.mediaId }).from(guidePosterBleeding).where(eq(guidePosterBleeding.guideId, guideId));
    await tx.delete(guides).where(eq(guides.id, guideId));
    await tx.update(media).set({ currentReferenceCount: sql`greatest(${media.currentReferenceCount} - 1, 0)` }).where(eq(media.id, guide.coverMediaId));
    if (guide.posterArtMediaId) {
      await tx.update(media).set({ currentReferenceCount: sql`greatest(${media.currentReferenceCount} - 1, 0)` }).where(eq(media.id, guide.posterArtMediaId));
    }
    for (const layer of bleeding) {
      await tx.update(media).set({ currentReferenceCount: sql`greatest(${media.currentReferenceCount} - 1, 0)` }).where(eq(media.id, layer.mediaId));
    }
    await emitGuideEvents(tx, guide.id, guide.version + 1, true);
    return { version: guide.version + 1 };
  });
}

export async function runCatalogSync() {
  await processCatalogSync();
  return { status: "saved" as const };
}