import { inflateSync } from "node:zlib";
import * as jpeg from "jpeg-js";

export interface SpriteImage {
	id: number;
	name: string;
	width: number;
	height: number;
	pixels: Buffer; // RGBA
}

// ── DefineBitsLossless2 Parser (with alpha) ──────────────────────

export function parseBitsLossless2(data: Buffer): {
	id: number;
	width: number;
	height: number;
	pixels: Buffer;
} {
	let offset = 0;
	const id = data.readUInt16LE(offset);
	offset += 2;
	const format = data.readUInt8(offset);
	offset += 1;
	const width = data.readUInt16LE(offset);
	offset += 2;
	const height = data.readUInt16LE(offset);
	offset += 2;

	let colorTableSize = 0;
	if (format === 3) {
		colorTableSize = data.readUInt8(offset) + 1;
		offset += 1;
	}

	const compressed = data.subarray(offset);
	let decompressed: Buffer;
	try {
		decompressed = inflateSync(compressed);
	} catch {
		return { id, width, height, pixels: Buffer.alloc(width * height * 4) };
	}

	const pixels = Buffer.alloc(width * height * 4);

	if (format === 5) {
		let srcOff = 0;
		for (let y = 0; y < height; y++) {
			for (let x = 0; x < width; x++) {
				if (srcOff + 3 >= decompressed.length) break;
				const a = decompressed[srcOff];
				let r = decompressed[srcOff + 1];
				let g = decompressed[srcOff + 2];
				let b = decompressed[srcOff + 3];
				srcOff += 4;

				// Un-premultiply alpha
				if (a > 0 && a < 255) {
					r = Math.min(255, Math.round((r * 255) / a));
					g = Math.min(255, Math.round((g * 255) / a));
					b = Math.min(255, Math.round((b * 255) / a));
				}

				const dstOff = (y * width + x) * 4;
				pixels[dstOff] = r;
				pixels[dstOff + 1] = g;
				pixels[dstOff + 2] = b;
				pixels[dstOff + 3] = a;
			}
		}
	} else if (format === 3) {
		const palette: number[][] = [];
		let palOff = 0;
		for (let i = 0; i < colorTableSize; i++) {
			const a = decompressed[palOff];
			let r = decompressed[palOff + 1];
			let g = decompressed[palOff + 2];
			let b = decompressed[palOff + 3];
			// Un-premultiply alpha for palette entries (same as format 5)
			if (a > 0 && a < 255) {
				r = Math.min(255, Math.round((r * 255) / a));
				g = Math.min(255, Math.round((g * 255) / a));
				b = Math.min(255, Math.round((b * 255) / a));
			}
			palette.push([r, g, b, a]);
			palOff += 4;
		}

		const rowPadded = Math.ceil(width / 4) * 4;
		let srcOff = colorTableSize * 4;
		for (let y = 0; y < height; y++) {
			for (let x = 0; x < width; x++) {
				const idx = decompressed[srcOff + x];
				const color = palette[idx] || [0, 0, 0, 0];
				const dstOff = (y * width + x) * 4;
				pixels[dstOff] = color[0];
				pixels[dstOff + 1] = color[1];
				pixels[dstOff + 2] = color[2];
				pixels[dstOff + 3] = color[3];
			}
			srcOff += rowPadded;
		}
	}

	return { id, width, height, pixels };
}

// ── DefineBitsLossless Parser (without alpha) ──────────────────────

export function parseBitsLossless(data: Buffer): {
	id: number;
	width: number;
	height: number;
	pixels: Buffer;
} {
	let offset = 0;
	const id = data.readUInt16LE(offset);
	offset += 2;
	const format = data.readUInt8(offset);
	offset += 1;
	const width = data.readUInt16LE(offset);
	offset += 2;
	const height = data.readUInt16LE(offset);
	offset += 2;

	let colorTableSize = 0;
	if (format === 3) {
		colorTableSize = data.readUInt8(offset) + 1;
		offset += 1;
	}

	const compressed = data.subarray(offset);
	let decompressed: Buffer;
	try {
		decompressed = inflateSync(compressed);
	} catch {
		return { id, width, height, pixels: Buffer.alloc(width * height * 4) };
	}

	const pixels = Buffer.alloc(width * height * 4);

	if (format === 5) {
		let srcOff = 0;
		for (let y = 0; y < height; y++) {
			for (let x = 0; x < width; x++) {
				if (srcOff + 3 >= decompressed.length) break;
				srcOff++; // skip padding byte
				const r = decompressed[srcOff++];
				const g = decompressed[srcOff++];
				const b = decompressed[srcOff++];
				const dstOff = (y * width + x) * 4;
				pixels[dstOff] = r;
				pixels[dstOff + 1] = g;
				pixels[dstOff + 2] = b;
				pixels[dstOff + 3] = 255;
			}
		}
	} else if (format === 3) {
		const palette: number[][] = [];
		let palOff = 0;
		for (let i = 0; i < colorTableSize; i++) {
			const r = decompressed[palOff];
			const g = decompressed[palOff + 1];
			const b = decompressed[palOff + 2];
			palette.push([r, g, b, 255]);
			palOff += 3;
		}

		const rowPadded = Math.ceil(width / 4) * 4;
		let srcOff = colorTableSize * 3;
		for (let y = 0; y < height; y++) {
			for (let x = 0; x < width; x++) {
				const idx = decompressed[srcOff + x];
				const color = palette[idx] || [0, 0, 0, 255];
				const dstOff = (y * width + x) * 4;
				pixels[dstOff] = color[0];
				pixels[dstOff + 1] = color[1];
				pixels[dstOff + 2] = color[2];
				pixels[dstOff + 3] = color[3];
			}
			srcOff += rowPadded;
		}
	}

	return { id, width, height, pixels };
}

