import assert from "node:assert/strict";
import { mkdtemp, rm, writeFile } from "node:fs/promises";
import os from "node:os";
import path from "node:path";
import { test } from "node:test";
import { Worker } from "node:worker_threads";
import { createCanvas } from "@napi-rs/canvas";
import * as photon from "@silvia-odwyer/photon-node";
import {
	detectSupportedImageMimeType,
	detectSupportedImageMimeTypeFromFile,
	processImage,
} from "../src/agent/image-processing/index.ts";
import { applyExifOrientation } from "../src/agent/image-processing/exif-orientation.mjs";
import { resizeImageInProcess } from "../src/agent/image-processing/resize-core.mjs";
import { resizeImage } from "../src/agent/image-processing/resize.ts";

// Synthetic, offline fixtures only. Canvas generates inputs; Photon is the
// actual processing implementation and supplies independent encoding oracles.
function png(width = 96, height = 96, noise = false): Buffer {
	const canvas = createCanvas(width, height);
	const context = canvas.getContext("2d");
	if (noise) {
		const pixels = context.createImageData(width, height);
		let state = 0x12345678;
		for (let i = 0; i < pixels.data.length; i += 4) {
			for (let channel = 0; channel < 3; channel++) {
				state = (Math.imul(state, 1664525) + 1013904223) >>> 0;
				pixels.data[i + channel] = state >>> 24;
			}
			pixels.data[i + 3] = 255;
		}
		context.putImageData(pixels, 0, 0);
	} else {
		context.fillStyle = "#33aadd";
		context.fillRect(0, 0, width, height);
	}
	return canvas.toBuffer("image/png");
}

function encodings(bytes: Uint8Array, width: number, height: number, qualities = [80, 85, 70, 55, 40]) {
	const image = photon.PhotonImage.new_from_byteslice(bytes);
	const resized = photon.resize(image, width, height, photon.SamplingFilter.Lanczos3);
	try {
		return [
			{ mimeType: "image/png", data: Buffer.from(resized.get_bytes()).toString("base64") },
			...qualities.map((quality) => ({ mimeType: "image/jpeg", data: Buffer.from(resized.get_bytes_jpeg(quality)).toString("base64") })),
		];
	} finally {
		resized.free();
		image.free();
	}
}

function bmp(): Buffer {
	// A 2x1, uncompressed, 24-bit Windows BMP (padded scanline).
	const bytes = Buffer.alloc(62);
	bytes.write("BM");
	bytes.writeUInt32LE(bytes.length, 2);
	bytes.writeUInt32LE(54, 10);
	bytes.writeUInt32LE(40, 14);
	bytes.writeInt32LE(2, 18);
	bytes.writeInt32LE(1, 22);
	bytes.writeUInt16LE(1, 26);
	bytes.writeUInt16LE(24, 28);
	bytes.writeUInt32LE(8, 34);
	bytes.set([0, 0, 255, 0, 255, 0], 54);
	return bytes;
}

function exifJpeg(orientation: number): Buffer {
	const image = photon.PhotonImage.new_from_byteslice(png(12, 8));
	let jpeg: Buffer;
	try {
		jpeg = Buffer.from(image.get_bytes_jpeg(80));
	} finally {
		image.free();
	}
	const exif = Buffer.alloc(36);
	exif.set([0xff, 0xe1, 0, 34]);
	exif.write("Exif\0\0", 4, "binary");
	exif.write("II", 10);
	exif.writeUInt16LE(42, 12);
	exif.writeUInt32LE(8, 14);
	exif.writeUInt16LE(1, 18);
	exif.writeUInt16LE(0x0112, 20);
	exif.writeUInt16LE(3, 22);
	exif.writeUInt32LE(1, 24);
	exif.writeUInt16LE(orientation, 28);
	return Buffer.concat([jpeg.subarray(0, 2), exif, jpeg.subarray(2)]);
}

