import { existsSync, promises as fs } from "node:fs";
import path from "node:path";
import { resolveFigureSwfUrl } from "@/lib/services/figure-source";
import { listFigureLibraries } from "@/lib/services/figuremap";
import { downloadFile } from "@/lib/services/import/core/download";
import { convertSwfToNitro } from "@/lib/services/swf-to-nitro";

export interface FigureListItem {
	lib: string;
	revision: number;
	nitroExists: boolean;
	// First part the library provides ({type,id}) — used to render an avatar
	// preview wearing it. Undefined if the library declares no parts.
	previewType?: string;
	previewId?: number;
}

export interface ImportFigureResult {
	ok: boolean;
	lib: string;
	warnings: string[];
	error?: string;
}

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

export async function ensureFigureDirs(): Promise<void> {
	await Promise.all(
		[FIGURE_NITRO_DIR, FIGURE_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*/ FIGURE_NITRO_DIR, `${lib}.nitro`);
}

export async function importSingleFigure(params: {
	lib: string;
	onProgress?: (status: string) => void;
}): Promise<ImportFigureResult> {
	const { lib, onProgress } = params;
	const warnings: string[] = [];
	await ensureFigureDirs();

	onProgress?.("downloading");
	const swfPath = path.join(
		/*turbopackIgnore: true*/ FIGURE_SWF_DIR,
		`${lib}.swf`,
	);
	let swfUrl: string;
	try {
		swfUrl = await resolveFigureSwfUrl(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}`,
		};

	onProgress?.("converting");
	try {
		const swfBuffer = await fs.readFile(/*turbopackIgnore: true*/ swfPath);
		const result = convertSwfToNitro(swfBuffer, lib);
		await fs.writeFile(
			/*turbopackIgnore: true*/ nitroPathFor(lib),
			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}`,
		};
	}

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

export async function deleteImportedFigure(
	lib: string,
): Promise<{ deletedFile: boolean }> {
	const p = nitroPathFor(lib);
	if (existsSync(/*turbopackIgnore: true*/ p)) {
		await fs.unlink(/*turbopackIgnore: true*/ p).catch(() => {});
		return { deletedFile: true };
	}
	return { deletedFile: false };
}

export async function getFigureList(params: {
	search: string;
	page: number;
	perPage: number;
}): Promise<{
	items: FigureListItem[];
	meta: { page: number; perPage: number; total: number };
}> {
	const { search, page, perPage } = params;
	const libs = await listFigureLibraries();
	const term = search.trim().toLowerCase();
	const filtered = term
		? libs.filter((l) => l.id.toLowerCase().includes(term))
		: libs;
	const total = filtered.length;
	const start = (Math.max(page, 1) - 1) * perPage;
	const items = filtered.slice(start, start + perPage).map((l) => ({
		lib: l.id,
		revision: l.revision,
		nitroExists: existsSync(/*turbopackIgnore: true*/ nitroPathFor(l.id)),
		previewType: l.parts?.[0]?.type,
		previewId: l.parts?.[0]?.id,
	}));
	return { items, meta: { page: Math.max(page, 1), perPage, total } };
}

export async function getFigureStats(): Promise<{
	total: number;
	imported: number;
	missing: number;
}> {
	const libs = await listFigureLibraries();
	const imported = libs.filter((l) =>
		existsSync(/*turbopackIgnore: true*/ nitroPathFor(l.id)),
	).length;
	return { total: libs.length, imported, missing: libs.length - imported };
}