/// <reference lib="webworker" />

import {
	block_light_emission,
	block_light_opacity,
	type BlockRegistry,
	type RenderLayer,
} from "$/common/everything_registry.ts";
import {
	AIR,
	CHUNK_AREA,
	CHUNK_HEIGHT,
	CHUNK_SIZE,
	ID_MASK,
	type SpriteRegion,
	TEXTURE_SIZE,
} from "$/common/constants.ts";
import type { Texture } from "../renderer/types.ts";
import {
	FACE_GROUPS,
	type FaceGroup,
	type FromChunkWorker,
	TERRAIN_QUAD_BYTES,
	TERRAIN_VERTEX_BYTES,
	type ToChunkWorker,
	UNALIGNED_GROUP,
} from "./chunk_messages.ts";
import { generate_raw_chunk, WorldgenSetup } from "$/common/generation.ts";
import { load_worldgen } from "$/common/worldgen_loader.ts";
import { default_block_value, get_state_value } from "$/common/utils.ts";
import { bake_model, block_variant, FACE_CORNERS, find_model, type ModelJson } from "$/common/block_models.ts";
import {
	choose_sort_type,
	FACE_AXIS,
	FACE_NORMALS,
	quad_indices,
	quad_planes,
	sort_by_distance,
	sort_quads,
} from "./translucent_sort.ts";
import {
	LightRegion,
	type LightTables,
	region_block,
	region_block_light,
	REGION_LAYER,
	REGION_SIZE,
	region_sky,
	REGION_VOID,
} from "./lighting.ts";

type TexturesInfo = Record<string, SpriteRegion>;

// keeps texture lookups off the sprite's edge
const UV_PAD = 0.5;

// same order as FACE_NORMALS in translucent_sort.ts, and FACE_CORNERS and CORNER_UVS in block_models.ts
// minecraft's shading by direction, so faces stay apart even in flat light
const FACE_SHADE = [1.0, 0.5, 0.8, 0.8, 0.6, 0.6];

// for each face corner, the two cells beside the cell in front of the face that touch that corner,
// as [index offset, y offset] for each. the cell touching both is at the sum of them
const CORNER_SIDES = FACE_CORNERS.map((corners, face) =>
	corners.map((corner) => {
		const sides: number[] = [];
		for (let axis = 0; axis < 3; axis++) {
			if (FACE_NORMALS[face][axis] !== 0) continue;
			const d = corner[axis] * 2 - 1;
			sides.push(axis === 0 ? d : axis === 1 ? d * REGION_LAYER : d * REGION_SIZE, axis === 1 ? d : 0);
		}
		return sides;
	})
);

const SOLID = 0;
const CUTOUT = 1;
const TRANSLUCENT = 2;
const LAYER_IDS: Record<RenderLayer, number> = { solid: SOLID, cutout: CUTOUT, translucent: TRANSLUCENT };

let blocks_registry: BlockRegistry[] = [];
let block_ids: Record<string, number> = {};
// by numeric id, looked up for every face. like sodium's light data cache, everything the mesher asks about a
// block is worked out once instead of per face
const TABLE_SIZE = ID_MASK + 1;
const block_layers = new Uint8Array(TABLE_SIZE);
const block_cull_same = new Uint8Array(TABLE_SIZE);
// darkens the corners it touches (minecraft's ambient occlusion), blocks with a full collision box do
const block_occludes = new Uint8Array(TABLE_SIZE);
// light can come around a corner past it
const block_lets_light_by = new Uint8Array(TABLE_SIZE);
const light_tables: LightTables = { opacity: new Uint8Array(TABLE_SIZE), emission: new Uint8Array(TABLE_SIZE) };
const region = new LightRegion();

// a model's quad ready for the mesher: uvs in the atlas, and for each corner how much of each of the face's
// four corner lights it gets, so faces smaller than the block are lit like minecraft's
interface MeshQuad {
	positions: number[];
	uvs: number[];
	face: number;
	cull: number;
	flush: boolean;
	// the face group it goes in, see FACE_GROUPS
	group: number;
	shade: number;
	sprite: SpriteRegion;
	// 4 weights per corner
	light_weights: number[];
}

let models: Record<string, ModelJson> = {};
// by block value, or by numeric id for blocks without variants
const baked = new Map<number, MeshQuad[]>();

let textures_info: TexturesInfo = {};
let image: Texture;
let worldgen: WorldgenSetup | undefined;
// numeric id to what a generated block stores, with its default states. matches the server
let default_values: number[] = [];
// generating has to wait for mods' worldgen scripts, or this worker's terrain wouldn't match the server's
let worldgen_ready: Promise<void> = Promise.resolve();

