/** Skull marker: bounty + decaying kill counter. Magenta-tint color curve. */

export const SKULL_KILL_BONUS = 500;
export const SKULL_DECAY_PER_SECOND = 1;

/**
 * Default skull value at pure black. White→black below this; red lerp (and
 * town-guard hostility) start strictly above it.
 * Overridable via world setting `skullBlackMax`.
 */
export const SKULL_BLACK_MAX_DEFAULT = 500;
/**
 * Default skull value at pure red. Black→red between black max and this;
 * beyond it, tint leans toward dark red.
 * Overridable via world setting `skullRedMax`.
 */
export const SKULL_RED_MAX_DEFAULT = 500_000;

/** @deprecated Use {@link SKULL_BLACK_MAX_DEFAULT}. */
export const SKULL_RED_LERP_START = SKULL_BLACK_MAX_DEFAULT;
/** @deprecated Use {@link SKULL_RED_MAX_DEFAULT}. */
export const SKULL_PURE_RED_VALUE = SKULL_RED_MAX_DEFAULT;
/** @deprecated Dark-red clamp is derived as 2× red max. */
export const SKULL_DARK_RED_VALUE = SKULL_RED_MAX_DEFAULT * 2;

/**
 * @param {number} bountyCopper
 * @param {number} killCounter
 */
export function skullValue (bountyCopper, killCounter)
{
	return Math.max(0, Math.floor(Number(bountyCopper) || 0) + Math.floor(Number(killCounter) || 0));
}

/**
 * Resolve tint / guard thresholds from world settings (falls back to defaults).
 * @param {{ skullBlackMax?: number, skullRedMax?: number } | null | undefined} settings
 */
export function resolveSkullThresholds (settings = null)
{
	const blackMax = Math.max(
		1,
		Math.floor(Number(settings?.skullBlackMax) || SKULL_BLACK_MAX_DEFAULT)
	);
	let redMax = Math.max(
		1,
		Math.floor(Number(settings?.skullRedMax) || SKULL_RED_MAX_DEFAULT)
	);
	if (redMax <= blackMax)
	{ redMax = blackMax + 1; }
	return {
		blackMax,
		redMax,
		darkRedMax: redMax * 2
	};
}

/**
 * True once the skull tint starts lerping from black toward red
 * (skull value strictly above black max).
 * @param {number} value
 * @param {{ skullBlackMax?: number, skullRedMax?: number } | null | undefined} [settings]
 */
export function skullAttractsTownGuards (value, settings = null)
{
	const { blackMax } = resolveSkullThresholds(settings);
	return Math.max(0, Math.floor(Number(value) || 0)) > blackMax;
}

/**
 * Decay kill counter by elapsed wall time (1 point / second).
 * @returns {{ killCounter: number, consumedMs: number }}
 */
export function decayKillCounter (killCounter, elapsedMs)
{
	const current = Math.max(0, Number(killCounter) || 0);
	if (current <= 0 || !(elapsedMs > 0))
	{ return { killCounter: current, consumedMs: 0 }; }
	const decay = Math.min(current, Math.floor(elapsedMs / 1000) * SKULL_DECAY_PER_SECOND);
	return {
		killCounter: current - decay,
		consumedMs: decay * 1000
	};
}

function lerp (a, b, t)
{
	return a + (b - a) * t;
}

/**
 * Magenta-tint target color for a skull value (0 = invisible / unused).
 * 1…blackMax → white→black; …→ pure red at redMax; then → dark red (128,0,0).
 * @param {number} value
 * @param {{ skullBlackMax?: number, skullRedMax?: number } | null | undefined} [settings]
 * @returns {{ r: number, g: number, b: number } | null} 0–1 channels, or null if invisible
 */
export function skullTintColor (value, settings = null)
{
	const v = Math.max(0, Math.floor(Number(value) || 0));
	if (v <= 0)
	{ return null; }
	const { blackMax, redMax, darkRedMax } = resolveSkullThresholds(settings);
	if (v <= blackMax)
	{
		const t = v / blackMax;
		const c = lerp(1, 0, t);
		return Object.freeze({ r: c, g: c, b: c });
	}
	if (v <= redMax)
	{
		// Black (0,0,0) → pure red (1,0,0).
		const t = (v - blackMax) / (redMax - blackMax);
		return Object.freeze({
			r: lerp(0, 1, t),
			g: 0,
			b: 0
		});
	}
	const t = Math.min(1, (v - redMax) / (darkRedMax - redMax));
	const dark = 128 / 255;
	return Object.freeze({
		r: lerp(1, dark, t),
		g: 0,
		b: 0
	});
}
