import { existsSync, promises as fs } from "node:fs";
import path from "node:path";
import { withAdmin } from "@/lib/api-handler";
import { apiError, apiOk } from "@/lib/api-response";
import { PERMS } from "@/lib/permissions";
import { prisma } from "@/lib/prisma";
import { logAudit } from "@/lib/services/audit";
import { getFurniAssetDirs } from "@/lib/services/furni-asset-dirs";
import {
	autoPriceFurni,
	CATEGORY_PAGE,
	classifyFurni,
	cleanupConvertedSwfs,
	deleteImportedItem,
	downloadFile,
	ensureDirectories,
	IMPORTED_PAGE_CAPTION_SAVE,
	importSingleFurni,
} from "@/lib/services/furni-import";
import { getHabboItFurnidata } from "@/lib/services/habbo-furnidata-cache";
import { listFurniture } from "@/lib/services/habbofurni";
import { rcon } from "@/lib/services/rcon";
import { convertSwfToNitro } from "@/lib/services/swf-to-nitro";

// Re-export for batch route backward compatibility
export {
	ensureDirectories,
	importSingleFurni,
} from "@/lib/services/furni-import";
export type { ImportSingleResult } from "@/types/furni";

// ── Delete imported item or clean up SWF files ──────────────────────
export const DELETE = withAdmin(
	{ permission: PERMS.ASSETS_IMPORT },
	async (request, ctx) => {
		const classname = request.nextUrl.searchParams.get("classname");

		// ── Delete specific imported item ─────────────────────────────────
		if (classname) {
			try {
				const { spriteId, deletedFiles, errors } =
					await deleteImportedItem(classname);

				// Refresh game server caches
				try {
					await rcon.updateCatalog();
					await rcon.updateItems();
				} catch (err) {
					errors.push(`RCON: ${(err as Error).message}`);
				}

				logAudit({
					userId: ctx.session.user.id,
					action: "furni_delete",
					target: "ItemsBase",
					targetId: spriteId,
					after: {
						classname,
						deletedFiles,
						errors: errors.length > 0 ? errors : undefined,
					},
				});

				return apiOk({
					classname,
					deletedFiles,
					errors: errors.length > 0 ? errors : undefined,
				});
			} catch (err) {
				return apiError((err as Error).message, 404);
			}
		}

		// ── Clean up SWF files that have been converted to Nitro ──────────
		const result = await cleanupConvertedSwfs();

		if (result.total === 0 && result.deleted === 0) {
			return apiOk({ deleted: 0, message: "SWF directory does not exist" });
		}

		return apiOk({
			deleted: result.deleted,
			total: result.total,
			remaining: result.remaining,
			errors: result.errors.length > 0 ? result.errors : undefined,
		});
	},
);