self.onmessage = async (event: MessageEvent<ToChunkWorker>) => {
	const message = event.data;
	switch (message.type) {
		case "init":
			blocks_registry = message.blocks_registry;
			block_ids = message.block_ids;
			models = message.models;
			baked.clear();
			build_block_tables();
			textures_info = message.textures_info;
			image = message.image as Texture;
			default_values = blocks_registry.map((block, nid) => default_block_value(nid, block));
			worldgen_ready = load_worldgen(message.worldgen_scripts, message.ores).then((setup) => {
				worldgen = setup;
			});
			break;
		case "generate":
			await worldgen_ready;
			generate(message.chunk_x, message.chunk_z, message.seed);
			break;
		case "mesh": {
			region.fill(message.chunks);
			region.compute(light_tables);
			const { solid, cutout, translucent, min_y, max_y } = make_chunk_mesh(
				message.chunk_x,
				message.chunk_z,
				message.chunks[4]!,
				message.camera,
			);
			post(
				{
					type: "meshed",
					chunk_x: message.chunk_x,
					chunk_z: message.chunk_z,
					version: message.version,
					min_y,
					max_y,
					solid,
					cutout,
					translucent,
					camera: message.camera,
				},
				[
					solid.vertices.buffer,
					cutout.vertices.buffer,
					translucent.vertices.buffer,
					translucent.indices.buffer,
					translucent.centers.buffer,
					...translucent.planes.map((planes) => planes.buffer),
				],
			);
			break;
		}
		case "sort": {
			const [x, y, z] = message.camera;
			const indices = quad_indices(sort_by_distance(message.centers, message.centers.length / 3, x, y, z));
			post({
				type: "sorted",
				chunk_x: message.chunk_x,
				chunk_z: message.chunk_z,
				version: message.version,
				sort_version: message.sort_version,
				indices,
			}, [indices.buffer]);
			break;
		}
	}
};

function post(message: FromChunkWorker, transfer: Transferable[]) {
	self.postMessage(message, transfer);
}

function generate(chunk_x: number, chunk_z: number, seed: string) {
	const { blocks, spills } = generate_raw_chunk(chunk_x, chunk_z, seed, block_ids, worldgen, default_values);
	post({ type: "generated", chunk_x, chunk_z, blocks, spills }, [blocks.buffer, spills.buffer]);
}

function build_block_tables() {
	blocks_registry.forEach((block, nid) => {
		if (!block || nid === AIR) return;
		const layer = LAYER_IDS[block.render_layer ?? "solid"];
		const opacity = block_light_opacity(block);
		block_layers[nid] = layer;
		block_cull_same[nid] = (block.cull_same ?? layer === TRANSLUCENT) ? 1 : 0;
		block_occludes[nid] = block.has_collision && layer !== TRANSLUCENT ? 1 : 0;
		block_lets_light_by[nid] = layer !== SOLID || opacity === 0 ? 1 : 0;
		light_tables.opacity[nid] = opacity;
		light_tables.emission[nid] = block_light_emission(block);
	});
	block_lets_light_by[AIR] = 1;
	block_layers[REGION_VOID] = SOLID;
	block_occludes[REGION_VOID] = 1;
	light_tables.opacity[REGION_VOID] = 15;
}

// the rule vanilla minecraft (and so sodium) uses: solid neighbors hide a face, and some blocks
// hide faces between two of themselves
function show_face(block: number, neighbor: number) {
	if (neighbor === AIR) return true;
	if (block_layers[neighbor] === SOLID) return false;
	return !(neighbor === block && block_cull_same[block]);
}

// per corner of the face being built
const corner_sky = new Float32Array(4);
const corner_block = new Float32Array(4);
const corner_ao = new Float32Array(4);

