import { deflateSync, gunzipSync, inflateSync } from "node:zlib";
import type { SpriteImage } from "./image-decoder";

// ── Minimal PNG Encoder ────────────────────────────────────────────

const CRC_TABLE = (() => {
	const table = new Uint32Array(256);
	for (let n = 0; n < 256; n++) {
		let c = n;
		for (let k = 0; k < 8; k++) {
			c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
		}
		table[n] = c;
	}
	return table;
})();

function crc32(data: Buffer): number {
	let crc = 0xffffffff;
	for (let i = 0; i < data.length; i++) {
		crc = CRC_TABLE[(crc ^ data[i]) & 0xff] ^ (crc >>> 8);
	}
	return (crc ^ 0xffffffff) >>> 0;
}

function pngChunk(type: string, data: Buffer): Buffer {
	const buf = Buffer.alloc(4 + 4 + data.length + 4);
	buf.writeUInt32BE(data.length, 0);
	buf.write(type, 4, 4, "ascii");
	data.copy(buf, 8);
	const crc = crc32(buf.subarray(4, 8 + data.length));
	buf.writeUInt32BE(crc >>> 0, 8 + data.length);
	return buf;
}

export function encodePng(width: number, height: number, rgba: Buffer): Buffer {
	const rawData = Buffer.alloc(height * (1 + width * 4));
	for (let y = 0; y < height; y++) {
		const rowStart = y * (1 + width * 4);
		rawData[rowStart] = 0; // filter: None
		rgba.copy(rawData, rowStart + 1, y * width * 4, (y + 1) * width * 4);
	}

	const compressed = deflateSync(rawData);

	const chunks: Buffer[] = [];

	// Signature
	chunks.push(Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]));

	// IHDR
	const ihdr = Buffer.alloc(13);
	ihdr.writeUInt32BE(width, 0);
	ihdr.writeUInt32BE(height, 4);
	ihdr[8] = 8; // bit depth
	ihdr[9] = 6; // color type: RGBA
	ihdr[10] = 0; // compression
	ihdr[11] = 0; // filter
	ihdr[12] = 0; // interlace
	chunks.push(pngChunk("IHDR", ihdr));

	// IDAT
	chunks.push(pngChunk("IDAT", compressed));

	// IEND
	chunks.push(pngChunk("IEND", Buffer.alloc(0)));

	return Buffer.concat(chunks);
}

// ── Bin-Packing Spritesheet Builder ────────────────────────────────

interface PackedRect {
	x: number;
	y: number;
	w: number;
	h: number;
	name: string;
}

function nextPow2(v: number): number {
	v--;
	v |= v >> 1;
	v |= v >> 2;
	v |= v >> 4;
	v |= v >> 8;
	v |= v >> 16;
	return v + 1;
}

/**
 * Simple shelf-based bin packing algorithm.
 * Sorts sprites by height descending, then packs left-to-right in rows.
 * Produces much tighter spritesheets than simple vertical stacking.
 */
function binPack(images: SpriteImage[]): {
	rects: PackedRect[];
	width: number;
	height: number;
} {
	if (images.length === 0) {
		return { rects: [], width: 1, height: 1 };
	}

	// Sort by height descending for better shelf packing
	const sorted = [...images].sort(
		(a, b) => b.height - a.height || b.width - a.width,
	);

	// Estimate initial atlas width based on total area
	const totalArea = sorted.reduce(
		(sum, img) => sum + img.width * img.height,
		0,
	);
	const maxSingleWidth = Math.max(...sorted.map((i) => i.width));
	let atlasWidth = Math.max(maxSingleWidth, Math.ceil(Math.sqrt(totalArea)));

	// Round up to power of 2 for GPU friendliness (max 2048)
	atlasWidth = Math.min(2048, nextPow2(atlasWidth));

	const rects: PackedRect[] = [];
	let shelfY = 0;
	let shelfHeight = 0;
	let shelfX = 0;

	for (const img of sorted) {
		// If sprite doesn't fit on current shelf, start new shelf
		if (shelfX + img.width > atlasWidth) {
			shelfY += shelfHeight;
			shelfHeight = 0;
			shelfX = 0;
		}

		rects.push({
			x: shelfX,
			y: shelfY,
			w: img.width,
			h: img.height,
			name: img.name,
		});
		shelfX += img.width;
		shelfHeight = Math.max(shelfHeight, img.height);
	}

	const finalHeight = shelfY + shelfHeight;
	return { rects, width: atlasWidth, height: finalHeight || 1 };
}

// ── Spritesheet Builder ────────────────────────────────────────────

interface FrameInfo {
	x: number;
	y: number;
	w: number;
	h: number;
}