// ── Search furni via official Habbo furnidata ───────────────────────
export const GET = withAdmin(
	{ permission: PERMS.ASSETS_IMPORT },
	async (request) => {
		const { nitroDir } = await getFurniAssetDirs();
		// Stats endpoint
		const action = request.nextUrl.searchParams.get("action");
		if (action === "stats") {
			const [totalResult, catalogResult, nitroMissingResult] =
				await Promise.all([
					prisma.$queryRaw<
						[{ cnt: bigint }]
					>`SELECT COUNT(*) as cnt FROM items_base`,
					prisma.$queryRaw<
						[{ cnt: bigint }]
					>`SELECT COUNT(DISTINCT item_ids) as cnt FROM catalog_items`,
					prisma.$queryRaw<
						[{ cnt: bigint }]
					>`SELECT COUNT(*) as cnt FROM items_base WHERE item_name NOT IN (SELECT catalog_name FROM catalog_items)`,
				]);

			const totalInDb = Number(totalResult[0].cnt);
			const inCatalog = Number(catalogResult[0].cnt);
			const notInCatalog = Number(nitroMissingResult[0].cnt);

			// Count missing .nitro files by checking filesystem
			const importedItems = await prisma.$queryRaw<
				Array<{ item_name: string }>
			>`
        SELECT ib.item_name FROM items_base ib
        INNER JOIN catalog_items ci ON ci.catalog_name = ib.item_name
        LIMIT 10000
      `;

			let missingNitro = 0;
			for (const item of importedItems) {
				const starIdx = item.item_name.indexOf("*");
				const base =
					starIdx !== -1
						? item.item_name.substring(0, starIdx)
						: item.item_name;
				const nitroPath = path.join(
					/*turbopackIgnore: true*/ nitroDir,
					`${base}.nitro`,
				);
				if (!existsSync(/*turbopackIgnore: true*/ nitroPath)) missingNitro++;
			}

			return apiOk({ totalInDb, inCatalog, notInCatalog, missingNitro });
		}

		// Missing nitro endpoint: returns only imported items missing .nitro files
		if (action === "missing-nitro") {
			const pageNum = parseInt(
				request.nextUrl.searchParams.get("page") || "1",
				10,
			);
			const perPage = 50;

			const importedItems = await prisma.$queryRaw<
				Array<{
					item_name: string;
					public_name: string;
					sprite_id: number;
					type: string;
				}>
			>`
        SELECT ib.item_name, ib.public_name, ib.sprite_id, ib.type FROM items_base ib
        INNER JOIN catalog_items ci ON ci.catalog_name = ib.item_name
      `;

			// Filter to only those missing .nitro on filesystem
			const missing = importedItems.filter((item) => {
				const starIdx = item.item_name.indexOf("*");
				const base =
					starIdx !== -1
						? item.item_name.substring(0, starIdx)
						: item.item_name;
				const p = path.join(
					/*turbopackIgnore: true*/ nitroDir,
					`${base}.nitro`,
				);
				return !existsSync(/*turbopackIgnore: true*/ p);
			});

			const total = missing.length;
			const lastPage = Math.max(Math.ceil(total / perPage), 1);
			const start = (pageNum - 1) * perPage;
			const pageItems = missing.slice(start, start + perPage);

			// Enrich with revision from official furnidata
			const furnidata = await getHabboItFurnidata();
			const items = pageItems.map((item) => {
				const fd =
					furnidata.get(item.item_name) ||
					furnidata.get(item.item_name.split("*")[0]) ||
					furnidata.get(`${item.item_name}*0`);
				return {
					id: item.sprite_id,
					classname: item.item_name,
					name: item.public_name || item.item_name,
					description: fd?.description || "",
					type: item.type === "i" ? "wallitem" : "flooritem",
					revision: fd?.revision || 0,
					category: fd?.category || fd?.furniline || "",
					alreadyImported: true,
					nitroExists: false,
				};
			});

			return apiOk({
				items,
				meta: { currentPage: pageNum, lastPage, total, perPage },
			});
		}

		const search = request.nextUrl.searchParams.get("search") || "";
		const page = parseInt(request.nextUrl.searchParams.get("page") || "1", 10);

		// Pull every imported classname once so we can both (a) sort non-imported
		// items to the top *before* pagination and (b) skip the per-page lookup
		// below. Single-column indexed query — fast even at 10k+ rows.
		const allImported = await prisma.itemsBase.findMany({
			select: { itemName: true },
		});
		const importedSet = new Set(
			allImported.map((e) => e.itemName).filter((n): n is string => !!n),
		);

		const result = await listFurniture({
			search: search || undefined,
			page,
			perPage: 50,
			importedSet,
		});

		const enriched = result.items.map((item) => {
			const imported = importedSet.has(item.classname);
			let nitroExists = false;
			if (imported) {
				const starIdx = item.classname.indexOf("*");
				const base =
					starIdx !== -1
						? item.classname.substring(0, starIdx)
						: item.classname;
				const p = path.join(
					/*turbopackIgnore: true*/ nitroDir,
					`${base}.nitro`,
				);
				nitroExists = existsSync(/*turbopackIgnore: true*/ p);
			}
			return { ...item, alreadyImported: imported, nitroExists };
		});

		return apiOk({ items: enriched, meta: result.meta });
	},
);

