package detail

import (
	"math"

	"salty/terrain/internal/field"
	"salty/terrain/internal/manifest"
	"salty/terrain/internal/world"
)

// brush is the 3x3 kernel a droplet's cut goes through, weights summing to one.
//
// A one-cell footprint leaves every droplet path as a rill one cell wide, which reads across the lowlands as
// brush strokes. Deposits are *not* spread through it and land on the droplet's own bilinear cell instead:
// spread through the brush, a pit's rim rises faster than its floor, the pit never fills, and every droplet
// that drains into it adds to the rim until there is a mound.
var brush = [9]struct {
	dx, dy int
	w      float64
}{
	{0, 0, 0.36},
	{0, 1, 0.12}, {0, -1, 0.12}, {1, 0, 0.12}, {-1, 0, 0.12},
	{1, 1, 0.04}, {1, -1, 0.04}, {-1, 1, 0.04}, {-1, -1, 0.04},
}

// Maps are the derivative fields the droplets leave behind: how much water passed, how much bedrock was
// scraped, how much sediment was laid. The layer rules read them - scraped bedrock and convex ridges paint as
// rock, sediment fans and basins as meadow.
type Maps struct {
	Flow, Wear, Deposit []float32
}

func newMaps(n int) *Maps {
	return &Maps{Flow: make([]float32, n), Wear: make([]float32, n), Deposit: make([]float32, n)}
}

// ParticleParams is one particle pass over one tile.
type ParticleParams struct {
	Cfg   manifest.Particle
	Seed  int64
	Frame world.Frame // the tile's cut, at detail resolution: what the hashes are keyed on

	SeaLevelM float64
	Hardness  *Hardness

	// Classes gives each cell its own droplet density, which is the difference between a rain-fed landscape
	// and an arid one: drop it and the dendritic gully network thins to isolated channels.
	Classes *Classes
}

// ParticleStats is what the pass moved, in metres.
type ParticleStats struct {
	Droplets                int
	Rounds                  int
	LargestCut, LargestFill float64
}

