import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, unlinkSync, writeFileSync } from "node:fs";
import { dirname, join } from "node:path";
import { normalizeDimensionId } from "../../../shared/world/dimensions.js";
import
{
	MINIMAP_CHUNK_PIXELS,
	MINIMAP_SPAN_CHUNKS,
	minimapRadius,
	renderChunkMinimapRgba
} from "../../../shared/render/chunkMinimap.js";
import { decodeChunkBlob } from "../world/chunkData.js";

const RGBA_BYTES = MINIMAP_CHUNK_PIXELS * MINIMAP_CHUNK_PIXELS * 4;

/**
 * Per-dimension minimap images, one uncompressed RGBA file per saved chunk.
 *
 * Lives under the server data directory next to `world.sqlite`:
 * `minimap/<dimensionId>/<chunkX>_<chunkY>.rgba`
 * (16×16×4 bytes while chunks are 16 tiles square).
 *
 * A file is written when that chunk is saved, and created on read when it is
 * missing but the chunk exists. Chunks with no row are drawn as empty by the
 * client and any stale file for them is removed. Changing sprite colours
 * (see `color-stamp.txt`) deletes every cached image so the next read rebuilds
 * them. The editor asks for a window of chunks; only cache misses load the
 * chunk blob.
 */
export class MinimapCache
{
	constructor (rootDir, worldDb)
	{
		this.rootDir = rootDir;
		this.worldDb = worldDb;
	}

	pathFor (dimensionId, chunkX, chunkY)
	{
		const dim = normalizeDimensionId(dimensionId);
		return join(this.rootDir, dim, `${chunkX | 0}_${chunkY | 0}.rgba`);
	}

	/**
	 * Drop cached images when the sprite-colour stamp changes (new or edited art).
	 * @param {string} stamp
	 */
	syncColorStamp (stamp)
	{
		mkdirSync(this.rootDir, { recursive: true });
		const file = join(this.rootDir, "color-stamp.txt");
		const next = String(stamp ?? "");
		let previous = null;
		try
		{ previous = readFileSync(file, "utf8"); }
		catch
		{ previous = null; }
		if (previous === next)
		{ return; }
		let entries = [];
		try
		{ entries = readdirSync(this.rootDir, { withFileTypes: true }); }
		catch
		{ entries = []; }
		for (const entry of entries)
		{
			if (!entry.isDirectory())
			{ continue; }
			rmSync(join(this.rootDir, entry.name), { recursive: true, force: true });
		}
		writeFileSync(file, next);
	}

	removeDimensions (dimensionIds)
	{
		for (const dimensionId of dimensionIds ?? [])
		{
			rmSync(join(this.rootDir, normalizeDimensionId(dimensionId)), { recursive: true, force: true });
		}
	}

	/**
	 * @param {string} dimensionId
	 * @param {number} chunkX
	 * @param {number} chunkY
	 * @param {object} chunkData
	 * @param {number} defaultGroundTypeId
	 * @returns {Buffer}
	 */
	write (dimensionId, chunkX, chunkY, chunkData, defaultGroundTypeId)
	{
		const rgba = renderChunkMinimapRgba(chunkData, defaultGroundTypeId);
		const file = this.pathFor(dimensionId, chunkX, chunkY);
		mkdirSync(dirname(file), { recursive: true });
		const buffer = Buffer.from(rgba.buffer, rgba.byteOffset, rgba.byteLength);
		writeFileSync(file, buffer);
		return buffer;
	}

	/**
	 * @returns {Buffer | null} cached or freshly built image, or null when the chunk is not saved
	 */
	readOrCreate (dimensionId, chunkX, chunkY, revisionId, defaultGroundTypeId)
	{
		const file = this.pathFor(dimensionId, chunkX, chunkY);
		const cached = this.#readValid(file);
		const saved = this.worldDb.hasChunkVersion(chunkX, chunkY, revisionId, dimensionId);
		if (!saved)
		{
			if (cached)
			{ unlinkSync(file); }
			return null;
		}
		if (cached)
		{ return cached; }
		const row = this.worldDb.getChunkVersion(chunkX, chunkY, revisionId, dimensionId);
		if (!row)
		{ return null; }
		const data = decodeChunkBlob(row.data_blob, defaultGroundTypeId, chunkX, chunkY);
		return this.write(dimensionId, chunkX, chunkY, data, defaultGroundTypeId);
	}

	/**
	 * 25×25 chunk window centred on `centerChunkX` / `centerChunkY`.
	 * Present chunks are raw RGBA, base64. Missing chunks are omitted.
	 */
	window (dimensionId, centerChunkX, centerChunkY, revisionId, defaultGroundTypeId)
	{
		const dim = normalizeDimensionId(dimensionId);
		const centerX = centerChunkX | 0;
		const centerY = centerChunkY | 0;
		const radius = minimapRadius(MINIMAP_SPAN_CHUNKS);
		const chunks = {};
		for (let dy = -radius; dy <= radius; dy++)
		{
			for (let dx = -radius; dx <= radius; dx++)
			{
				const chunkX = centerX + dx;
				const chunkY = centerY + dy;
				try
				{
					const image = this.readOrCreate(dim, chunkX, chunkY, revisionId, defaultGroundTypeId);
					if (image)
					{ chunks[`${chunkX},${chunkY}`] = image.toString("base64"); }
				}
				catch (error)
				{
					console.error(
						`[minimap] skipped ${dim} ${chunkX},${chunkY}:`,
						error?.message ?? error
					);
				}
			}
		}
		return {
			dimensionId: dim,
			chunkX: centerX,
			chunkY: centerY,
			chunkPixels: MINIMAP_CHUNK_PIXELS,
			span: MINIMAP_SPAN_CHUNKS,
			chunks
		};
	}

	#readValid (file)
	{
		if (!existsSync(file))
		{ return null; }
		const buffer = readFileSync(file);
		if (buffer.length !== RGBA_BYTES)
		{
			unlinkSync(file);
			return null;
		}
		return buffer;
	}
}