// ── Import furni (single or batch) ──────────────────────────────────
export const POST = withAdmin(
	{ permission: PERMS.ASSETS_IMPORT },
	async (request, ctx) => {
		const body = await request.json();

		await ensureDirectories();

		// ── Batch import ─────────────────────────────────────────────────
		if (Array.isArray(body.items)) {
			const results: Array<{
				classname: string;
				ok: boolean;
				itemId?: number;
				catalogItemId?: number | null;
				dimensions?: { x: number; y: number; z: number };
				spriteCount?: number;
				warnings: string[];
				error?: string;
			}> = [];

			for (const item of body.items) {
				if (!item.classname || !item.name) {
					results.push({
						classname: item.classname || "unknown",
						ok: false,
						warnings: [],
						error: "Missing classname or name",
					});
					continue;
				}

				try {
					const result = await importSingleFurni({
						id: item.id ?? 0,
						classname: item.classname,
						name: item.name,
						description: item.description ?? "",
						type: item.type ?? "flooritem",
						revision: item.revision ?? 0,
						category: item.category ?? "unknown",
					});

					results.push({ classname: item.classname, ...result });

					if (result.ok) {
						logAudit({
							userId: ctx.session.user.id,
							action: "furni_import",
							target: "ItemsBase",
							targetId: result.itemId!,
							after: {
								classname: item.classname,
								name: item.name,
								type: item.type === "wallitem" ? "i" : "s",
								catalogItemId: result.catalogItemId,
								dimensions: result.dimensions,
								batch: true,
								warnings:
									result.warnings.length > 0 ? result.warnings : undefined,
							},
						});
					}
				} catch (err) {
					results.push({
						classname: item.classname,
						ok: false,
						warnings: [],
						error: (err as Error).message,
					});
				}
			}

			// Refresh caches once after batch
			try {
				await rcon.updateCatalog();
				await rcon.updateItems();
			} catch (err) {
				console.warn(
					"[import-furni] RCON update failed after batch:",
					(err as Error).message,
				);
			}

			const succeeded = results.filter((r) => r.ok).length;
			const failed = results.filter((r) => !r.ok).length;

			return apiOk({ batch: true, succeeded, failed, results });
		}

		// ── Single import ────────────────────────────────────────────────
		const { id, classname, name, description, type, revision, category } = body;

		if (!classname || !name) return apiError("Missing classname or name", 400);

		const result = await importSingleFurni({
			id: id ?? 0,
			classname,
			name,
			description: description ?? "",
			type: type ?? "flooritem",
			revision: revision ?? 0,
			category: category ?? "unknown",
		});

		if (!result.ok) return apiError(result.error!, 409);

		// Refresh game server caches
		try {
			await rcon.updateCatalog();
			await rcon.updateItems();
		} catch (err) {
			console.warn(
				"[import-furni] RCON update failed:",
				(err as Error).message,
			);
			result.warnings.push("RCON cache refresh failed");
		}

		logAudit({
			userId: ctx.session.user.id,
			action: "furni_import",
			target: "ItemsBase",
			targetId: result.itemId!,
			after: {
				classname,
				name,
				spriteId: id ?? 0,
				type: type === "wallitem" ? "i" : "s",
				catalogItemId: result.catalogItemId,
				dimensions: result.dimensions,
				spriteCount: result.spriteCount,
				warnings: result.warnings.length > 0 ? result.warnings : undefined,
			},
		});

		return apiOk({
			id: result.itemId,
			catalogItemId: result.catalogItemId,
			dimensions: result.dimensions,
			spriteCount: result.spriteCount,
			warnings: result.warnings.length > 0 ? result.warnings : undefined,
		});
	},
);