// RunParticle erodes a tile in place with hydraulic droplets.
//
// h is in metres and land marks the cells droplets may spawn on. Everything inside works in *cell heights* -
// metres over the cell size - so a slope of 1 is 45 degrees and every constant in the manifest means the same
// thing at any resolution, which is how the numpy was tuned and why the numbers carry across.
//
// Determinism, which is the part that is not a port. The numpy draws spawn cells from an RNG stream; that is
// index-dependent, so a cell would get different droplets depending on which tile it fell in and every seam
// would show. Here a cell's droplet count and every one of their choices is a hash of (seed, world position),
// so a droplet spawned in a tile's interior is bit-identical to the one spawned when that cell falls inside a
// neighbour's margin.
//
// The pass runs in rounds, which is the numpy's batching kept deliberately rather than inherited: droplets
// within a round read the height as it was when the round began and scatter their deltas into per-band
// buffers summed afterwards in band order, so two droplets in one cell in one round do not see each other and
// the result does not depend on which goroutine ran. Feedback - a channel deepening as more water follows it -
// comes from the rounds, not from within one.
func RunParticle(h *field.Field, land []bool, p ParticleParams) (*Maps, ParticleStats) {
	var st ParticleStats
	cellM := h.CellM
	w, ht := h.W, h.H
	maps := newMaps(w * ht)
	cfg := p.Cfg
	if cfg.Lifetime <= 0 || (cfg.DropletsPerCell <= 0 && p.Classes == nil) {
		return maps, st
	}

	// Into cell heights, and back at the end.
	hc := make([]float64, w*ht)
	inv := 1 / cellM
	for i, v := range h.Data {
		hc[i] = float64(v) * inv
	}
	// The numpy spawns on land standing at least two metres clear of the water, which keeps droplets out of
	// the surf zone where they would only churn the beach the coastal pass laid.
	spawnAbove := (p.SeaLevelM + 2) / cellM

	lifetime := cfg.Lifetime
	inertia := cfg.Inertia
	capacityF := cfg.Capacity
	minSlope := cfg.MinSlope
	depositRate := cfg.DepositRate
	erodeRate := cfg.ErodeRate * orOne(cfg.Scale)
	maxChange := cfg.MaxChange * orOne(cfg.Scale)
	evaporation := cfg.Evaporation
	gravity := cfg.Gravity
	maxSpeed := cfg.MaxSpeed
	maxLoad := cfg.MaxLoad
	minErode := math.Max(cfg.MinErodeSlope, 1e-6)
	limit := float64(w) - 2.001
	limitY := float64(ht) - 2.001

	// How many droplets each cell spawns, and therefore how many rounds. Counting first costs one pass over
	// the tile and makes the round count a property of the world rather than of the loop.
	total := 0
	for y := 0; y < ht; y++ {
		for x := 0; x < w; x++ {
			i := y*w + x
			if !land[i] || hc[i] <= spawnAbove {
				continue
			}
			wx, wy := p.Frame.PlanetXY(x, y)
			total += int(p.Classes.droplets(i, cfg.DropletsPerCell) + hashXY(p.Seed, wx, wy, 0))
		}
	}
	if total == 0 {
		return maps, st
	}
	// Rounds comes from the manifest and *not* from the droplet count, which is the one place this departs
	// from the numpy on purpose. Derived from the count it would depend on how big a piece of the world was
	// being worked on, so a droplet would land in a different round in a tile than in the whole map and the
	// seams would not close.
	rounds := cfg.Rounds
	if rounds < 1 {
		rounds = 1
	}
	st.Droplets, st.Rounds = total, rounds

	reach := lifetime + 2 // a droplet steps one cell at a time; the brush adds one more
	// A fixed band size, not one per core: a cell's contributions are summed band by band and floating-point
	// addition is not associative, so a partition that moved with GOMAXPROCS would move the last bit with it.
	const bandRows = 64
	bands := field.FixedBandCount(ht, bandRows)
	type buf struct {
		y0, y1          int // the rows this band may touch
		dh              []float64
		flow, wear, dep []float32
	}
	bufs := make([]buf, bands)

	for round := 0; round < rounds; round++ {
		field.FixedBands(ht, bandRows, func(b, y0, y1 int) {
			lo := y0 - reach
			if lo < 0 {
				lo = 0
			}
			hi := y1 + reach
			if hi > ht {
				hi = ht
			}
			n := (hi - lo) * w
			bf := &bufs[b]
			if len(bf.dh) != n {
				bf.dh = make([]float64, n)
				bf.flow = make([]float32, n)
				bf.wear = make([]float32, n)
				bf.dep = make([]float32, n)
			} else {
				clear(bf.dh)
				clear(bf.flow)
				clear(bf.wear)
				clear(bf.dep)
			}
			bf.y0, bf.y1 = lo, hi

			add := func(x, y int, dh, flow, wear, dep float64) {
				if y < lo || y >= hi || x < 0 || x >= w {
					return
				}
				j := (y-lo)*w + x
				bf.dh[j] += dh
				bf.flow[j] += float32(flow)
				bf.wear[j] += float32(wear)
				bf.dep[j] += float32(dep)
			}

			for y := y0; y < y1; y++ {
				for x := 0; x < w; x++ {
					i := y*w + x
					if !land[i] || hc[i] <= spawnAbove {
						continue
					}
					wx, wy := p.Frame.PlanetXY(x, y)
					count := int(p.Classes.droplets(i, cfg.DropletsPerCell) + hashXY(p.Seed, wx, wy, 0))
					for j := 0; j < count; j++ {
						if int(hashXY(p.Seed, wx, wy, int32(100+j))*float64(rounds)) != round {
							continue
						}
						px := clampF(float64(x)+hashXY(p.Seed, wx, wy, int32(3*j+1)), 1, limit)
						py := clampF(float64(y)+hashXY(p.Seed, wx, wy, int32(3*j+2)), 1, limitY)
						runDroplet(hc, land, w, px, py, dropletConst{
							lifetime: lifetime, inertia: inertia, capacityF: capacityF,
							minSlope: minSlope, depositRate: depositRate, erodeRate: erodeRate,
							maxChange: maxChange, evaporation: evaporation, gravity: gravity,
							maxSpeed: maxSpeed, maxLoad: maxLoad, minErode: minErode,
							limitX: limit, limitY: limitY,
						}, p.Hardness, add)
					}
				}
			}
		})

		// Summed in band order, never drained from a channel: the result must not depend on which goroutine
		// finished first (cross-cutting rule 12).
		for b := range bufs {
			bf := &bufs[b]
			if bf.dh == nil {
				continue
			}
			for y := bf.y0; y < bf.y1; y++ {
				src := (y - bf.y0) * w
				dst := y * w
				for x := 0; x < w; x++ {
					hc[dst+x] += bf.dh[src+x]
					maps.Flow[dst+x] += bf.flow[src+x]
					maps.Wear[dst+x] += bf.wear[src+x]
					maps.Deposit[dst+x] += bf.dep[src+x]
				}
			}
		}
	}

	for i := range h.Data {
		after := float32(hc[i] * cellM)
		if d := float64(after - h.Data[i]); d < st.LargestCut {
			st.LargestCut = d
		} else if d > st.LargestFill {
			st.LargestFill = d
		}
		h.Data[i] = after
	}
	// Wear and deposit are in cell heights; report them in metres like everything else.
	for i := range maps.Wear {
		maps.Wear[i] = float32(float64(maps.Wear[i]) * cellM)
		maps.Deposit[i] = float32(float64(maps.Deposit[i]) * cellM)
	}
	st.LargestCut = -st.LargestCut
	return maps, st
}