// minecraft's smooth lighting: each corner averages the light of the cell in front of the face and the three
// cells around it that touch the corner, and gets darker for each of those that's a full block
function light_face_corners(face: number, front: number, front_y: number) {
	const front_id = region_block(region, front, front_y);
	const front_sky = region_sky(region, front, front_y);
	const front_block = region_block_light(region, front, front_y);
	const front_ao = block_occludes[front_id] ? 0.2 : 1;

	for (let corner = 0; corner < 4; corner++) {
		const [a_offset, a_dy, b_offset, b_dy] = CORNER_SIDES[face][corner];
		const a = front + a_offset;
		const a_y = front_y + a_dy;
		const b = front + b_offset;
		const b_y = front_y + b_dy;
		const a_id = region_block(region, a, a_y);
		const b_id = region_block(region, b, b_y);

		let a_sky = region_sky(region, a, a_y);
		let a_block = region_block_light(region, a, a_y);
		let b_sky = region_sky(region, b, b_y);
		let b_block = region_block_light(region, b, b_y);
		const a_ao = block_occludes[a_id] ? 0.2 : 1;
		const b_ao = block_occludes[b_id] ? 0.2 : 1;

		// with both sides closed the corner cell can't be seen, vanilla uses a side's values instead
		let c_sky = a_sky;
		let c_block = a_block;
		let c_ao = a_ao;
		if (block_lets_light_by[a_id] || block_lets_light_by[b_id]) {
			const c = a + b_offset;
			const c_y = a_y + b_dy;
			c_sky = region_sky(region, c, c_y);
			c_block = region_block_light(region, c, c_y);
			c_ao = block_occludes[region_block(region, c, c_y)] ? 0.2 : 1;
		}

		// cells with no light at all are usually inside solid blocks, vanilla counts them as the front cell
		// so corners against walls don't go black
		if (a_sky === 0 && a_block === 0) {
			a_sky = front_sky;
			a_block = front_block;
		}
		if (b_sky === 0 && b_block === 0) {
			b_sky = front_sky;
			b_block = front_block;
		}
		if (c_sky === 0 && c_block === 0) {
			c_sky = front_sky;
			c_block = front_block;
		}

		corner_sky[corner] = (a_sky + b_sky + c_sky + front_sky) / 4;
		corner_block[corner] = (a_block + b_block + c_block + front_block) / 4;
		corner_ao[corner] = (a_ao + b_ao + c_ao + front_ao) / 4;
	}
}

// sodium's rule for which diagonal splits the quad: the brighter one, otherwise the ambient occlusion
// gets smeared across the whole face
function should_flip() {
	const ao_02 = corner_ao[0] + corner_ao[2];
	const ao_13 = corner_ao[1] + corner_ao[3];
	if (ao_02 !== ao_13) {
		return ao_02 < ao_13;
	}
	const light = (corner: number) => corner_sky[corner] * 16 + corner_block[corner];
	return light(0) + light(2) > light(1) + light(3);
}

// quads being built, in the terrain vertex format
class QuadBuffer {
	count = 0;
	bytes = new Uint8Array(TERRAIN_QUAD_BYTES * 64);
	f32 = new Float32Array(this.bytes.buffer);
	u16 = new Uint16Array(this.bytes.buffer);

	// room for one more quad
	reserve() {
		if ((this.count + 1) * TERRAIN_QUAD_BYTES <= this.bytes.length) return;
		const bytes = new Uint8Array(this.bytes.length * 2);
		bytes.set(this.bytes);
		this.bytes = bytes;
		this.f32 = new Float32Array(bytes.buffer);
		this.u16 = new Uint16Array(bytes.buffer);
	}
}

// the lowest and highest y of any quad in the chunk being meshed
let mesh_min_y = Infinity;
let mesh_max_y = -Infinity;

function push_quad(buffer: QuadBuffer, quad: MeshQuad, x: number, y: number, z: number, alpha: number) {
	buffer.reserve();
	const { f32, u16, bytes } = buffer;
	const sprite = quad.sprite;
	// starting from the second corner moves the diagonal, the winding stays the same
	const first = should_flip() ? 1 : 0;
	const alpha_byte = Math.round(alpha * 255);

	for (let k = 0; k < 4; k++) {
		const corner = (first + k) & 3;
		const byte = (buffer.count * 4 + k) * TERRAIN_VERTEX_BYTES;
		const vy = y + quad.positions[corner * 3 + 1];
		f32[byte / 4] = x + quad.positions[corner * 3];
		f32[byte / 4 + 1] = vy;
		f32[byte / 4 + 2] = z + quad.positions[corner * 3 + 2];
		u16[byte / 2 + 6] = Math.round(atlas_u(sprite, quad.uvs[corner * 2]) * 65535);
		u16[byte / 2 + 7] = Math.round(atlas_v(sprite, quad.uvs[corner * 2 + 1]) * 65535);
		const brightness = Math.round(quad.shade * corner_ao[corner] * 255);
		bytes[byte + 16] = brightness;
		bytes[byte + 17] = brightness;
		bytes[byte + 18] = brightness;
		bytes[byte + 19] = alpha_byte;
		// where to read the lightmap, block light across and sky light down
		bytes[byte + 20] = Math.round((corner_block[corner] + 0.5) / 16 * 255);
		bytes[byte + 21] = Math.round((corner_sky[corner] + 0.5) / 16 * 255);
		if (vy < mesh_min_y) mesh_min_y = vy;
		if (vy > mesh_max_y) mesh_max_y = vy;
	}
	buffer.count += 1;
}

