/** Shared lighting raycast and falloff — used by server bake and client dynamic lights. */

import { LightOcclusion } from "../definitions/tiles.js";

export function bresenhamTiles (x0, y0, x1, y1)
{
	const tiles = [];
	let x = x0;
	let y = y0;
	const dx = Math.abs(x1 - x0);
	const dy = Math.abs(y1 - y0);
	const sx = x0 < x1 ? 1 : -1;
	const sy = y0 < y1 ? 1 : -1;
	let err = dx - dy;

	while (true)
	{
		tiles.push({ x, y });
		if (x === x1 && y === y1)
		{ break; }

		const e2 = 2 * err;
		if (e2 > -dy)
		{
			err -= dy;
			x += sx;
		}
		if (e2 < dx)
		{
			err += dx;
			y += sy;
		}
	}
	return tiles;
}

/**
 * Binary LOS for combat / legacy callers (`true` = clear).
 * Destination may be blocked and still "reached" (facing surface).
 */
export function rayReaches (fromX, fromY, toX, toY, isClear)
{
	const ray = evaluateLightRay(fromX, fromY, toX, toY, (x, y) =>
		(isClear(x, y) ? LightOcclusion.clear : LightOcclusion.solid));
	return ray.reaches;
}

/**
 * Light transmission along a Bresenham ray.
 * @param {(x: number, y: number) => number} occlusionAt
 *        {@link LightOcclusion.clear|partial|solid}
 * @returns {{ reaches: boolean, extraDistance: number }}
 *          `extraDistance` is added to geometric hypot for falloff (partial tiles
 *          cost +1 each, i.e. that step falls off twice as fast).
 */
export function evaluateLightRay (fromX, fromY, toX, toY, occlusionAt)
{
	if (fromX === toX && fromY === toY)
	{
		return {
			reaches: occlusionAt(toX, toY) !== LightOcclusion.solid,
			extraDistance: 0
		};
	}

	const tiles = bresenhamTiles(fromX, fromY, toX, toY);
	let extraDistance = 0;
	// Only tiles strictly between source and target can occlude / add penalty.
	for (let i = 1; i < tiles.length - 1; i++)
	{
		const level = occlusionAt(tiles[i].x, tiles[i].y) | 0;
		if (level >= LightOcclusion.solid)
		{ return { reaches: false, extraDistance: 0 }; }
		if (level === LightOcclusion.partial)
		{ extraDistance += 1; }
	}
	return { reaches: true, extraDistance };
}

export function falloffAtDistance (dist, range)
{
	if (range <= 0 || dist > range)
	{ return 0; }

	const t = 1 - dist / range;
	return t * t * (3 - 2 * t);
}

export function encodeLight (dist, range)
{
	const falloff = falloffAtDistance(dist, range);
	if (falloff <= 0)
	{ return 0; }

	return Math.max(1, Math.round(255 * falloff));
}

export function lightIntensity (encoded)
{
	return Math.min(1, Math.max(0, (encoded ?? 0) / 255));
}

/**
 * Best dynamic light at a tile (0–1).
 * @param {Array<{ tileX: number, tileY: number, range: number, intensity?: number }>} sources
 * @param {(x: number, y: number) => number|boolean} occlusionAt
 *        LightOcclusion level, or legacy boolean (`true` = clear).
 */
export function dynamicLightAtTile (tileX, tileY, sources, occlusionAt)
{
	const occlude = normalizeOcclusionFn(occlusionAt);
	let best = 0;
	for (const source of sources)
	{
		const geo = Math.hypot(tileX - source.tileX, tileY - source.tileY);
		const ray = evaluateLightRay(source.tileX, source.tileY, tileX, tileY, occlude);
		if (!ray.reaches)
		{ continue; }
		const dist = geo + ray.extraDistance;
		if (dist > source.range)
		{ continue; }
		best = Math.max(best, falloffAtDistance(dist, source.range) * (source.intensity ?? 1));
	}
	return best;
}

function normalizeOcclusionFn (occlusionAt)
{
	return (x, y) =>
	{
		const value = occlusionAt(x, y);
		if (value === true)
		{ return LightOcclusion.clear; }
		if (value === false)
		{ return LightOcclusion.solid; }
		return value | 0;
	};
}
