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,
	};
}