using System;
using System.Collections.Generic;
using Sandbox;

namespace RedSnail.FloraTool;

/// <summary>
/// Turns painted coverage into concrete instances. Everything here is a pure function of the chunk
/// coordinate, the cell contents and the seed - no state, no RNG object - so a chunk regenerates
/// identically every run, on every machine, however many times it is streamed in and out.
/// </summary>
public static class FloraGenerator
{
	public readonly record struct Instance(int EntryIndex, Vector3 Position, Rotation Rotation, float Scale)
	{
		public readonly Transform ToTransform() => new(Position, Rotation, Scale);
	}

	/// <summary>
	/// Integer avalanche hash. Deterministic across runs and platforms, which the framework RNG is
	/// not guaranteed to be, and cheap enough to call several times per instance.
	/// </summary>
	private static uint Hash(uint x)
	{
		x ^= x >> 16;
		x *= 0x7feb352du;
		x ^= x >> 15;
		x *= 0x846ca68bu;
		x ^= x >> 16;
		return x;
	}

	private static float HashFloat(uint x) => Hash(x) * (1.0f / 4294967296.0f);

	/// <summary>
	/// Generates every instance for one chunk, appending into <paramref name="results"/>.
	/// </summary>
	public static void GenerateChunk(FloraStorage.ChunkCoord coord, FloraStorage.Cell[] cells,
		FloraDefinition definition, int seed, List<Instance> results)
	{
		if (cells is null || definition is null)
			return;

		var origin = FloraStorage.ChunkOrigin(coord);
		var maxPerCell = Math.Max(definition.MaxPerCell, 1);

		// Mixing the chunk coordinate into the seed keeps neighbouring chunks from sharing a
		// sequence, which would otherwise show up as a visible repeating pattern across the world.
		var chunkSeed = Hash((uint)seed
			^ Hash((uint)coord.X * 73856093u)
			^ Hash((uint)coord.Y * 19349663u));

		for (var cellIndex = 0; cellIndex < cells.Length; cellIndex++)
		{
			var cell = cells[cellIndex];

			var density = cell.Density;
			if (density <= 0.0f)
				continue;

			if (cell.Normal.z < definition.SlopeLimit)
				continue;

			var cellSeed = Hash(chunkSeed ^ Hash((uint)cellIndex * 0x9e3779b9u));

			var cx = cellIndex % FloraStorage.ChunkResolution;
			var cy = cellIndex / FloraStorage.ChunkResolution;

			var cellMinX = origin.x + cx * FloraStorage.CellSize;
			var cellMinY = origin.y + cy * FloraStorage.CellSize;

			// Fractional counts are resolved by a hash rather than rounding, so density reads as a
			// smooth thinning across a field instead of stepping between whole numbers per cell.
			var exact = density * maxPerCell;
			var count = (int)exact;
			if (HashFloat(cellSeed ^ 0x1b56c4e9u) < exact - count)
				count++;

			for (var i = 0; i < count; i++)
			{
				var s = Hash(cellSeed + (uint)i * 0x85ebca6bu);

				var entry = ResolveEntry(definition, cell.EntryIndex, s);
				if (entry.Index < 0)
					continue;

				results.Add(BuildInstance(entry.Index, entry.Entry, cell, s, cellMinX, cellMinY));
			}
		}
	}

	/// <summary>
	/// A cell either names its entry - painted deliberately with one species selected - or defers to
	/// the definition's weights.
	/// </summary>
	private static (int Index, FloraEntry Entry) ResolveEntry(FloraDefinition definition, int cellEntryIndex, uint seed)
	{
		var entries = definition.Entries;
		if (entries is null || entries.Count == 0)
			return (-1, null);

		if (cellEntryIndex < entries.Count)
		{
			var named = entries[cellEntryIndex];
			return named?.HasModel is true ? (cellEntryIndex, named) : (-1, null);
		}

		var total = 0.0f;
		for (var i = 0; i < entries.Count; i++)
		{
			if (entries[i]?.HasModel is true && entries[i].Weight > 0.0f)
				total += entries[i].Weight;
		}

		if (total <= 0.0f)
			return (-1, null);

		var pick = HashFloat(seed ^ 0x3c6ef372u) * total;

		for (var i = 0; i < entries.Count; i++)
		{
			var entry = entries[i];
			if (entry?.HasModel is not true || entry.Weight <= 0.0f)
				continue;

			pick -= entry.Weight;
			if (pick <= 0.0f)
				return (i, entry);
		}

		return (-1, null);
	}

	private static Instance BuildInstance(int entryIndex, FloraEntry entry, FloraStorage.Cell cell,
		uint seed, float cellMinX, float cellMinY)
	{
		var jitterX = HashFloat(seed ^ 0x68bc21ebu);
		var jitterY = HashFloat(seed ^ 0x02e5be93u);

		var x = cellMinX + jitterX * FloraStorage.CellSize;
		var y = cellMinY + jitterY * FloraStorage.CellSize;

		var normal = cell.Normal;

		// The baked height is the cell centre's, so a slope needs the offset carried across to the
		// jittered position or trunks float on the uphill side and sink on the downhill one.
		var offsetX = x - (cellMinX + FloraStorage.CellSize * 0.5f);
		var offsetY = y - (cellMinY + FloraStorage.CellSize * 0.5f);
		var z = cell.Height - (normal.x * offsetX + normal.y * offsetY) / MathF.Max(normal.z, 0.1f);

		var position = new Vector3(x, y, z);
		if (entry.SinkDepth > 0.0f)
			position -= normal * entry.SinkDepth;

		var rotation = entry.RandomYaw
			? Rotation.FromYaw(HashFloat(seed ^ 0x7f4a7c15u) * 360.0f)
			: Rotation.Identity;

		if (entry.AlignToNormal > 0.0f)
		{
			var aligned = Rotation.LookAt(normal) * Rotation.FromPitch(90.0f);
			rotation = Rotation.Slerp(rotation, aligned * rotation, entry.AlignToNormal);
		}

		if (entry.RandomTilt > 0.0f)
		{
			var tiltAngle = HashFloat(seed ^ 0x165667b1u) * entry.RandomTilt;
			var tiltDirection = HashFloat(seed ^ 0x27d4eb2fu) * 360.0f;
			rotation *= Rotation.FromAxis(Rotation.FromYaw(tiltDirection).Forward, tiltAngle);
		}

		var scale = MathX.Lerp(entry.Scale.Min, entry.Scale.Max, HashFloat(seed ^ 0xd3a2646cu));

		return new Instance(entryIndex, position, rotation, scale);
	}
}