// Package uplift builds what the fluvial solve integrates: a rock uplift rate field in metres per year, an
// erodibility field, a continent mask that says where the sea is, and a small initial relief to break the
// symmetry.
//
// This is heightmap_noise.generate_metres turned inside out (D-47). The numpy version produced the terrain:
// ranges to 2600 m, foothills, plains, and erosion was applied to it afterwards as decoration. Here the same
// shapes produce an uplift *rate*, and the terrain is whatever the stream-power solve makes of it. The
// percentile thresholding is kept exactly, because it is what makes the result seed-independent.
//
// The coast is kept (D-48). Sea level is the base level on every ocean cell, which is a far better-posed
// boundary for the solve than a single outlet edge and removes the artificial divide a one-outlet map has
// along three of its sides. This package decides *where* the coastline runs and nothing else about it; what
// the shoreline and the sea floor then look like belongs to package coast, which runs after the solve.
//
// # Why the plains need their own uplift, and not a flat one
//
// The first version gave the whole intraplate interior one uniform rate, 0.2 mm/yr against a convergent
// 5 mm/yr. That produced a table-flat green void with a polygonal river network scribbled across it, and the
// network was an artifact rather than drainage. Two reasons, and they are the same reason twice:
//
//   - Steady state is S = U/(K*A^m). On a plain A is large and U was tiny, so S collapsed to nothing.
//   - Uniform uplift over a wide area produces no *divides*. With no divides there is no drainage to find,
//     so the router fell back on the only gradient present, which was the priority-flood's millimetre of
//     epsilon, and drew the flood's own traversal geometry as rivers.
//
// Real intraplate regions are not uniform. They warp gently over tens of kilometres into swells and sags, and
// that warping is what puts divides on a plain. So the intraplate rate is modulated by a long-wavelength
// field.
//
// # And why the rate itself must stay low
//
// The first attempt at the above did the right thing and then overdid it: the plains were lifted to
// 0.25-0.9 mm/yr, on the reasoning that a higher rate sustains more relief against K. It does, but relief is
// not the quantity that was in trouble. Steady state is S = U/(K*A^m), and with no critical area that holds
// down to a single cell, so every divide stands at A = cell² whatever else is true of it. At the defaults
// that made 0.25 mm/yr a 32 degree hillslope and 0.9 mm/yr one past the angle of repose — so the repose clamp,
// which is meant to be a mountain process, became the surface of the whole continent. Measured: 81 % of the
// land fell in the >0.5 mm/yr class and the plains held 1 %.
//
// The lesson is that U and S are not two knobs. For n = 1, U alone fixes the hillslope angle at a given A,
// and the only things that make a plain flat are a low U or a large A. So the intraplate rate is an order of
// magnitude lower than it was and the *variation* carries the divides, which is what it was for. The
// mountain-to-plain ratio is 30-fold and up, which is what real ones are.
//
// # Where the land ends does not decide how fast it is rising
//
// The uplift rate used to be multiplied by the continent mask, which is a smoothstep, so it tapered to zero
// across the shore. That made every coastline on the map the lowest-uplift ground on the map, by construction
// and whatever the tectonics said — and since steady state is S = U/(K*A^m), ground with no uplift grades to
// no slope, so every coast was a plain. It is why the coastal pass measured a mean sea cliff of two metres
// while working perfectly: there was nothing anywhere on the map for the surf to cut into.
//
// The two questions are not the same question. The mask answers "is this cell sea", which is a yes or a no and
// is what the solve needs for its base level. The uplift field answers "how fast is this rock rising", and a
// range that happens to run out to the water is rising at range rates right up to the waterline — which is
// what Big Sur, the Norwegian west coast and the Great Australian Bight all are. So the mask is thresholded
// rather than multiplied, and whether a given coast is a cliff or a plain is now decided by where the range
// band falls relative to the coastline, which is exactly the sort of thing that should be decided by the
// tectonics and not by a smoothstep.
package uplift