test("already-fit image bytes are unchanged, MIME aliases normalize, and transfer leaves input intact", async () => {
	const bytes = png();
	const original = Buffer.from(bytes);
	const result = await processImage(bytes, " Image/PNG; charset=binary ");
	assert.deepEqual(result, { ok: true, data: bytes.toString("base64"), mimeType: "image/png", hints: [] });
	assert.deepEqual(bytes, original);
	const jpeg = exifJpeg(1);
	assert.deepEqual(await processImage(jpeg, "image/jpg"), { ok: true, data: jpeg.toString("base64"), mimeType: "image/jpeg", hints: [] });
});

test("native default dimensions are 2000x2000 and dimension hints use the native mapping", async () => {
	const bytes = png(12000, 24);
	const result = await processImage(bytes, "image/png");
	assert.ok(result.ok);
	assert.equal(result.mimeType, "image/png");
	assert.deepEqual(result.hints, ["[Image: original 12000x24, displayed at 2000x4. Multiply coordinates by 6.00 to map to original image.]"]);
	const decoded = photon.PhotonImage.new_from_byteslice(Buffer.from(result.data, "base64"));
	try {
		assert.equal(decoded.get_width(), 2000);
		assert.equal(decoded.get_height(), 4);
	} finally { decoded.free(); }
	const tall = await resizeImage(png(24, 12000), "image/png");
	assert.ok(tall);
	assert.equal(tall.width, 4);
	assert.equal(tall.height, 2000);
});

test("model dimensions use sequential rounding, not a one-step scale", async () => {
	const result = await resizeImage(png(301, 503), "image/png", { maxWidth: 101, maxHeight: 100 });
	assert.ok(result);
	// 301x503 -> 101x169 -> 60x100.
	assert.equal(result.width, 60);
	assert.equal(result.height, 100);
	assert.equal(result.data, encodings(png(301, 503), 60, 100)[0]!.data);
	const rounding = await resizeImage(png(50, 77), "image/png", { maxWidth: 10, maxHeight: 10 });
	assert.ok(rounding);
	assert.equal(rounding.width, 7); // round(100 / round(77 * 10 / 50)); one-step gives 6.
	assert.equal(rounding.height, 10);
});

test("native cap is strict and measures base64 bytes, not binary bytes", async () => {
	const source = png(24, 24);
	// A valid PNG with ignored trailing bytes: under 4.5 MiB binary, exactly
	// 4.5 MiB base64. At equality the unchanged fast path must NOT run.
	const padded = Buffer.alloc((4.5 * 1024 * 1024 / 4) * 3);
	source.copy(padded);
	assert.ok(padded.length < 4.5 * 1024 * 1024);
	assert.equal(padded.toString("base64").length, 4.5 * 1024 * 1024);
	const exact = await processImage(padded, "image/png");
	assert.ok(exact.ok);
	assert.notEqual(exact.data, padded.toString("base64"));
	assert.ok(exact.data.length < 4.5 * 1024 * 1024);
	assert.equal(exact.hints.length, 1, "native re-encoding is marked resized even at identical dimensions");
	const justBelow = padded.subarray(0, padded.length - 3);
	const below = await processImage(justBelow, "image/png");
	assert.ok(below.ok);
	assert.equal(below.data, justBelow.toString("base64"));
	assert.deepEqual(below.hints, []);
});

test("PNG wins first under cap even when JPEG is smaller", async () => {
	const bytes = png(96, 96, true);
	const candidates = encodings(bytes, 95, 95);
	assert.ok(candidates[0]!.data.length > candidates[1]!.data.length);
	const result = await resizeImage(bytes, "image/png", { maxWidth: 95, maxBytes: candidates[0]!.data.length + 1 });
	assert.ok(result);
	assert.equal(result.mimeType, "image/png");
	assert.equal(result.data, candidates[0]!.data);
});