// pixels of a sprite to atlas coordinates, kept off the sprite's edge
function atlas_u(sprite: SpriteRegion, u: number) {
	return (sprite.x * TEXTURE_SIZE + Math.min(Math.max(u, UV_PAD), TEXTURE_SIZE - UV_PAD)) / image.width;
}

function atlas_v(sprite: SpriteRegion, v: number) {
	return (sprite.y * TEXTURE_SIZE + Math.min(Math.max(v, UV_PAD), TEXTURE_SIZE - UV_PAD)) / image.height;
}

// the model quads for a block value, baked the first time it's seen
function block_quads(value: number): MeshQuad[] {
	const nid = value & ID_MASK;
	const block = blocks_registry[nid];
	const key = block.variants ? value : nid;
	let quads = baked.get(key);
	if (quads) return quads;

	let states: Record<string, number> | undefined;
	if (block.variants && block.states) {
		states = {};
		for (const state of block.states) states[state.name] = get_state_value(value, block, state.name)!;
	}
	const variant = block_variant(block, states);
	const model = find_model(variant.model, models) ?? find_model("engine:cube", models)!;

	quads = bake_model(model, variant.textures, variant.y).map((quad) => ({
		positions: quad.positions,
		uvs: quad.uvs,
		face: quad.face,
		cull: quad.cull,
		flush: quad.flush,
		group: quad.aligned ? quad.face : UNALIGNED_GROUP,
		shade: quad.shade ? FACE_SHADE[quad.face] : 1,
		sprite: textures_info[quad.texture] ?? textures_info["engine:missing"],
		light_weights: light_weights(quad.face, quad.positions),
	}));
	baked.set(key, quads);
	return quads;
}

// bilinear weights of the face's four corners at each of the quad's corners
function light_weights(face: number, positions: number[]) {
	const axes = [0, 1, 2].filter((axis) => FACE_NORMALS[face][axis] === 0);
	const weights: number[] = [];
	for (let k = 0; k < 4; k++) {
		for (const corner of FACE_CORNERS[face]) {
			let weight = 1;
			for (const axis of axes) {
				const t = Math.min(Math.max(positions[k * 3 + axis], 0), 1);
				weight *= corner[axis] ? t : 1 - t;
			}
			weights.push(weight);
		}
	}
	return weights;
}

// light for a quad smaller than a face, or not on the block's edge at all
const face_sky = new Float32Array(4);
const face_block = new Float32Array(4);
const face_ao = new Float32Array(4);

function light_quad(quad: MeshQuad, index: number, y: number, face_offsets: number[]) {
	if (quad.flush) {
		light_face_corners(quad.face, index + face_offsets[quad.face], y + FACE_NORMALS[quad.face][1]);
		face_sky.set(corner_sky);
		face_block.set(corner_block);
		face_ao.set(corner_ao);
		const w = quad.light_weights;
		for (let k = 0; k < 4; k++) {
			let sky = 0;
			let block = 0;
			let ao = 0;
			for (let c = 0; c < 4; c++) {
				sky += w[k * 4 + c] * face_sky[c];
				block += w[k * 4 + c] * face_block[c];
				ao += w[k * 4 + c] * face_ao[c];
			}
			corner_sky[k] = sky;
			corner_block[k] = block;
			corner_ao[k] = ao;
		}
		return;
	}

	// inside the block: its own cell's light, or the cell it faces if the block stops light itself
	let cell = index;
	let cell_y = y;
	if (light_tables.opacity[region_block(region, index, y)] === 15) {
		cell = index + face_offsets[quad.face];
		cell_y = y + FACE_NORMALS[quad.face][1];
	}
	corner_sky.fill(region_sky(region, cell, cell_y));
	corner_block.fill(region_block_light(region, cell, cell_y));
	corner_ao.fill(1);
}