export function buildSpritesheet(images: SpriteImage[]): {
	png: Buffer;
	frames: Map<string, FrameInfo>;
	width: number;
	height: number;
} {
	if (images.length === 0) {
		const emptyPng = encodePng(1, 1, Buffer.alloc(4));
		return { png: emptyPng, frames: new Map(), width: 1, height: 1 };
	}

	const { rects, width: sheetWidth, height: sheetHeight } = binPack(images);

	// Build lookup by name for pixel data
	const imageByName = new Map(images.map((img) => [img.name, img]));

	const combined = Buffer.alloc(sheetWidth * sheetHeight * 4);
	const frames = new Map<string, FrameInfo>();

	for (const rect of rects) {
		const img = imageByName.get(rect.name);
		if (!img) continue;

		// Copy pixels row by row
		for (let y = 0; y < img.height; y++) {
			const srcStart = y * img.width * 4;
			const dstStart = ((rect.y + y) * sheetWidth + rect.x) * 4;
			img.pixels.copy(combined, dstStart, srcStart, srcStart + img.width * 4);
		}
		frames.set(rect.name, { x: rect.x, y: rect.y, w: rect.w, h: rect.h });
	}

	const png = encodePng(sheetWidth, sheetHeight, combined);
	return { png, frames, width: sheetWidth, height: sheetHeight };
}

// ── .nitro Bundle Creator ──────────────────────────────────────────

export function createNitroBundle(
	jsonData: object,
	pngData: Buffer,
	name: string,
): Buffer {
	const jsonStr = JSON.stringify(jsonData);
	const jsonCompressed = deflateSync(Buffer.from(jsonStr, "utf-8"));
	const pngCompressed = deflateSync(pngData);

	const jsonFileName = `${name}.json`;
	const pngFileName = `${name}.png`;

	const totalSize =
		2 +
		(2 + jsonFileName.length + 4 + jsonCompressed.length) +
		(2 + pngFileName.length + 4 + pngCompressed.length);

	const bundle = Buffer.alloc(totalSize);
	let offset = 0;

	bundle.writeInt16BE(2, offset);
	offset += 2;

	bundle.writeInt16BE(jsonFileName.length, offset);
	offset += 2;
	bundle.write(jsonFileName, offset, jsonFileName.length, "utf-8");
	offset += jsonFileName.length;
	bundle.writeInt32BE(jsonCompressed.length, offset);
	offset += 4;
	jsonCompressed.copy(bundle, offset);
	offset += jsonCompressed.length;

	bundle.writeInt16BE(pngFileName.length, offset);
	offset += 2;
	bundle.write(pngFileName, offset, pngFileName.length, "utf-8");
	offset += pngFileName.length;
	bundle.writeInt32BE(pngCompressed.length, offset);
	offset += 4;
	pngCompressed.copy(bundle, offset);

	return bundle;
}

// ── .nitro Bundle Parser ──────────────────────────────────────────

export function parseNitroBundle(buffer: Buffer): {
	json: Record<string, unknown>;
	jsonFileName: string;
	png: Buffer;
	pngFileName: string;
} {
	let offset = 0;

	const fileCount = buffer.readInt16BE(offset);
	offset += 2;
	if (fileCount < 2) {
		throw new Error(
			`Expected at least 2 files in .nitro bundle, got ${fileCount}`,
		);
	}

	// File 1: JSON
	const jsonFileNameLen = buffer.readInt16BE(offset);
	offset += 2;
	const jsonFileName = buffer.toString(
		"utf-8",
		offset,
		offset + jsonFileNameLen,
	);
	offset += jsonFileNameLen;
	const jsonCompressedLen = buffer.readInt32BE(offset);
	offset += 4;
	const jsonCompressed = buffer.subarray(offset, offset + jsonCompressedLen);
	offset += jsonCompressedLen;
	const jsonStr = inflateJsonOrGzip(jsonCompressed).toString("utf-8");
	const json = JSON.parse(jsonStr);

	// File 2: PNG
	const pngFileNameLen = buffer.readInt16BE(offset);
	offset += 2;
	const pngFileName = buffer.toString("utf-8", offset, offset + pngFileNameLen);
	offset += pngFileNameLen;
	const pngCompressedLen = buffer.readInt32BE(offset);
	offset += 4;
	const pngCompressed = buffer.subarray(offset, offset + pngCompressedLen);
	offset += pngCompressedLen;
	const png = inflateJsonOrGzip(pngCompressed);

	return { json, jsonFileName, png, pngFileName };
}

/**
 * Some bundled .nitro files (e.g. official /var/www/Gamedata furniture)
 * gzip their contents instead of raw-deflate. Try inflate first, then fall
 * back to gunzip so both formats parse.
 */
function inflateJsonOrGzip(input: Buffer): Buffer {
	try {
		return inflateSync(input);
	} catch {
		return gunzipSync(input);
	}
}