import (
	"math"

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

type Result struct {
	Rate   *field.Field // rock uplift, metres per year
	Height *field.Field // initial relief, metres; ocean cells sit at sea level and stay there for the solve
	Land   *field.Field // continent mask, 0 at sea, 1 inland
	K      *field.Field // erodibility multiplier from the lithology pass, around 1
	Base   []bool       // cells fixed at base level: the ocean

	Faults []Fault

	// FaultClamped is how many cells the painted path's fault pass pushed past the angle of repose and had
	// to bound. Nonzero is not an error - it is the set telling an author their throws are large for the
	// class they sit in - but it is worth seeing rather than discovering in a hillshade.
	FaultClamped int
}

// Fault is a recorded trace, kept for meta.json and for whatever later wants to draw one.
type Fault struct {
	Points  [][2]float64 `json:"points"` // map coordinates, 0..1
	ThrowM  float64      `json:"throw_m"`
	Major   bool         `json:"major"`
	Reverse bool         `json:"reverse"` // which side goes up
}

// seaThreshold is where the continent mask stops being land. The mask is a smoothstep, so it has a ramp, and
// this is the one place that ramp is turned into the yes-or-no answer the solve needs: a cell is either an
// ocean cell held at base level or it is not.
//
// It is a named constant rather than a literal in two loops because the rate field and the height field have
// to agree about it exactly. If they ever disagreed, a cell would be uplifted and then pinned at base level,
// or held at sea level while taking no uplift, and neither would be visible in anything a run prints.
const seaThreshold = 0.02

// Pass indices for the seeded sources. Fixed and never reordered: a pass keeps its own stream so that
// inserting a later pass does not reshuffle the ones before it (cross-cutting rule 12).
const (
	srcContinent = 1
	srcWarp      = 2
	srcBand      = 3
	srcRidges    = 4
	srcCrests    = 5
	srcRelief    = 6
	srcSwell     = 7
	srcFaults    = 8
	srcLithology = 9
)

// Build produces the geology-grid inputs at size x size.
func Build(size int, cellM float64, m *manifest.Manifest) *Result {
	seed := m.Source.Seed
	cfg := m.Pipeline
	sideM := float64(size-1) * cellM
	u, v := noise.Identity(size)

	// A low-frequency warp bends everything that follows, so ridges curve and ranges are not blobs.
	ws := noise.NewSource(seed, srcWarp)
	wx := noise.FBM(size, ws, noise.Params{BaseCells: 3, Octaves: 3, Gain: 0.5})
	wy := noise.FBM(size, ws, noise.Params{BaseCells: 3, Octaves: 3, Gain: 0.5})

	land := continentMask(size, u, v, wx, wy, seed, cfg.Continent)

	// Ranges: an elongated, warped band says where they run, stretched across its grain so they come as long
	// chains rather than patches. Thresholded by percentile, not by value, which is the whole trick.
	bs := noise.NewSource(seed, srcBand)
	angle := bs.Range(0, math.Pi)
	cos, sin := math.Cos(angle), math.Sin(angle)
	bu := field.NewLike(u)
	bv := field.NewLike(v)
	for i := range bu.Data {
		x := float64(u.Data[i]) - 0.5
		y := float64(v.Data[i]) - 0.5
		along := x*cos + y*sin
		across := -x*sin + y*cos
		bu.Data[i] = float32(0.5 + along*0.7 + float64(wx.Data[i]-0.5)*0.32)
		bv.Data[i] = float32(0.5 + across*2.2 + float64(wy.Data[i]-0.5)*0.32)
	}
	band := noise.FBMAt(bu, bv, bs, noise.Params{BaseCells: 3, Octaves: 3, Gain: 0.5})
	rangeMask := percentileMask(band, cfg.Plates.LowUpliftFraction.Hi()*100, 86)

	// The regional swell: long-wavelength warping of the intraplate interior, which is what puts divides on
	// a plain. Without it the lowlands have no drainage of their own and the flood's epsilon decides where
	// the water goes.
	ss := noise.NewSource(seed, srcSwell)
	swu, swv := noise.Warp(u, v, wx, wy, 0.10)
	swell := noise.FBMAt(swu, swv, ss, noise.Params{BaseCells: 2, Octaves: 4, Gain: 0.5})
	swell.Normalise()

	// Rock uplift in metres per year.
	intraLo := cfg.Plates.IntraplateMmYr / 1000
	intraHi := cfg.Plates.IntraplateSwellMmYr / 1000
	if intraHi < intraLo {
		intraHi = intraLo
	}
	convergent := cfg.Plates.ConvergentMmYr.Hi() / 1000
	rate := field.New(size, size, cellM)
	for i := range rate.Data {
		if land.Data[i] <= seaThreshold {
			// Ocean. The rate is zeroed for the sake of map_uplift and the statistics; the solve does not
			// need it, because a base cell is fixed and StreamPower skips it before it reads the rate.
			rate.Data[i] = 0
			continue
		}
		base := intraLo + (intraHi-intraLo)*float64(swell.Data[i])
		rate.Data[i] = float32(base + (convergent-base)*float64(rangeMask.Data[i]))
	}

	faults := buildFaults(rate, u, v, seed, angle, sideM, cfg.Faults, cfg.Plates.ConvergentMmYr.Hi()/1000,
		float64(cfg.Fluvial.Steps)*cfg.Fluvial.DtYr)

	// Lithology: a plan-view erodibility field. It is what stops every ridge in a range looking like every
	// other ridge, because a hard band resists and a soft one is cut away.
	k := lithology(size, cellM, u, v, wx, wy, seed, cfg.Lithology)

	// Initial relief: small on purpose. The spec says 50-150 m x normalised uplift and it means it; the
	// solve is what produces relief, and handing it 2600 m of ridged noise means it spends its whole run
	// tearing that down instead of carving.
	rs := noise.NewSource(seed, srcRidges)
	wu, wv := noise.Warp(u, v, wx, wy, 0.16)
	ridges := noise.FBMAt(wu, wv, rs, noise.Params{BaseCells: 5, Octaves: 6, Gain: 0.42, Ridged: true})
	ridges.Normalise()
	cs := noise.NewSource(seed, srcCrests)
	cu, cv := noise.Warp(u, v, wx, wy, 0.224) // the stronger warp the crest lines need
	crests := noise.CellularEdges(cu, cv, cs, 14, 0.95)

	ps := noise.NewSource(seed, srcRelief)
	plains := noise.FBM(size, ps, noise.Params{BaseCells: 6, Octaves: 4, Gain: 0.45})

	ampLo := cfg.Relief.AmplitudeM.Lo()
	ampHi := cfg.Relief.AmplitudeM.Hi()
	crestW := cfg.Relief.CrestWeight
	maxRate := convergent
	if maxRate <= 0 {
		maxRate = 1
	}
	height := field.New(size, size, cellM)
	base := make([]bool, size*size)
	for i := range height.Data {
		if land.Data[i] <= seaThreshold {
			// Ocean: base level, fixed, never eroded, never uplifted, and held at sea level for the whole
			// solve. The sea floor is not laid here and deliberately not laid *yet* — a coastal cell drains
			// into an ocean cell, and if that cell already sat at -180 m the solver would cut the river down
			// to -180 m, because that is the base level it was handed. The first run with a coast eroded the
			// land to 174 m below sea level for exactly that reason. Package coast lays the sea floor after
			// the solve, where it also has the relief it needs to decide how wide the shelf is.
			height.Data[i] = float32(m.SeaLevelM)
			base[i] = true
			continue
		}
		norm := float64(rate.Data[i]) / maxRate // normalised uplift, 0..1
		amp := ampLo + (ampHi-ampLo)*norm
		shape := (1-crestW)*float64(ridges.Data[i]) + crestW*float64(crests.Data[i])
		height.Data[i] = float32(m.SeaLevelM + 20 + amp*shape + float64(plains.Data[i])*8)
	}

	return &Result{Rate: rate, Height: height, Land: land, K: k, Base: base, Faults: faults}
}

// percentileMask thresholds a field between two percentiles and smoothsteps between them, so the fraction of
// the map it covers is the same whatever the seed.
func percentileMask(f *field.Field, loPct, hiPct float64) *field.Field {
	lo := f.Percentile(loPct)
	hi := f.Percentile(hiPct)
	span := float64(hi - lo)
	if span < 1e-6 {
		span = 1e-6
	}
	out := field.NewLike(f)
	for i, b := range f.Data {
		t := (float64(b) - float64(lo)) / span
		if t < 0 {
			t = 0
		} else if t > 1 {
			t = 1
		}
		out.Data[i] = float32(noise.Smoothstep(t))
	}
	return out
}

// continentMask is the coast. A radial falloff with noise added to the radius gives a disc with a wobbly
// edge, which is what the first version did and what it looked like. Instead a warped multi-octave field is
// biased radially and then thresholded at the percentile that yields the wanted land fraction: the coastline
// gets bays, peninsulas and offshore deeps, and the land area is still the same whatever the seed.
func continentMask(size int, u, v, wx, wy *field.Field, seed int64, cfg manifest.Continent) *field.Field {
	out := field.New(size, size, 1)
	if !cfg.Enabled {
		out.Fill(1)
		return out
	}
	s := noise.NewSource(seed, srcContinent)
	cx := 0.5 + (s.Float()-0.5)*0.12
	cy := 0.5 + (s.Float()-0.5)*0.12

	// Strong domain warp, so the shape is not obviously built from a circle.
	//
	// The octave count is the coastline's own detail and it is a manifest key because it is the one number
	// that decides whether the continent has a coast or an outline: five octaves over this map is a 450 m
	// finest feature, which is a smooth blob, and everything downstream that asks "is this stretch sheltered"
	// then answers "no" everywhere. Gain stays at 0.5 rather than the 0.42 the *relief* noise uses, because
	// this field is thresholded at a percentile rather than read as a height, so a steep spectrum costs
	// nothing here and is what makes the shoreline crenellate.
	cu, cv := noise.Warp(u, v, wx, wy, cfg.CoastWarp)
	octaves := cfg.OutlineOctaves
	if octaves < 1 {
		octaves = 5
	}
	gain := cfg.OutlineGain
	if gain <= 0 {
		gain = 0.5
	}
	shape := noise.FBMAt(cu, cv, s, noise.Params{BaseCells: 2, Octaves: octaves, Gain: gain})

	// The radial term only biases the field towards the middle; it does not define the edge.
	score := field.New(size, size, 1)
	for i := range score.Data {
		x := float64(u.Data[i]) - cx
		y := float64(v.Data[i]) - cy
		radius := math.Hypot(x*1.05, y*0.95) / cfg.Radius
		score.Data[i] = float32(float64(shape.Data[i]) - cfg.RadialBias*radius*radius)
	}

	// The threshold that yields the wanted land fraction, read off the distribution.
	seaPct := (1 - cfg.LandFraction) * 100
	lo := score.Percentile(seaPct)
	hi := score.Percentile(math.Min(99.9, seaPct+cfg.ShoreWidthPct))
	span := float64(hi - lo)
	if span < 1e-6 {
		span = 1e-6
	}
	for i, sc := range score.Data {
		t := (float64(sc) - float64(lo)) / span
		if t < 0 {
			t = 0
		} else if t > 1 {
			t = 1
		}
		out.Data[i] = float32(noise.Smoothstep(t))
	}

	// The last few percent of the map is forced to sea, so land never touches the edge.
	//
	// This is not cosmetic. A border cell is an outlet: it takes no uplift, is never eroded, and the repose
	// clamp will not lower it either, so any land that reaches the edge is frozen at whatever height the
	// initial relief gave it while the interior erodes away beneath it. The result is a rim of untouched
	// terrain standing over a hundred metres above its neighbour — which is exactly what the repose test
	// found when it reported a 66 degree slope on a map whose angle of repose was 22. Percentile
	// thresholding picks the lowest fraction of the *score* and has no reason to put it at the edges, so the
	// margin has to be imposed.
	const marginFrac = 0.04
	for i := range out.Data {
		x := float64(i%size) / float64(size-1)
		y := float64(i/size) / float64(size-1)
		d := math.Min(math.Min(x, 1-x), math.Min(y, 1-y))
		if d < marginFrac {
			out.Data[i] *= float32(noise.Smoothstep(math.Max(0, d/marginFrac)))
		}
	}
	return out
}

// lithology is the spec's 4.3: low-frequency noise thresholded into a few rock types, each with its own
// erodibility. Plan view, and orthogonal to the strata model that scales the particle pass by depth.
func lithology(size int, cellM float64, u, v, wx, wy *field.Field, seed int64, cfg manifest.Lithology) *field.Field {
	out := field.New(size, size, cellM)
	if cfg.Types <= 1 || len(cfg.KMultipliers) == 0 {
		out.Fill(1)
		return out
	}
	s := noise.NewSource(seed, srcLithology)
	lu, lv := noise.Warp(u, v, wx, wy, 0.18)
	f := noise.FBMAt(lu, lv, s, noise.Params{BaseCells: 3, Octaves: 4, Gain: 0.5})

	n := cfg.Types
	if n > len(cfg.KMultipliers) {
		n = len(cfg.KMultipliers)
	}
	// Equal-area bands, so every rock type actually appears whatever the seed.
	edges := make([]float32, n-1)
	for i := 1; i < n; i++ {
		edges[i-1] = f.Percentile(float64(i) / float64(n) * 100)
	}
	for i, val := range f.Data {
		t := 0
		for t < len(edges) && val > edges[t] {
			t++
		}
		out.Data[i] = float32(cfg.KMultipliers[t])
	}
	// Softened, so a boundary is a transition rather than a wall the solver carves into a cliff.
	return out.Blur(2)
}

// buildFaults perturbs the uplift field across a set of traces. Normal faults are applied as an uplift-rate
// *difference* across the trace, steep on one side and gentle on the other, and erosion then carves the
// escarpment; that is the spec's 4.2 and it is why a fault reads as landscape rather than as a drawn line.
//
// Orientation follows the range grain rather than being random, because a fault set that ignores the
// structure it belongs to looks like scratches.
func buildFaults(rate, u, v *field.Field, seed int64, grainAngle, sideM float64,
	cfg manifest.Faults, convergent, runYears float64) []Fault {
	s := noise.NewSource(seed, srcFaults)
	if runYears <= 0 {
		runYears = 1.5e6
	}

	nMajor := int(cfg.Major.Pick(s.Float()) + 0.5)
	nMinor := int(cfg.Minor.Pick(s.Float()) + 0.5)
	faults := make([]Fault, 0, nMajor+nMinor)

	for i := 0; i < nMajor+nMinor; i++ {
		major := i < nMajor
		lengthM := cfg.LengthKm.Pick(s.Float()) * 1000
		if major {
			lengthM = math.Max(lengthM, cfg.LengthKm.Hi()*1000*0.6)
		}
		throw := cfg.ThrowMinorM.Pick(s.Float())
		if major {
			throw = cfg.ThrowMajorM.Pick(s.Float())
		}
		// Parallel to the grain, with a little scatter: never a random orientation.
		a := grainAngle + (s.Float()-0.5)*0.6
		cx, cy := s.Float(), s.Float()
		half := lengthM / sideM / 2

		// A polyline, gently curved by low-frequency wander rather than a straight segment.
		const segs = 8
		pts := make([][2]float64, segs+1)
		wander := (s.Float() - 0.5) * 0.5
		for j := 0; j <= segs; j++ {
			t := float64(j)/segs*2 - 1 // -1..1
			off := wander * (1 - t*t)  // zero at the tips, largest in the middle
			px := cx + math.Cos(a)*half*t - math.Sin(a)*half*off
			py := cy + math.Sin(a)*half*t + math.Cos(a)*half*off
			pts[j] = [2]float64{px, py}
		}
		faults = append(faults, Fault{Points: pts, ThrowM: throw, Major: major, Reverse: s.Float() < 0.5})
	}

	// Throw is a total displacement over the run, so it becomes a rate the solve can integrate.
	steepM := 200.0
	gentleM := 2000.0
	field.Rows(rate.H, func(y0, y1 int) {
		for y := y0; y < y1; y++ {
			for x := 0; x < rate.W; x++ {
				i := y*rate.W + x
				px := float64(u.Data[i])
				py := float64(v.Data[i])
				var delta float64
				for _, f := range faults {
					d, inside := signedDistance(px, py, f.Points)
					if !inside {
						continue
					}
					dm := d * sideM
					sign := 1.0
					if f.Reverse {
						sign = -1
					}
					// Steep side falls off fast, gentle side slowly: an asymmetric block, not a ridge.
					var w float64
					if dm*sign >= 0 {
						w = math.Exp(-math.Abs(dm) / steepM)
					} else {
						w = -math.Exp(-math.Abs(dm) / gentleM)
					}
					delta += f.ThrowM / runYears * w
				}
				if delta != 0 {
					r := float64(rate.Data[i]) + delta
					if r < 0 {
						r = 0
					}
					if r > convergent*1.6 {
						r = convergent * 1.6
					}
					rate.Data[i] = float32(r)
				}
			}
		}
	})
	return faults
}

// signedDistance is the perpendicular distance from a point to a polyline, signed by which side it falls on,
// in map units. inside is false beyond the ends, where a fault has no effect.
func signedDistance(px, py float64, pts [][2]float64) (float64, bool) {
	best := math.Inf(1)
	sign := 1.0
	found := false
	for j := 0; j+1 < len(pts); j++ {
		ax, ay := pts[j][0], pts[j][1]
		bx, by := pts[j+1][0], pts[j+1][1]
		dx, dy := bx-ax, by-ay
		l2 := dx*dx + dy*dy
		if l2 < 1e-12 {
			continue
		}
		t := ((px-ax)*dx + (py-ay)*dy) / l2
		if t < 0 || t > 1 {
			continue // beyond this segment; a neighbouring one may still claim the point
		}
		found = true
		projx, projy := ax+t*dx, ay+t*dy
		d := math.Hypot(px-projx, py-projy)
		if d < best {
			best = d
			// Cross product decides the side.
			if (px-ax)*dy-(py-ay)*dx < 0 {
				sign = -1
			} else {
				sign = 1
			}
		}
	}
	if !found {
		return 0, false
	}
	return best * sign, true
}