// region has to be filled and lit first
// values is the middle chunk's blocks with their states, for models that change with them
function make_chunk_mesh(chunk_x: number, chunk_z: number, values: Uint32Array, camera: number[]) {
	// solid and cutout get a buffer per face group, translucent one for everything since it's sorted instead
	const opaque = [SOLID, CUTOUT].map(() =>
		Array.from({ length: FACE_GROUPS }, () => ({ buffer: new QuadBuffer(), min: Infinity, max: -Infinity }))
	);
	const translucent_quads = new QuadBuffer();
	mesh_min_y = Infinity;
	mesh_max_y = -Infinity;
	// for sorting the translucent quads
	let centers = new Float32Array(256);
	let faces = new Uint8Array(256);

	// where the neighbor on each face is, same order as FACE_NORMALS
	const face_offsets = FACE_NORMALS.map(([nx, ny, nz]) => nx + ny * REGION_LAYER + nz * REGION_SIZE);

	for (let y = 0; y < CHUNK_HEIGHT; y++) {
		for (let z = 0; z < CHUNK_SIZE; z++) {
			for (let x = 0; x < CHUNK_SIZE; x++) {
				// the middle chunk of the region
				const index = y * REGION_LAYER + (z + CHUNK_SIZE) * REGION_SIZE + x + CHUNK_SIZE;
				const block_nid = region.blocks[index];
				if (block_nid === AIR) continue;

				const block_info = blocks_registry[block_nid];
				const layer_id = block_layers[block_nid];
				const alpha = layer_id === TRANSLUCENT ? block_info.alpha ?? 1 : 1;

				const wx = chunk_x * CHUNK_SIZE + x;
				const wz = chunk_z * CHUNK_SIZE + z;

				for (const quad of block_quads(values[y * CHUNK_AREA + z * CHUNK_SIZE + x])) {
					if (quad.cull >= 0) {
						const neighbor = region_block(
							region,
							index + face_offsets[quad.cull],
							y + FACE_NORMALS[quad.cull][1],
						);
						if (!show_face(block_nid, neighbor)) continue;
					}

					light_quad(quad, index, y, face_offsets);

					if (layer_id !== TRANSLUCENT) {
						const group = opaque[layer_id][quad.group];
						push_quad(group.buffer, quad, wx, y, wz, alpha);
						if (quad.group !== UNALIGNED_GROUP) {
							const axis = FACE_AXIS[quad.face];
							const plane = (axis === 0 ? wx : axis === 1 ? y : wz) + quad.positions[axis];
							if (plane < group.min) group.min = plane;
							if (plane > group.max) group.max = plane;
						}
					} else {
						push_quad(translucent_quads, quad, wx, y, wz, alpha);
						// sorting treats every quad as facing along an axis, rotated ones too
						const q = translucent_quads.count - 1;
						centers = ensure_capacity(centers, (q + 1) * 3);
						faces = ensure_capacity(faces, q + 1);
						const p = quad.positions;
						centers[q * 3] = wx + (p[0] + p[6]) / 2;
						centers[q * 3 + 1] = y + (p[1] + p[7]) / 2;
						centers[q * 3 + 2] = wz + (p[2] + p[8]) / 2;
						faces[q] = quad.face;
					}
				}
			}
		}
	}

	// each layer's groups one after another, in one buffer
	const [solid, cutout] = opaque.map((groups) => {
		const quad_count = groups.reduce((sum, group) => sum + group.buffer.count, 0);
		const vertices = new Uint8Array(quad_count * TERRAIN_QUAD_BYTES);
		const ranges: FaceGroup[] = [];
		let first = 0;
		for (const { buffer, min, max } of groups) {
			vertices.set(buffer.bytes.subarray(0, buffer.count * TERRAIN_QUAD_BYTES), first * TERRAIN_QUAD_BYTES);
			ranges.push({ first, count: buffer.count, min, max });
			first += buffer.count;
		}
		return { vertices, quad_count, groups: ranges };
	});
	const translucent = {
		vertices: translucent_quads.bytes.slice(0, translucent_quads.count * TERRAIN_QUAD_BYTES),
		quad_count: translucent_quads.count,
	};

	const quads = { centers, faces, count: translucent.quad_count };
	const sort_type = choose_sort_type(quads);
	const [camera_x, camera_y, camera_z] = camera;

	return {
		min_y: mesh_min_y === Infinity ? 0 : mesh_min_y,
		max_y: mesh_max_y === -Infinity ? 0 : mesh_max_y,
		solid,
		cutout,
		translucent: {
			...translucent,
			indices: sort_quads(quads, sort_type, camera_x, camera_y, camera_z),
			sort_type,
			centers: centers.slice(0, quads.count * 3),
			planes: quad_planes(quads),
		},
	};
}

function ensure_capacity<T extends Float32Array<ArrayBuffer> | Uint8Array<ArrayBuffer>>(
	buffer: T,
	required: number,
): T {
	if (required <= buffer.length) return buffer;

	let new_length = buffer.length;
	while (new_length < required) {
		new_length *= 2;
	}

	const new_buffer = new (buffer.constructor as new (length: number) => T)(new_length);
	new_buffer.set(buffer as ArrayLike<number>);
	return new_buffer;
}