// ── Re-generate missing .nitro files (PATCH) ─────────────────────────
export const PATCH = withAdmin(
	{ permission: PERMS.ASSETS_IMPORT },
	async (request) => {
		const body = await request.json();
		const items: Array<{ classname: string; revision: number }> =
			body.items || [];

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

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

		const results: Array<{ classname: string; ok: boolean; warning?: string }> =
			[];

		for (const item of items) {
			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`,
			);

			// Skip if .nitro already exists
			if (existsSync(/*turbopackIgnore: true*/ nitroPath)) {
				results.push({
					classname: item.classname,
					ok: true,
					warning: "Already exists",
				});
				continue;
			}

			// Resolve revision: try furnidata first, then spriteId as fallback
			let rev = item.revision || 0;
			if (rev === 0) {
				const furnidata = await getHabboItFurnidata();
				const fd =
					furnidata.get(item.classname) ||
					furnidata.get(baseClassname) ||
					furnidata.get(`${baseClassname}*0`);
				if (fd) rev = fd.revision;
			}

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

			// Download SWF if not present — try multiple revision candidates
			if (!existsSync(swfPath)) {
				// Build list of revisions to try: known rev, spriteId, common fallbacks
				const spriteId = await prisma.itemsBase.findFirst({
					where: { itemName: item.classname },
					select: { spriteId: true },
				});
				const revsToTry = [
					...new Set([rev, spriteId?.spriteId || 0].filter((r) => r > 0)),
				];

				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) {
					results.push({
						classname: item.classname,
						ok: false,
						warning: `SWF not found on Habbo CDN (tried revisions: ${revsToTry.join(", ") || "none"})`,
					});
					continue;
				}
			}

			// Convert SWF → Nitro + update FurnitureData.json
			try {
				const swfBuffer = await fs.readFile(swfPath);
				const conversion = convertSwfToNitro(swfBuffer, baseClassname);
				await fs.writeFile(nitroPath, conversion.bundle);

				// Add to FurnitureData.json if not already present
				try {
					const { buildFurniEntry, appendFurniEntry, readFurniData } =
						await import("@/lib/services/furni-data");
					const furniData = (await readFurniData()) as {
						roomitemtypes?: { furnitype?: Array<{ classname?: string }> };
						wallitemtypes?: { furnitype?: Array<{ classname?: string }> };
					};

					// Check if already in FurnitureData
					const allEntries = [
						...(furniData.roomitemtypes?.furnitype || []),
						...(furniData.wallitemtypes?.furnitype || []),
					];
					const alreadyInFD = allEntries.some(
						(e) =>
							e.classname === baseClassname || e.classname === item.classname,
					);

					if (!alreadyInFD) {
						const dbItem = await prisma.itemsBase.findFirst({
							where: { itemName: item.classname },
							select: {
								id: true,
								spriteId: true,
								publicName: true,
								type: true,
							},
						});
						const furnidata = await getHabboItFurnidata();
						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,
						});
						await appendFurniEntry(entry, itemType);
					}
				} catch (fdErr) {
					console.warn(
						`[regen] FurnitureData update skipped for ${item.classname}:`,
						(fdErr as Error).message,
					);
				}

				results.push({ classname: item.classname, ok: true });
			} catch (err) {
				results.push({
					classname: item.classname,
					ok: false,
					warning: (err as Error).message,
				});
			}
		}

		const succeeded = results.filter((r) => r.ok).length;
		const failed = results.filter((r) => !r.ok).length;

		return apiOk({ succeeded, failed, results });
	},
);

// ── Re-classify ALL imported items across all sub-pages + update prices (PUT) ──
// Supports ?dryrun=1 to preview changes without applying them.
export const PUT = withAdmin(
	{ permission: PERMS.ASSETS_IMPORT },
	async (request, ctx) => {
		const isDryRun = request.nextUrl.searchParams.get("dryrun") === "1";

		// 1. Find the root "imported_furni" page
		const parentPage = await prisma.catalogPages.findFirst({
			where: { captionSave: IMPORTED_PAGE_CAPTION_SAVE },
			select: { id: true },
		});
		if (!parentPage) {
			return apiOk({
				dryRun: isDryRun,
				moved: 0,
				repriced: 0,
				message: "No imported_furni page found — nothing to reorganize",
			});
		}

		// 2. Collect ALL imported page IDs (parent + every imp_* sub-page)
		const subPages = await prisma.catalogPages.findMany({
			where: { parentId: parentPage.id },
			select: { id: true, captionSave: true },
		});
		const allImportedPageIds = [
			String(parentPage.id),
			...subPages.map((p) => String(p.id)),
		];

		// 3. Find ALL catalog_items across all imported pages
		//    page_id is VARCHAR in DB so we use string placeholders
		const inPlaceholders = allImportedPageIds.map(() => "?").join(",");
		const allItems = await prisma.$queryRawUnsafe<
			Array<{
				id: number;
				item_ids: string;
				catalog_name: string;
				page_id: string;
				cost_credits: number;
			}>
		>(
			`SELECT id, item_ids, catalog_name, page_id, cost_credits FROM catalog_items WHERE page_id IN (${inPlaceholders})`,
			...allImportedPageIds,
		);

		if (allItems.length === 0) {
			return apiOk({
				dryRun: isDryRun,
				moved: 0,
				repriced: 0,
				message: "No imported items found — nothing to reorganize",
			});
		}

		// 4. Build classname → type map from items_base
		const uniqueItemIds = [
			...new Set(allItems.map((i) => Number(i.item_ids))),
		].filter((n) => !Number.isNaN(n));
		const dbItems =
			uniqueItemIds.length > 0
				? await prisma.itemsBase.findMany({
						where: { id: { in: uniqueItemIds } },
						select: { id: true, itemName: true, type: true },
					})
				: [];
		const typeMap = new Map<string, string>();
		for (const di of dbItems) {
			if (di.itemName) typeMap.set(di.itemName, di.type || "s");
		}

		// 5. Pre-load category page map (captionSave → pageId) to avoid N+1 queries
		const categoryPageMap = new Map<string, number>();
		for (const sp of subPages) {
			if (sp.captionSave) categoryPageMap.set(sp.captionSave, sp.id);
		}

		// Helper: resolve or create category page using the cached map
		async function resolvePageId(catKey: string): Promise<string> {
			const captionSave = `imp_${catKey}`;
			const cached = categoryPageMap.get(captionSave);
			if (cached !== undefined) return String(cached);

			if (isDryRun) return "new";

			// Create the page (only happens once per new category)
			const catInfo = CATEGORY_PAGE[catKey] || CATEGORY_PAGE.other;
			const parentId = parentPage?.id;
			await prisma.$executeRaw`
        INSERT INTO catalog_pages (caption_save, caption, page_layout, parent_id, min_rank, order_num, icon_image, enabled, visible, includes, page_headline, page_teaser, page_special, page_text1, page_text2, page_text_details, page_text_teaser)
        VALUES (${captionSave}, ${catInfo.label}, 'default_3x3', ${parentId}, '1', ${catInfo.order}, ${catInfo.icon}, '1', '1', '', '', '', '', '', '', '', '')
      `;
			const created = await prisma.catalogPages.findFirst({
				where: { captionSave, parentId },
				select: { id: true },
			});
			categoryPageMap.set(captionSave, created?.id);
			return String(created?.id);
		}

		// 6. Classify all items (pure computation + cached lookups, no per-item DB queries)
		let moved = 0;
		let repriced = 0;
		let skipped = 0;
		const errors: string[] = [];
		const categoryCounts: Record<string, number> = {};
		const pagesWithItems = new Set<string>();

		// Collect batched updates: key = "pageId|credits|points|pointsType" → item ids
		const updateBatches = new Map<string, number[]>();

		// First pass: resolve any new category pages (max ~14 DB inserts)
		const neededCategories = new Set<string>();
		for (const item of allItems) {
			const itemType = typeMap.get(item.catalog_name) || "s";
			neededCategories.add(classifyFurni(item.catalog_name, itemType));
		}
		for (const catKey of neededCategories) {
			try {
				await resolvePageId(catKey);
			} catch (err) {
				errors.push(`create page ${catKey}: ${(err as Error).message}`);
			}
		}

		// Second pass: classify items (no DB calls)
		for (const item of allItems) {
			const itemType = typeMap.get(item.catalog_name) || "s";
			const catKey = classifyFurni(item.catalog_name, itemType);
			categoryCounts[catKey] = (categoryCounts[catKey] || 0) + 1;

			const captionSave = `imp_${catKey}`;
			const cachedPageId = categoryPageMap.get(captionSave);
			const correctPageIdStr =
				cachedPageId !== undefined ? String(cachedPageId) : "new";

			const price = autoPriceFurni(item.catalog_name);
			const needsMove = item.page_id !== correctPageIdStr;
			const needsReprice = item.cost_credits !== price.credits;

			pagesWithItems.add(correctPageIdStr);

			if (!needsMove && !needsReprice) {
				skipped++;
				continue;
			}

			if (needsMove) moved++;
			if (needsReprice) repriced++;

			if (!isDryRun) {
				const batchKey = `${correctPageIdStr}|${price.credits}|${price.points}|${price.pointsType}`;
				const batch = updateBatches.get(batchKey);
				if (batch) {
					batch.push(item.id);
				} else {
					updateBatches.set(batchKey, [item.id]);
				}
			}
		}

		// 7. Apply batched updates (one UPDATE per category/price combo instead of per item)
		if (!isDryRun) {
			for (const [batchKey, ids] of updateBatches) {
				const [pageId, credits, points, pointsType] = batchKey.split("|");
				try {
					const idPlaceholders = ids.map(() => "?").join(",");
					await prisma.$queryRawUnsafe(
						`UPDATE catalog_items SET page_id = ?, cost_credits = ?, cost_points = ?, points_type = ? WHERE id IN (${idPlaceholders})`,
						pageId,
						Number(credits),
						Number(points),
						Number(pointsType),
						...ids,
					);
				} catch (err) {
					errors.push(`batch update: ${(err as Error).message}`);
				}
			}
		}

		// 8. Cleanup empty sub-pages (only if NOT dry-run)
		let pagesDeleted = 0;
		if (!isDryRun) {
			for (const subPage of subPages) {
				const subPageIdStr = String(subPage.id);
				if (!pagesWithItems.has(subPageIdStr)) {
					try {
						const remaining = await prisma.$queryRawUnsafe<
							Array<{ cnt: bigint }>
						>(
							`SELECT COUNT(*) as cnt FROM catalog_items WHERE page_id = ?`,
							subPageIdStr,
						);
						const count = Number(remaining[0]?.cnt ?? 0);
						if (count === 0) {
							await prisma.$executeRaw`DELETE FROM catalog_pages WHERE id = ${subPage.id}`;
							pagesDeleted++;
						}
					} catch (err) {
						errors.push(
							`cleanup ${subPage.captionSave}: ${(err as Error).message}`,
						);
					}
				}
			}
		}

		// 9. Refresh game server caches (only if NOT dry-run and changes were made)
		if (!isDryRun && (moved > 0 || repriced > 0 || pagesDeleted > 0)) {
			try {
				await rcon.updateCatalog();
			} catch (err) {
				errors.push(`RCON: ${(err as Error).message}`);
			}
		}

		if (!isDryRun) {
			logAudit({
				userId: ctx.session.user.id,
				action: "furni_reorganize",
				target: "CatalogItems",
				targetId: parentPage.id,
				after: {
					moved,
					repriced,
					skipped,
					pagesDeleted,
					categoryCounts,
					errors: errors.length > 0 ? errors : undefined,
				},
			});
		}

		return apiOk({
			dryRun: isDryRun,
			moved,
			repriced,
			skipped,
			pagesDeleted,
			total: allItems.length,
			categoryCounts,
			errors: errors.length > 0 ? errors : undefined,
		});
	},
);