EpicNext-Cms/src/lib/services/effect-import.ts

import { existsSync, promises as fs } from "node:fs";
import path from "node:path";
import { listOfficialEffects, resolveEffectSwfUrl } from "@/lib/services/effect-source";
import { listLocalEffects, mergeEffect, removeEffect } from "@/lib/services/effectmap";
import { downloadFile } from "@/lib/services/import/core/download";
import { convertSwfToNitro } from "@/lib/services/swf-to-nitro";
import type { EffectListItem, EffectMapEntry, ImportEffectResult } from "@/types/effects";

export const EFFECT_NITRO_DIR = path.join(
  /*turbopackIgnore: true*/ process.cwd(),
  "public/nitro-assets/bundled/effect",
);
export const EFFECT_SWF_DIR = path.join(/*turbopackIgnore: true*/ process.cwd(), "public/swf/gordon");

export async function ensureEffectDirs(): Promise<void> {
  await Promise.all(
    [EFFECT_NITRO_DIR, EFFECT_SWF_DIR]
      .filter((dir) => !existsSync(/*turbopackIgnore: true*/ dir))
      .map((dir) => fs.mkdir(/*turbopackIgnore: true*/ dir, { recursive: true })),
  );
}

function nitroPathFor(lib: string): string {
  return path.join(/*turbopackIgnore: true*/ EFFECT_NITRO_DIR, `${lib}.nitro`);
}

export async function importSingleEffect(params: {
  id: string;
  lib: string;
  type: string;
  revision: number;
  onProgress?: (status: string) => void;
}): Promise<ImportEffectResult> {
  const { id, lib, type, revision, onProgress } = params;
  const warnings: string[] = [];
  await ensureEffectDirs();

  const nitroPath = nitroPathFor(lib);

  // Download SWF
  onProgress?.("downloading");
  const swfPath = path.join(/*turbopackIgnore: true*/ EFFECT_SWF_DIR, `${lib}.swf`);
  let swfUrl: string;
  try {
    swfUrl = await resolveEffectSwfUrl(lib);
  } catch (err) {
    return {
      ok: false,
      lib,
      warnings,
      error: `Could not resolve SWF URL: ${(err as Error).message}`,
    };
  }
  const dl = await downloadFile(swfUrl, swfPath, { validate: "swf" });
  if (!dl.ok) return { ok: false, lib, warnings, error: `SWF download failed: ${swfUrl}` };

  // Convert SWF → Nitro
  onProgress?.("converting");
  try {
    const swfBuffer = await fs.readFile(/*turbopackIgnore: true*/ swfPath);
    const result = convertSwfToNitro(swfBuffer, lib);
    await fs.writeFile(/*turbopackIgnore: true*/ nitroPath, result.bundle);
    if (result.warnings?.length) warnings.push(...result.warnings);
  } catch (err) {
    return {
      ok: false,
      lib,
      warnings,
      error: `SWF→Nitro conversion failed: ${(err as Error).message}`,
    };
  }

  // Merge EffectMap.json (last step — no orphan entry if anything above failed)
  onProgress?.("writing_map");
  try {
    const entry: EffectMapEntry = { id, lib, type, revision };
    await mergeEffect(entry);
  } catch (err) {
    warnings.push(`EffectMap.json merge failed: ${(err as Error).message}`);
    return { ok: false, lib, warnings, error: "EffectMap.json merge failed" };
  }

  return { ok: true, lib, warnings };
}

export async function deleteImportedEffect(
  idOrLib: string,
): Promise<{ removed: boolean; deletedFile: boolean }> {
  const local = await listLocalEffects();
  const entry = local.find((e) => e.id === idOrLib || e.lib === idOrLib);
  const removed = await removeEffect(idOrLib);
  let deletedFile = false;
  if (entry) {
    const p = nitroPathFor(entry.lib);
    if (existsSync(/*turbopackIgnore: true*/ p)) {
      await fs.unlink(/*turbopackIgnore: true*/ p).catch(() => {});
      deletedFile = true;
    }
  }
  return { removed, deletedFile };
}

export async function getEffectList(search: string): Promise<EffectListItem[]> {
  const [official, local] = await Promise.all([listOfficialEffects(), listLocalEffects()]);
  const localByLib = new Map(local.map((e) => [e.lib, e]));
  const term = search.trim().toLowerCase();
  const merged = official.map((e) => {
    const present = localByLib.has(e.lib);
    return {
      ...e,
      present,
      nitroExists: existsSync(/*turbopackIgnore: true*/ nitroPathFor(e.lib)),
    };
  });
  return term
    ? merged.filter(
        (e) =>
          e.lib.toLowerCase().includes(term) || e.id.toLowerCase().includes(term) || e.type.includes(term),
      )
    : merged;
}

export async function getEffectStats(): Promise<{
  official: number;
  imported: number;
  missing: number;
}> {
  const [official, local] = await Promise.all([listOfficialEffects(), listLocalEffects()]);
  const localLibs = new Set(local.map((e) => e.lib));
  const imported = official.filter((e) => localLibs.has(e.lib)).length;
  return { official: official.length, imported, missing: official.length - imported };
}