test("JPEG quality selection is native first-fit [80,85,70,55,40], not smallest output", async () => {
	const bytes = png(96, 96, true);
	const candidates = encodings(bytes, 96, 96);
	assert.ok(candidates[0]!.data.length > candidates[2]!.data.length);
	assert.ok(candidates[2]!.data.length > candidates[1]!.data.length);
	assert.ok(candidates[1]!.data.length > candidates[3]!.data.length);
	const at80 = await resizeImage(bytes, "image/png", { maxBytes: candidates[1]!.data.length + 1 });
	assert.ok(at80);
	assert.equal(at80.data, candidates[1]!.data);
	// Strict equality excludes 80; 85 is larger, so 70 is the next fit.
	const at70 = await resizeImage(bytes, "image/png", { maxBytes: candidates[1]!.data.length });
	assert.ok(at70);
	assert.equal(at70.data, candidates[3]!.data);
	assert.equal(at70.width, 96);
	assert.equal(at70.height, 96);
	for (const [index, quality] of [[4, 55], [5, 40]] as const) {
		const candidate = candidates[index]!;
		const cap = candidate.data.length + 1;
		assert.ok(candidates.slice(0, index).every((earlier) => earlier.data.length >= cap));
		const lowerQuality = await resizeImage(bytes, "image/png", { maxBytes: cap });
		assert.ok(lowerQuality);
		assert.equal(lowerQuality.data, candidate.data, `native quality ${quality} wins when preceding candidates are over cap`);
		assert.equal(lowerQuality.width, 96);
		assert.equal(lowerQuality.height, 96);
	}
	const override = await resizeImage(bytes, "image/png", { jpegQuality: 85, maxBytes: candidates[2]!.data.length + 1 });
	assert.ok(override);
	assert.equal(override.data, candidates[2]!.data, "caller quality precedes the native remaining quality steps");
});

test("all encodings over cap reduce each dimension by floor(0.75), eventually omitting at 1x1", async () => {
	const bytes = png(97, 95, true);
	const full = encodings(bytes, 97, 95);
	const next = encodings(bytes, 72, 71);
	const maxBytes = Math.min(...full.map((candidate) => candidate.data.length));
	const expected = next.find((candidate) => candidate.data.length < maxBytes);
	assert.ok(expected, "synthetic fixture fits on the first reduced dimensions");
	const result = await resizeImage(bytes, "image/png", { maxBytes });
	assert.ok(result);
	assert.equal(result.width, 72);
	assert.equal(result.height, 71);
	assert.equal(result.mimeType, expected.mimeType);
	assert.equal(result.data, expected.data);
	assert.equal(await resizeImage(bytes, "image/png", { maxBytes: 1 }), null);
	const omitted = await processImage(bytes, "image/png", { resizeOptions: { maxBytes: 1 } });
	assert.deepEqual(omitted, { ok: false, message: "[Image omitted: could not be resized below the inline image size limit.]" });
});

test("BMP converts to PNG and reports the native conversion hint", async () => {
	const bytes = bmp();
	assert.equal(detectSupportedImageMimeType(bytes), "image/bmp");
	const result = await processImage(bytes, "IMAGE/BMP");
	assert.ok(result.ok);
	assert.equal(result.mimeType, "image/png");
	assert.equal(detectSupportedImageMimeType(Buffer.from(result.data, "base64")), "image/png");
	assert.deepEqual(result.hints, ["[Image converted from image/bmp to image/png.]"]);
	const decoded = photon.PhotonImage.new_from_byteslice(Buffer.from(result.data, "base64"));
	try {
		assert.equal(decoded.get_width(), 2);
		assert.equal(decoded.get_height(), 1);
	} finally { decoded.free(); }
});

