import { existsSync, promises as fs } from "node:fs";
import path from "node:path";
import { downloadFile } from "@/lib/services/import/core/download";
import { CANONICAL_PETS, resolvePetSwfUrl } from "@/lib/services/pet-source";
import { convertSwfToNitro } from "@/lib/services/swf-to-nitro";

export interface PetListItem {
	lib: string;
	nitroExists: boolean;
}

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

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

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

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

	onProgress?.("downloading");
	const swfPath = path.join(
		/*turbopackIgnore: true*/ PET_SWF_DIR,
		`${lib}.swf`,
	);
	let swfUrl: string;
	try {
		swfUrl = await resolvePetSwfUrl(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 deleteImportedPet(
	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 function getPetList(search: string): PetListItem[] {
	const term = search.trim().toLowerCase();
	const list = CANONICAL_PETS.map((lib) => ({
		lib,
		nitroExists: existsSync(/*turbopackIgnore: true*/ nitroPathFor(lib)),
	}));
	return term ? list.filter((p) => p.lib.toLowerCase().includes(term)) : list;
}

export function getPetStats(): {
	total: number;
	imported: number;
	missing: number;
} {
	const imported = CANONICAL_PETS.filter((lib) =>
		existsSync(/*turbopackIgnore: true*/ nitroPathFor(lib)),
	).length;
	return {
		total: CANONICAL_PETS.length,
		imported,
		missing: CANONICAL_PETS.length - imported,
	};
}