// ── DefineBitsJpeg2 Parser (JPEG without alpha) ───────────────────

export function parseBitsJpeg2(
	data: Buffer,
): { id: number; width: number; height: number; pixels: Buffer } | null {
	if (data.length < 6) return null;

	const id = data.readUInt16LE(0);
	let jpegData = data.subarray(2);

	// Strip erroneous JPEG header (FF D9 FF D1) if present
	if (
		jpegData.length >= 4 &&
		jpegData[0] === 0xff &&
		jpegData[1] === 0xd9 &&
		jpegData[2] === 0xff &&
		jpegData[3] === 0xd1
	) {
		jpegData = jpegData.subarray(4);
	}

	const dims = parseJpegDimensions(jpegData);
	if (!dims) return null;

	const pixels = decodeJpegToRGBA(jpegData, dims.width, dims.height);
	return { id, width: dims.width, height: dims.height, pixels };
}

// ── DefineBitsJpeg3 Parser (JPEG with alpha channel) ──────────────

export function parseBitsJpeg3(
	data: Buffer,
): { id: number; width: number; height: number; pixels: Buffer } | null {
	if (data.length < 6) return null;

	const id = data.readUInt16LE(0);
	const alphaDataOffset = data.readUInt32LE(2);
	let jpegData = data.subarray(6, 6 + alphaDataOffset);

	// Strip erroneous JPEG header (FF D9 FF D1) if present
	if (
		jpegData.length >= 4 &&
		jpegData[0] === 0xff &&
		jpegData[1] === 0xd9 &&
		jpegData[2] === 0xff &&
		jpegData[3] === 0xd1
	) {
		jpegData = jpegData.subarray(4);
	}

	const dims = parseJpegDimensions(jpegData);
	if (!dims) return null;

	const pixels = decodeJpegToRGBA(jpegData, dims.width, dims.height);

	// Apply zlib-compressed alpha channel
	const compressedAlpha = data.subarray(6 + alphaDataOffset);
	if (compressedAlpha.length > 0) {
		try {
			const alpha = inflateSync(compressedAlpha);
			const pixelCount = dims.width * dims.height;
			for (let i = 0; i < pixelCount && i < alpha.length; i++) {
				pixels[i * 4 + 3] = alpha[i];
			}
		} catch {
			// Alpha decompression failed, keep fully opaque
		}
	}

	return { id, width: dims.width, height: dims.height, pixels };
}

// ── JPEG Dimension Parser (reads SOF0/SOF2 markers) ───────────────

export function parseJpegDimensions(
	jpeg: Buffer,
): { width: number; height: number } | null {
	let offset = 0;
	while (offset < jpeg.length - 1) {
		if (jpeg[offset] !== 0xff) {
			offset++;
			continue;
		}

		const marker = jpeg[offset + 1];
		offset += 2;

		// SOF0 (Baseline), SOF1 (Extended), SOF2 (Progressive)
		if (marker >= 0xc0 && marker <= 0xc2) {
			if (offset + 7 > jpeg.length) return null;
			// Skip length (2 bytes) + precision (1 byte)
			const height = jpeg.readUInt16BE(offset + 3);
			const width = jpeg.readUInt16BE(offset + 5);
			return { width, height };
		}

		// Skip non-SOF markers with length field
		if (marker === 0xd8 || marker === 0xd9) continue; // SOI / EOI
		if (marker >= 0xd0 && marker <= 0xd7) continue; // RST markers
		if (offset + 2 > jpeg.length) break;
		const segLen = jpeg.readUInt16BE(offset);
		offset += segLen;
	}
	return null;
}

// ── JPEG to RGBA decoder using jpeg-js ──────────────────────────────

export function decodeJpegToRGBA(
	jpegData: Buffer,
	width: number,
	height: number,
): Buffer {
	try {
		const decoded = jpeg.decode(jpegData, {
			useTArray: true,
			formatAsRGBA: true,
		});
		// jpeg-js returns RGBA data directly
		return Buffer.from(
			decoded.data.buffer,
			decoded.data.byteOffset,
			decoded.data.byteLength,
		);
	} catch {
		// Fallback: transparent pixels if JPEG decode fails
		return Buffer.alloc(width * height * 4);
	}
}