type dropletConst struct {
	lifetime                          int
	inertia, capacityF, minSlope      float64
	depositRate, erodeRate, maxChange float64
	evaporation, gravity, maxSpeed    float64
	maxLoad, minErode                 float64
	limitX, limitY                    float64
}

// runDroplet is one droplet's whole life. It reads the height as it was at the start of the round and reports
// what it moved through add; it never writes to the shared map itself.
func runDroplet(h []float64, land []bool, w int, px, py float64, c dropletConst, hard *Hardness,
	add func(x, y int, dh, flow, wear, dep float64)) {

	dx, dy := 0.0, 0.0
	speed, water, sediment := 1.0, 1.0, 0.0

	for step := 0; step < c.lifetime; step++ {
		hcv, gx, gy, x0, y0, fx, fy := sampleBilinear(h, w, px, py)

		dx = dx*c.inertia - gx*(1-c.inertia)
		dy = dy*c.inertia - gy*(1-c.inertia)
		length := math.Hypot(dx, dy)
		if length <= 1e-9 {
			return // standing water: it cannot pick a direction, so it stops
		}
		dx /= length
		dy /= length

		nx, ny := px+dx, py+dy
		inside := nx >= 1 && nx <= c.limitX && ny >= 1 && ny <= c.limitY
		hn, _, _, _, _, _, _ := sampleBilinear(h, w, clampF(nx, 1, c.limitX), clampF(ny, 1, c.limitY))
		dh := 0.0
		if inside {
			dh = hn - hcv
		}

		slope := math.Max(-dh, c.minSlope)
		capacity := math.Min(slope*speed*water*c.capacityF, c.maxLoad)
		hardness := 0.0
		if hard != nil {
			hardness = hard.At(y0*w+x0, hcv)
		}
		// Flat ground resists cutting. The gate has to sit well above the median lowland slope or the
		// meadows come out brushed with rills, which is the lesson 0.25 encodes.
		holds := math.Hypot(gx, gy) / c.minErode
		if holds > 1 {
			holds = 1
		}
		holds *= holds

		deposit, erode := 0.0, 0.0
		if dh > 0 {
			deposit = math.Min(dh, sediment) // uphill: fill the pit it is climbing out of
		} else if sediment > capacity {
			deposit = (sediment - capacity) * c.depositRate
		}
		if dh <= 0 && sediment <= capacity {
			erode = math.Min((capacity-sediment)*c.erodeRate, -dh) * (1 - hardness) * holds
		}

		// The sea is a sink: the droplet drops its whole load at the mouth, which is what makes a fan. It is
		// the land mask that decides, not a height comparison - the sea floor is held at sea level while the
		// detail passes run (the same invariant the solve keeps), so there is no depth to compare against.
		intoSea := false
		if inside {
			nxi, nyi := int(nx+0.5), int(ny+0.5)
			if nxi >= 0 && nxi < w && nyi >= 0 && nyi*w+nxi < len(land) {
				intoSea = !land[nyi*w+nxi]
			}
		}
		if intoSea {
			deposit, erode = sediment, 0
		} else {
			deposit = math.Min(deposit, c.maxChange)
			erode = math.Min(erode, c.maxChange)
		}

		// Neither the cut nor the deposit may touch water. Both stencils straddle the waterline whenever a
		// droplet is within a cell of it, and the sea floor is held at sea level here and put back afterwards,
		// so anything written there would be silently thrown away - sediment that should have built a beach,
		// quietly deleted. The cut is simply skipped, because cutting a sea floor that is a placeholder means
		// nothing; the deposit is given to the droplet's own cell, which is land for as long as it is alive.
		onLand := func(x, y int) bool {
			if x < 0 || x >= w || y < 0 {
				return false
			}
			i := y*w + x
			return i < len(land) && land[i]
		}
		if erode > 0 {
			for _, b := range brush {
				if onLand(x0+b.dx, y0+b.dy) {
					add(x0+b.dx, y0+b.dy, -erode*b.w, 0, 0, 0)
				}
			}
		}
		if deposit > 0 {
			put := func(x, y int, amount float64) {
				if !onLand(x, y) {
					x, y = x0, y0
				}
				add(x, y, amount, 0, 0, 0)
			}
			put(x0, y0, deposit*(1-fx)*(1-fy))
			put(x0+1, y0, deposit*fx*(1-fy))
			put(x0, y0+1, deposit*(1-fx)*fy)
			put(x0+1, y0+1, deposit*fx*fy)
		}
		add(x0, y0, 0, water, erode, deposit)

		sediment += erode - deposit
		speed = math.Min(math.Sqrt(math.Max(0, speed*speed-dh*c.gravity)), c.maxSpeed)
		water *= 1 - c.evaporation

		if !inside || intoSea || water <= 0.001 {
			return
		}
		px, py = nx, ny
	}
}

