import { existsSync, promises as fs } from "node:fs";
import path from "node:path";
import { withAdmin } from "@/lib/api-handler";
import { apiError } from "@/lib/api-response";
import { PERMS } from "@/lib/permissions";
import { prisma } from "@/lib/prisma";
import { getFurniAssetDirs } from "@/lib/services/furni-asset-dirs";
import { appendFurniEntriesBatch, buildFurniEntry, readFurniData } from "@/lib/services/furni-data";
import { downloadFile, ensureDirectories } from "@/lib/services/furni-import";
import { getHabboItFurnidata } from "@/lib/services/habbo-furnidata-cache";
import { rcon } from "@/lib/services/rcon";
import { convertSwfToNitro } from "@/lib/services/swf-to-nitro";

interface RegenItem {
  classname: string;
  revision: number;
}

/**
 * SSE batch regenerate .nitro files.
 * Streams progress events for each item.
 */
export const POST = withAdmin({ permission: PERMS.ASSETS_IMPORT }, async (request) => {
  const body = await request.json();
  const items: RegenItem[] = body.items || [];
  const concurrency = Math.min(Math.max(body.concurrency || 3, 1), 5);

  if (items.length === 0) return apiError("No items to regenerate", 400);

  await ensureDirectories();
  const { swfDir, nitroDir } = await getFurniAssetDirs();
  const encoder = new TextEncoder();

  const stream = new ReadableStream({
    async start(controller) {
      const send = (data: unknown) => {
        try {
          controller.enqueue(encoder.encode(`data: ${JSON.stringify(data)}\n\n`));
        } catch {
          /* stream closed */
        }
      };

      const startTime = Date.now();
      send({ type: "regen_start", total: items.length });

      let succeeded = 0;
      let failed = 0;
      let skipped = 0;
      const furniDataEntries: Array<{ entry: Record<string, unknown>; itemType: string }> = [];

      // Load furnidata once for all items
      const furnidata = await getHabboItFurnidata();

      // Load existing FurnitureData.json classnames for dedup
      const existingFD = (await readFurniData()) as {
        roomitemtypes?: { furnitype?: Array<{ classname?: string }> };
        wallitemtypes?: { furnitype?: Array<{ classname?: string }> };
      };
      const fdClassnames = new Set([
        ...(existingFD.roomitemtypes?.furnitype || []).map((e) => e.classname),
        ...(existingFD.wallitemtypes?.furnitype || []).map((e) => e.classname),
      ]);

      for (let i = 0; i < items.length; i += concurrency) {
        const chunk = items.slice(i, i + concurrency);

        const promises = chunk.map(async (item) => {
          const starIdx = item.classname.indexOf("*");
          const baseClassname = starIdx !== -1 ? item.classname.substring(0, starIdx) : item.classname;
          const nitroPath = path.join(/*turbopackIgnore: true*/ nitroDir, `${baseClassname}.nitro`);

          if (existsSync(/*turbopackIgnore: true*/ nitroPath)) {
            skipped++;
            send({ type: "regen_progress", classname: item.classname, status: "skipped" });
            return;
          }

          send({ type: "regen_progress", classname: item.classname, status: "downloading" });

          // Resolve revision
          let rev = item.revision || 0;
          if (rev === 0) {
            const fd =
              furnidata.get(item.classname) ||
              furnidata.get(baseClassname) ||
              furnidata.get(`${baseClassname}*0`);
            if (fd) rev = fd.revision;
          }

          // Try spriteId as fallback revision
          const revsToTry: number[] = [];
          if (rev > 0) revsToTry.push(rev);
          const dbItem = await prisma.itemsBase.findFirst({
            where: { itemName: item.classname },
            select: { id: true, spriteId: true, publicName: true, type: true },
          });
          if (dbItem?.spriteId && !revsToTry.includes(dbItem.spriteId)) {
            revsToTry.push(dbItem.spriteId);
          }

          if (revsToTry.length === 0) {
            failed++;
            send({
              type: "regen_progress",
              classname: item.classname,
              status: "failed",
              message: "No revision found",
            });
            return;
          }

          const swfPath = path.join(swfDir, `${baseClassname}.swf`);

          // Download SWF if needed
          if (!existsSync(swfPath)) {
            let downloaded = false;
            for (const tryRev of revsToTry) {
              const dl = await downloadFile(
                `https://images.habbo.com/dcr/hof_furni/${tryRev}/${encodeURIComponent(baseClassname)}.swf`,
                swfPath,
                { validate: "swf" },
              );
              if (dl.ok) {
                rev = tryRev;
                downloaded = true;
                break;
              }
            }
            if (!downloaded) {
              failed++;
              send({
                type: "regen_progress",
                classname: item.classname,
                status: "failed",
                message: `SWF not found (revs: ${revsToTry.join(", ")})`,
              });
              return;
            }
          }

          // Convert
          send({ type: "regen_progress", classname: item.classname, status: "converting" });
          try {
            const swfBuffer = await fs.readFile(swfPath);
            const conversion = convertSwfToNitro(swfBuffer, baseClassname);
            await fs.writeFile(nitroPath, conversion.bundle);

            // Build FurnitureData entry if missing
            if (!fdClassnames.has(baseClassname) && !fdClassnames.has(item.classname)) {
              const fd = furnidata.get(item.classname) || furnidata.get(baseClassname);
              const itemType = dbItem?.type === "i" ? "i" : "s";
              const entry = buildFurniEntry({
                id: dbItem?.spriteId || 0,
                classname: baseClassname,
                revision: rev,
                category: fd?.category || "",
                name: dbItem?.publicName || baseClassname,
                description: fd?.description || "",
                spriteId: dbItem?.spriteId || 0,
                dims: conversion.dimensions || { x: 1, y: 1, z: 1 },
                metadata: conversion.metadata || null,
                habboIt: fd || null,
              });
              furniDataEntries.push({ entry, itemType });
              fdClassnames.add(baseClassname);
            }

            succeeded++;
            send({ type: "regen_progress", classname: item.classname, status: "done" });
          } catch (err) {
            failed++;
            send({
              type: "regen_progress",
              classname: item.classname,
              status: "failed",
              message: (err as Error).message,
            });
          }
        });

        await Promise.allSettled(promises);
      }

      // Batch write FurnitureData.json
      if (furniDataEntries.length > 0) {
        try {
          await appendFurniEntriesBatch(furniDataEntries);
          send({
            type: "regen_info",
            message: `Added ${furniDataEntries.length} entries to FurnitureData.json`,
          });
        } catch (err) {
          send({
            type: "regen_info",
            message: `FurnitureData.json write failed: ${(err as Error).message}`,
          });
        }
      }

      // RCON refresh
      try {
        await rcon.updateItems();
        await rcon.updateCatalog();
      } catch {
        /* non-fatal */
      }

      send({
        type: "regen_complete",
        succeeded,
        failed,
        skipped,
        furniDataAdded: furniDataEntries.length,
        duration: Date.now() - startTime,
      });

      controller.close();
    },
  });

  return new Response(stream, {
    headers: {
      "Content-Type": "text/event-stream",
      "Cache-Control": "no-cache",
      Connection: "keep-alive",
    },
  });
});