test("EXIF-oriented dimensions govern resizing, with native unchanged-byte behavior when already fit", async () => {
	for (const orientation of [2, 3, 4, 5, 6, 7, 8]) {
		const bytes = exifJpeg(orientation);
		const untouched = await resizeImage(bytes, "image/jpeg");
		assert.ok(untouched);
		assert.equal(untouched.data, bytes.toString("base64"));
		assert.equal(untouched.originalWidth, orientation >= 5 ? 8 : 12);
		assert.equal(untouched.originalHeight, orientation >= 5 ? 12 : 8);
		const resized = await resizeImage(bytes, "image/jpeg", { maxWidth: 6, maxHeight: 6 });
		assert.ok(resized);
		assert.equal(resized.width, orientation >= 5 ? 4 : 6);
		assert.equal(resized.height, orientation >= 5 ? 6 : 4);
	}
});

test("EXIF mirrors and rotations preserve exact pixel placement for JPEG and both WebP EXIF layouts", () => {
	const expected = [
		[1, 2, 3, 4, 5, 6], // unchanged
		[3, 2, 1, 6, 5, 4], // horizontal mirror
		[6, 5, 4, 3, 2, 1], // 180 degrees
		[4, 5, 6, 1, 2, 3], // vertical mirror
		[1, 4, 2, 5, 3, 6], // transpose
		[4, 1, 5, 2, 6, 3], // 90 degrees clockwise
		[6, 3, 5, 2, 4, 1], // transverse
		[3, 6, 2, 5, 1, 4], // 90 degrees counterclockwise
	];
	for (let orientation = 1; orientation <= 8; orientation++) {
		const jpeg = exifJpeg(orientation);
		// Only metadata is needed here: decoding is covered by the resize test.
		const exif = jpeg.subarray(6, 38);
		for (const metadata of [jpeg, ...[exif, exif.subarray(6)].map((data) => {
			// Odd-size RIFF chunk before EXIF verifies native even-byte padding.
			const webp = Buffer.alloc(12 + 10 + 8 + data.length);
			webp.write("RIFF", 0);
			webp.writeUInt32LE(webp.length - 8, 4);
			webp.write("WEBP", 8);
			webp.write("JUNK", 12);
			webp.writeUInt32LE(1, 16);
			webp.write("EXIF", 22);
			webp.writeUInt32LE(data.length, 26);
			data.copy(webp, 30);
			return webp;
		})]) {
			const pixels = Uint8Array.from([1, 2, 3, 4, 5, 6].flatMap((value) => [value, 0, 0, 255]));
			const raw = new photon.PhotonImage(pixels, 3, 2);
			const oriented = applyExifOrientation(photon, raw, metadata);
			try {
				assert.equal(oriented.get_width(), orientation >= 5 ? 2 : 3);
				assert.equal(oriented.get_height(), orientation >= 5 ? 3 : 2);
				assert.deepEqual(Array.from(oriented.get_raw_pixels()).filter((_, index) => index % 4 === 0), expected[orientation - 1]);
			} finally {
				if (oriented !== raw) oriented.free();
				raw.free();
			}
		}
	}
});

test("corrupt supported input is omitted, unsupported conversion fails, and explicit autoResizeImages=false retains native bypass", async () => {
	const bytes = Buffer.from("not an image");
	assert.deepEqual(await processImage(bytes, "image/png"), { ok: false, message: "[Image omitted: could not be resized below the inline image size limit.]" });
	assert.deepEqual(await processImage(bytes, "image/bmp"), { ok: false, message: "[Image omitted: could not be converted to a supported inline image format.]" });
	assert.deepEqual(await processImage(bytes, "image/png", { autoResizeImages: false }), { ok: true, data: bytes.toString("base64"), mimeType: "image/png", hints: [] });
	const wide = png(12000, 24);
	const bypass = await processImage(wide, "image/png", { autoResizeImages: false });
	assert.ok(bypass.ok);
	assert.equal(bypass.data, wide.toString("base64"));
	const converted = await processImage(bmp(), "image/bmp", { autoResizeImages: false });
	assert.ok(converted.ok);
	assert.equal(converted.mimeType, "image/png");
});