// sampleBilinear is the height and its gradient at a float position, with the integer cell and the
// fractions the caller needs to scatter back. The caller keeps the position inside [1, size-2].
func sampleBilinear(h []float64, w int, px, py float64) (hc, gx, gy float64, x0, y0 int, fx, fy float64) {
	x0 = int(px)
	y0 = int(py)
	fx = px - float64(x0)
	fy = py - float64(y0)
	i := y0*w + x0
	h00 := h[i]
	h10 := h[i+1]
	h01 := h[i+w]
	h11 := h[i+w+1]
	gx = (h10-h00)*(1-fy) + (h11-h01)*fy
	gy = (h01-h00)*(1-fx) + (h11-h10)*fx
	hc = h00*(1-fx)*(1-fy) + h10*fx*(1-fy) + h01*(1-fx)*fy + h11*fx*fy
	return hc, gx, gy, x0, y0, fx, fy
}

func clampF(v, lo, hi float64) float64 {
	if v < lo {
		return lo
	}
	if v > hi {
		return hi
	}
	return v
}

func orOne(v float64) float64 {
	if v <= 0 {
		return 1
	}
	return v
}

// hashXY is splitmix64's finaliser over the seed and a world position, in [0, 1). The same arithmetic as the
// router's jitter and for the same reason: everything random has to be a hash of where a thing is, never of
// the order it was visited in.
func hashXY(seed int64, x, y int, k int32) float64 {
	h := uint64(seed)*0x9e3779b97f4a7c15 + 0x243f6a8885a308d3
	h ^= uint64(uint32(int32(x)))*0x9e3779b97f4a7c15 +
		uint64(uint32(int32(y)))*0xc2b2ae3d27d4eb4f +
		uint64(uint32(k))*0x165667b19e3779f9
	h ^= h >> 30
	h *= 0xbf58476d1ce4e5b9
	h ^= h >> 27
	h *= 0x94d049bb133111eb
	h ^= h >> 31
	return float64(h>>11) / float64(uint64(1)<<53)
}