import { resolveGordonBuildUrl } from "@/lib/services/import/core/gordon";
import { siteSettings } from "@/lib/services/site-settings";

export interface OfficialColor {
	id: number;
	index: number;
	club: number;
	selectable: boolean;
	hexCode: string;
}
export interface OfficialPalette {
	id: number;
	colors: OfficialColor[];
}
export interface OfficialPart {
	id: number;
	type: string;
	colorable: boolean;
	index: number;
	colorindex: number;
}
export interface OfficialSet {
	id: number;
	gender: string;
	club: number;
	colorable: boolean;
	selectable: boolean;
	preselectable: boolean;
	sellable: boolean;
	parts: OfficialPart[];
	hiddenLayers?: { partType: string }[];
}
export interface OfficialSetType {
	type: string;
	paletteId: number;
	mandM0: boolean;
	mandF0: boolean;
	mandM1: boolean;
	mandF1: boolean;
	sets: OfficialSet[];
}
export interface OfficialFigureData {
	palettes: OfficialPalette[];
	setTypes: OfficialSetType[];
}
export interface OfficialLibrary {
	id: string;
	revision: number;
	parts: { id: number; type: string }[];
}

const CACHE_TTL = 30 * 60 * 1000;
const DEFAULT_FIGUREDATA_URL = "https://www.habbo.com/gamedata/figuredata/1";
let fdCache: { data: OfficialFigureData; ts: number } | null = null;
let fmCache: { libs: OfficialLibrary[]; ts: number } | null = null;

export function __clearFigureOfficialCache(): void {
	fdCache = null;
	fmCache = null;
}

const attr = (tag: string, name: string): string | undefined =>
	new RegExp(`\\b${name}="([^"]*)"`).exec(tag)?.[1];
const bool = (v: string | undefined): boolean => v === "1" || v === "true";
const num = (v: string | undefined): number => {
	const n = Number(v);
	return Number.isFinite(n) ? n : 0;
};

export async function fetchOfficialFigureData(): Promise<OfficialFigureData> {
	const now = Date.now();
	if (fdCache && now - fdCache.ts < CACHE_TTL) return fdCache.data;
	const url = await siteSettings.get(
		"figuredata_source_url",
		DEFAULT_FIGUREDATA_URL,
	);
	const res = await fetch(url ?? DEFAULT_FIGUREDATA_URL, {
		signal: AbortSignal.timeout(30000),
	});
	if (!res.ok) throw new Error(`figuredata fetch failed: ${res.status}`);
	const xml = await res.text();

	const palettes: OfficialPalette[] = [];
	for (const pm of xml.matchAll(/<palette\b([^>]*)>([\s\S]*?)<\/palette>/g)) {
		const id = num(attr(pm[1], "id"));
		const colors: OfficialColor[] = [];
		for (const cm of pm[2].matchAll(/<color\b([^>]*)>([^<]*)<\/color>/g)) {
			colors.push({
				id: num(attr(cm[1], "id")),
				index: num(attr(cm[1], "index")),
				club: num(attr(cm[1], "club")),
				selectable: bool(attr(cm[1], "selectable")),
				hexCode: cm[2].trim(),
			});
		}
		palettes.push({ id, colors });
	}

	const setTypes: OfficialSetType[] = [];
	for (const sm of xml.matchAll(/<settype\b([^>]*)>([\s\S]*?)<\/settype>/g)) {
		const a = sm[1];
		const sets: OfficialSet[] = [];
		for (const setM of sm[2].matchAll(/<set\b([^>]*)>([\s\S]*?)<\/set>/g)) {
			const sa = setM[1];
			const parts: OfficialPart[] = [];
			for (const pm of setM[2].matchAll(/<part\b([^>]*)\/?>/g)) {
				parts.push({
					id: num(attr(pm[1], "id")),
					type: attr(pm[1], "type") ?? "",
					colorable: bool(attr(pm[1], "colorable")),
					index: num(attr(pm[1], "index")),
					colorindex: num(attr(pm[1], "colorindex")),
				});
			}
			const hiddenLayers: { partType: string }[] = [];
			for (const hm of setM[2].matchAll(/<layer\b([^>]*)\/?>/g)) {
				const pt = attr(hm[1], "parttype");
				if (pt) hiddenLayers.push({ partType: pt });
			}
			sets.push({
				id: num(attr(sa, "id")),
				gender: attr(sa, "gender") ?? "U",
				club: num(attr(sa, "club")),
				colorable: bool(attr(sa, "colorable")),
				selectable: bool(attr(sa, "selectable")),
				preselectable: bool(attr(sa, "preselectable")),
				sellable: bool(attr(sa, "sellable")),
				parts,
				hiddenLayers: hiddenLayers.length ? hiddenLayers : undefined,
			});
		}
		setTypes.push({
			type: attr(a, "type") ?? "",
			paletteId: num(attr(a, "paletteid")),
			mandM0: bool(attr(a, "mand_m_0")),
			mandF0: bool(attr(a, "mand_f_0")),
			mandM1: bool(attr(a, "mand_m_1")),
			mandF1: bool(attr(a, "mand_f_1")),
			sets,
		});
	}

	const data = { palettes, setTypes };
	fdCache = { data, ts: now };
	return data;
}

export async function fetchOfficialFigureMap(): Promise<OfficialLibrary[]> {
	const now = Date.now();
	if (fmCache && now - fmCache.ts < CACHE_TTL) return fmCache.libs;
	const override = (
		(await siteSettings.get("figure_swf_base_url", "")) ?? ""
	).trim();
	const base = override
		? `${override.replace(/\/+$/, "")}/`
		: await resolveGordonBuildUrl();
	const res = await fetch(`${base}figuremap.xml`, {
		signal: AbortSignal.timeout(30000),
	});
	if (!res.ok) throw new Error(`figuremap fetch failed: ${res.status}`);
	const xml = await res.text();
	const libs: OfficialLibrary[] = [];
	for (const lm of xml.matchAll(/<lib\b([^>]*)>([\s\S]*?)<\/lib>/g)) {
		const parts: { id: number; type: string }[] = [];
		for (const pm of lm[2].matchAll(/<part\b([^>]*)\/?>/g)) {
			parts.push({
				id: num(attr(pm[1], "id")),
				type: attr(pm[1], "type") ?? "",
			});
		}
		libs.push({
			id: attr(lm[1], "id") ?? "",
			revision: num(attr(lm[1], "revision")),
			parts,
		});
	}
	fmCache = { libs, ts: now };
	return libs;
}