test("MIME sniffing matches native supported signatures and rejects APNG/JPEG-LS/malformed BMP", async () => {
	assert.equal(detectSupportedImageMimeType(png()), "image/png");
	assert.equal(detectSupportedImageMimeType(Buffer.from([0xff, 0xd8, 0xff, 0xe0])), "image/jpeg");
	assert.equal(detectSupportedImageMimeType(Buffer.from([0xff, 0xd8, 0xff, 0xf7])), null);
	assert.equal(detectSupportedImageMimeType(Buffer.from("GIF89a")), "image/gif");
	assert.equal(detectSupportedImageMimeType(Buffer.from("GIF87a")), "image/gif");
	assert.equal(detectSupportedImageMimeType(Buffer.from("RIFFxxxxWEBP")), "image/webp");
	assert.equal(detectSupportedImageMimeType(Buffer.from("BM")), null);
	assert.equal(detectSupportedImageMimeType(Buffer.from("not an image")), null);
	const truncatedPng = Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]);
	assert.equal(detectSupportedImageMimeType(truncatedPng), null);
	// MIME sniffing, like Pi, walks chunk headers without checking CRCs.
	const source = png(2, 2);
	const acTL = Buffer.alloc(20);
	acTL.writeUInt32BE(8, 0);
	acTL.write("acTL", 4);
	const apng = Buffer.concat([source.subarray(0, 33), acTL, source.subarray(33)]);
	assert.equal(detectSupportedImageMimeType(apng), null);
	const badBmp = bmp();
	badBmp.writeUInt16LE(2, 26);
	assert.equal(detectSupportedImageMimeType(badBmp), null);
	const dir = await mkdtemp(path.join(os.tmpdir(), "lh-image-processing-"));
	try {
		await writeFile(path.join(dir, "renamed.txt"), source);
		await writeFile(path.join(dir, "animated.png"), apng);
		assert.equal(await detectSupportedImageMimeTypeFromFile(path.join(dir, "renamed.txt")), "image/png");
		assert.equal(await detectSupportedImageMimeTypeFromFile(path.join(dir, "animated.png")), null);
		await assert.rejects(detectSupportedImageMimeTypeFromFile(path.join(dir, "missing")), { code: "ENOENT" });
	} finally { await rm(dir, { recursive: true, force: true }); }
});

test("unbundled Node worker responds with tagged output and matches the in-process fallback", async () => {
	const bytes = png(96, 96, true);
	const options = { maxWidth: 64, maxHeight: 64, maxBytes: 4000 };
	const worker = new Worker(path.join(process.cwd(), "src/agent/image-processing/resize-worker.mjs"));
	try {
		const reply = new Promise<{ type: string; result: unknown }>((resolve, reject) => {
			worker.once("message", resolve);
			worker.once("error", reject);
		});
		worker.postMessage({ inputBytes: new Uint8Array(bytes), mimeType: "image/png", options });
		assert.deepEqual(await reply, { type: "pi:image-resize-response", result: await resizeImageInProcess(bytes, "image/png", options) });
		assert.deepEqual(await resizeImage(bytes, "image/png", options), await resizeImageInProcess(bytes, "image/png", options));
	} finally { await worker.terminate(); }
});

test("missing cwd-relative worker falls back in-process without altering the caller bytes", async () => {
	const cwd = process.cwd();
	const dir = await mkdtemp(path.join(os.tmpdir(), "lh-image-worker-fallback-"));
	const bytes = png();
	const options = { maxWidth: 64, maxHeight: 64 };
	const expected = await resizeImageInProcess(bytes, "image/png", options);
	try {
		process.chdir(dir);
		assert.deepEqual(await resizeImage(bytes, "image/png", options), expected);
	} finally {
		process.chdir(cwd);
		await rm(dir, { recursive: true, force: true });
	}
});