// Package planet is the driver for a painted world: template in, terrain out.
//
// It owns the order of operations and nothing else. The image and its legend belong to internal/template,
// the cylinder to internal/world, the cutting up to internal/region, and every physical process to the
// packages that already had it. What lives here is the sequence, the reporting, and the two things that are
// only true of a whole planet: that its open ocean is painted rather than solved, and that its statistics
// pool across regions rather than being computed per region and averaged.
package planet

import (
	"fmt"
	"math"
	"os"
	"path/filepath"
	"strconv"
	"time"

	"salty/terrain/internal/field"
	"salty/terrain/internal/manifest"
	"salty/terrain/internal/overlay"
	"salty/terrain/internal/plates"
	"salty/terrain/internal/region"
	"salty/terrain/internal/template"
	"salty/terrain/internal/uplift"
	"salty/terrain/internal/world"
)

// Inputs is everything a bake needs before a single erosion step has run: the painted map classified and
// projected onto the cylinder, and the cylinder cut into regions.
//
// It is a type of its own because it is worth looking at on its own. Two decisions can wreck an hour-long
// bake - how the legend read the paint, and how the planet was cut up - and both are settled here, in about
// a minute. That is what the plan command exists to show.
type Inputs struct {
	M      *manifest.Manifest
	P      world.Planet
	Legend *template.Legend
	Raster *template.Raster // at paint resolution
	Map    *template.Map    // at planet resolution
	Part   *region.Partition

	// Palette is how the preview is drawn. Never nil: the generator's own when the manifest names none.
	Palette *field.Palette

	PaintW, PaintH int
	Match          template.Match
	EdgeRewritten  int
	Dissolved      int
	MarginCells    int
	Elapsed        time.Duration

	// The annotation layer, or nil throughout when the manifest configures none. It is prepared here rather
	// than at export time for one reason: its coast_jitter marks have to be read *before* the waterline is
	// roughened, which is the first thing that happens to the painting, so by the time a plan exists the
	// overlay has already had its say. Everything else it carries is inert - see internal/overlay.
	Overlay       *overlay.Legend
	OverlayRaster *overlay.Raster
	OverlayMatch  overlay.Match
	OverlayDoc    *overlay.Document

	// Faults is the planet's whole fault set, in world metres, drawn once here because placing a trace needs
	// the class raster of the *whole* cylinder - and because a set drawn per region would put a different
	// fault in every one of them, which is the defect that kept the procedural path's version from being
	// portable at all. Every region reads the same slice and filters it to its own frame.
	Faults []uplift.FaultTrace

	// Plates is the tectonic model, or nil when the manifest asks for none. Drawn here for the same reason
	// the fault set is: a plate is a planet-wide object, and a partition computed per region would give the
	// same physical margin a different classification in every one of them.
	Plates *plates.Model
}

// Painting is the two images already in memory, which is what the studio has: the pictures being edited are
// the ones in the browser, so a plan run against the files on disk would answer a question nobody asked.
//
// A nil Painting, or a nil half of one, means "read what the manifest names". The two halves are separate
// because they are edited separately: moving a road does not re-roughen the coast unless a coast_jitter mark
// moved with it, and the studio's plan cache keys on them one at a time.
type Painting struct {
	Class          []uint8
	ClassW, ClassH int

	Overlay            []uint8
	OverlayAlpha       []uint8
	OverlayW, OverlayH int

	// The tectonic layer, RGB with no alpha: every pixel of it is some plate, so there is no "nothing" to
	// carry. Like the other two it is the authority while the studio is open.
	Plates           []uint8
	PlatesW, PlatesH int
}

// Prepare reads the template, classifies it, projects it onto the planet and partitions it.
//
// Nothing here erodes anything, and nothing here is expensive: the whole thing is a few image passes and
// three distance transforms.
func Prepare(m *manifest.Manifest, log func(string, ...any)) (*Inputs, error) {
	return PrepareWith(m, nil, log)
}

// PrepareWith is Prepare over paintings already in memory. See Painting; nil reads what the manifest names,
// which is what Prepare does.
func PrepareWith(m *manifest.Manifest, art *Painting, log func(string, ...any)) (*Inputs, error) {

	if !m.IsPlanet() {
		return nil, fmt.Errorf("%s has no planet block; this is the square canvas that `generate` builds",
			m.Path)
	}
	start := time.Now()
	if log == nil {
		log = func(string, ...any) {}
	}
	pb := m.Planet
	cell := m.GeologyCellM()

	lg, err := template.Load(m.LegendPath())
	if err != nil {
		return nil, err
	}
	log("legend   %s: %d classes", m.Planet.Legend, len(lg.Classes))

	var px []uint8
	var pw, ph int
	if art != nil {
		px, pw, ph = art.Class, art.ClassW, art.ClassH
	}
	if px == nil {
		var err error
		px, pw, ph, err = template.DecodeRGB(m.TemplatePath())
		if err != nil {
			return nil, err
		}
		log("template %s: %d x %d px", pb.Template, pw, ph)
	} else {
		log("template in memory: %d x %d px", pw, ph)
	}

	ras, match := lg.Classify(px, pw, ph)
	px = nil
	edge, dissolved := ras.DissolveStrokes(lg)
	speckle := ras.Despeckle()
	log("classify %s; %d px rescued at the poles, %d dissolved, %d despeckled",
		match, edge, dissolved, speckle)

	marginCells := pb.MarginCells(cell)
	p, err := world.New(pb.CircumferenceKm*1000, cell, pw, ph, marginCells, pb.NoisePeriodKm*1000)
	if err != nil {
		return nil, err
	}
	log("planet   %d x %d cells of %.1f m: %.1f x %.1f km, %.0f km2 (+%d rows of polar pad)",
		p.W, p.PaintH(), p.CellM, p.CircumferenceM()/1000, p.HeightM()/1000,
		p.CircumferenceM()*p.HeightM()/1e6, p.PadY)

	padClass := lg.FirstSea()
	if pb.PadClass != "" {
		padClass = lg.Index(pb.PadClass)
		if padClass < 0 {
			return nil, fmt.Errorf("%s: planet.pad_class %q is not a class in the legend", m.Path, pb.PadClass)
		}
		if !lg.Classes[padClass].Sea {
			return nil, fmt.Errorf("%s: planet.pad_class %q is land; the pad is the ocean a polar cap "+
				"drains into", m.Path, pb.PadClass)
		}
	}
	if padClass < 0 {
		return nil, fmt.Errorf("%s: the legend has no sea class, so there is nothing to fill the polar pad "+
			"with", m.LegendPath())
	}

	pal := field.DefaultPalette()
	if path := m.PalettePath(); path != "" {
		pal, err = field.LoadPalette(path)
		if err != nil {
			return nil, err
		}
		log("palette  %s", m.Planet.Palette)
	}

	// The annotation layer, read before the coast is roughened rather than after: its coast_jitter marks are
	// the one thing on it the generator reads, and what they decide is how far the waterline may move.
	ov, ovRas, ovMatch, err := loadOverlay(m, art, pw, ph, log)
	if err != nil {
		return nil, err
	}

	// The painted waterline is roughened before it is projected: a drawn shore is a smooth curve and a coast
	// is not. See template/coast.go. Off by default only in the sense that an amplitude of zero is the
	// painting exactly as drawn.
	coast := template.Coast{
		AmplitudePx:  pb.CoastJitterPx,
		WavelengthPx: pb.CoastJitterWavelengthPx,
		Octaves:      pb.CoastJitterOctaves,
		Gain:         pb.CoastJitterGain,
		Seed:         m.Source.Seed,
	}
	if ov != nil && ovRas != nil {
		coast.Scale = ov.CoastScale(ovRas)
	}
	if coast.Amount() {
		ras = ras.RoughenCoast(lg, p, coast)
		masked := ""
		if coast.Scale != nil {
			masked = ", masked by the overlay"
		}
		log("coast    the painted waterline roughened by up to %.0f px over %.0f px bays, %d octaves%s",
			coast.AmplitudePx, coast.WavelengthPx, coast.Octaves, masked)
	}

	pm := ras.Project(p, lg, padClass)

	part, err := region.Build(pm, marginCells, pb.MinLandCells)
	if err != nil {
		return nil, err
	}

	// The plates first, because the fault set is now partly a consequence of them.
	tect, err := buildPlates(m, p, pm, art, log)
	if err != nil {
		return nil, err
	}

	faults := buildFaultSet(pm, lg, pb.FaultGrainKm, m.Source.Seed)
	if len(faults) > 0 {
		log("faults   %d class traces over %d classes, grain %.0f km",
			len(faults), faultClasses(lg), pb.FaultGrainKm)
	}
	if belt := buildBeltFaults(p, pm, tect, pb.Plates.Faults, m.Source.Seed, log); len(belt) > 0 {
		faults = append(faults, belt...)
	}

	in := &Inputs{
		M: m, P: p, Legend: lg, Raster: ras, Map: pm, Part: part, Palette: pal,
		PaintW: pw, PaintH: ph, Match: match,
		EdgeRewritten: edge, Dissolved: dissolved, MarginCells: marginCells,
		Overlay: ov, OverlayRaster: ovRas, OverlayMatch: ovMatch,
		Faults:  faults,
		Plates:  tect,
		Elapsed: time.Since(start),
	}
	if ov != nil && ovRas != nil {
		in.OverlayDoc = ov.Describe(ovRas, ovMatch, in.OverlayScale(),
			m.Planet.Overlay, m.Planet.OverlayLegend)
	}
	return in, nil
}

// faultCandidateTarget is roughly how many strided samples of the planet the fault placement draws from. The
// sample is only ever used for a uniform draw - the *areas* are the projection's own exact counts - so what
// it has to be is dense enough that a small class still has somewhere to put a trace, not dense enough to
// measure anything. Sixty-odd thousand over a 76-million-cell planet is a stride of about 34 cells, 270 m,
// and leaves a class covering a fifth of a per cent with over a hundred candidates.
const faultCandidateTarget = 65536

// buildFaultSet draws the planet's faults, or returns nil when no class asks for any.
func buildFaultSet(pm *template.Map, lg *template.Legend, grainKm float64, seed int64) []uplift.FaultTrace {
	if !lg.HasFaults() || grainKm <= 0 {
		return nil
	}
	specs := make([]uplift.FaultSpec, len(lg.Classes))
	for i := range lg.Classes {
		f := lg.Classes[i].Faults
		if f == nil || !lg.Classes[i].Land() {
			continue
		}
		specs[i] = uplift.FaultSpec{Per1000Km2: f.Per1000Km2, ThrowM: f.ThrowM, LengthKm: f.LengthKm}
	}

	p := pm.P
	stride := int(math.Sqrt(float64(p.W)*float64(p.PaintH())/faultCandidateTarget) + 0.5)
	if stride < 1 {
		stride = 1
	}
	candidates := make([][]int32, len(lg.Classes))
	// Painted rows only. The polar pad is synthetic ocean that no class was ever painted on, and a trace
	// placed there would be a fault in scaffolding.
	for y := p.PadY; y < p.H-p.PadY; y += stride {
		for x := 0; x < p.W; x += stride {
			i := y*p.W + x
			c := pm.Class[i]
			if specs[c].Wanted() {
				candidates[c] = append(candidates[c], int32(i))
			}
		}
	}
	areaCells, _, _ := pm.Counts()
	return uplift.BuildFaults(p, seed, grainKm, specs, candidates, areaCells)
}

// buildPlates draws the planet's tectonics, or returns nil when the manifest asks for none.
//
// The land mask is read through a callback at world coordinates rather than handed over as a raster, and
// that is what keeps internal/plates ignorant of templates. What it wants from the painting is one bit per
// position - continent or ocean - and that bit is what decides whether a plate is continental, and therefore
// whether a margin between two of them is a collision or a subduction zone.
func buildPlates(mf *manifest.Manifest, p world.Planet, pm *template.Map, art *Painting,
	log func(string, ...any)) (*plates.Model, error) {

	cfg := mf.Planet.Plates
	inMemory := art != nil && art.Plates != nil
	painted := inMemory || mf.HasPaintedPlates()
	if !painted && cfg.Count <= 0 {
		return nil, nil
	}

	var m *plates.Model
	var err error
	if painted {
		m, err = paintedPlates(mf, p, pm, art, cfg, log)
	} else {
		m, err = plates.Build(p, mf.Source.Seed, cfg, landAt(p, pm))
	}
	if err != nil {
		return nil, err
	}

	continental := 0
	for i := range m.Plates {
		if m.Plates[i].Continental {
			continental++
		}
	}
	byKind := plates.LengthByKind(m.Boundaries)
	source := "from seed " + strconv.FormatInt(mf.Source.Seed, 10)
	if painted {
		source = "painted"
	}
	log("plates   %d %s (%d continental), %d boundaries, tectonic grid %.0f m",
		len(m.Plates), source, continental, len(m.Boundaries), m.GCellM)
	log("         collision %.0f km, subduction %.0f km, rift %.0f km, ridge %.0f km, transform %.0f km",
		byKind[plates.Collision]/1000, byKind[plates.Subduction]/1000, byKind[plates.Rift]/1000,
		byKind[plates.Ridge]/1000, byKind[plates.Transform]/1000)
	return m, nil
}

// landAt answers "is this world position painted land" against the projected map.
//
// A callback rather than the raster itself, because internal/plates and internal/uplift's belt placement both
// want exactly this one bit and neither should know what a template is. It is also the only thing the
// painting tells the tectonic model, which is worth being able to point at: everything else about a plate
// comes from the seed and the manifest.
func landAt(p world.Planet, pm *template.Map) func(xM, yM float64) bool {
	return func(xM, yM float64) bool {
		x := p.WrapX(int(math.Floor(xM / p.CellM)))
		y := p.ClampY(int(math.Floor(yM/p.CellM)) + p.PadY)
		return !pm.Sea[y*p.W+x]
	}
}

// buildBeltFaults places the traces that belong to the plate margins rather than to a painted class.
//
// Separate from buildFaultSet and added to the same slice, because from the solve's point of view a fault is
// a fault: both end up in Inputs.Faults, both are rasterised by the same FaultDelta, and the difference is
// only in how they were placed. Where they came from survives in the log line and in the trace's own Class,
// which is -1 for a belt fault because no painted colour asked for it.
func buildBeltFaults(p world.Planet, pm *template.Map, tect *plates.Model, cfg plates.Belt,
	seed int64, log func(string, ...any)) []uplift.FaultTrace {

	if tect == nil || !cfg.Wanted() {
		return nil
	}
	out := uplift.BuildBeltFaults(p, seed, cfg, tect.Boundaries, landAt(p, pm))
	cfg = cfg.WithDefaults()
	log("         %d belt traces, %.0f km deformation half-width at %.0f cm/yr, %.0f%% conjugate",
		len(out), cfg.ZoneKm, cfg.ReferenceCmYr, cfg.Conjugate()*100)
	return out
}

// paintedPlates reads the tectonic layer and turns it into a model.
//
// The decoding happens here rather than in internal/plates for the same reason the land mask does: that
// package deals in geometry and motion, and giving it a file path would give it an opinion about image
// formats, paths and the manifest. It is handed pixels.
func paintedPlates(mf *manifest.Manifest, p world.Planet, pm *template.Map, art *Painting,
	cfg plates.Config, log func(string, ...any)) (*plates.Model, error) {

	legendPath := mf.PlatesLegendPath()
	lg, err := plates.LoadPaintLegend(legendPath)
	if err != nil {
		return nil, err
	}

	// The sheet in memory wins when there is one, for the same reason Painting exists at all: the studio is
	// editing a picture in a browser, and a plan run against the file on disk would answer a question nobody
	// asked.
	layerPath := mf.Planet.Plates.Layer
	var px []uint8
	var pw, ph int
	if art != nil && art.Plates != nil {
		px, pw, ph = art.Plates, art.PlatesW, art.PlatesH
		layerPath = "in memory"
	} else {
		path := mf.PlatesLayerPath()
		if px, pw, ph, err = template.DecodeRGB(path); err != nil {
			return nil, fmt.Errorf("tectonic layer %s: %w", path, err)
		}
	}

	m, match, err := plates.FromPainting(p, cfg, lg, px, pw, ph, landAt(p, pm))
	if err != nil {
		return nil, fmt.Errorf("tectonic layer %s: %w", layerPath, err)
	}
	log("tectonic %s, %dx%d px, %d plates", layerPath, pw, ph, len(lg.Plates))
	if match.Far > 0 {
		// Reported rather than fatal, and loudly. Every pixel becomes the nearest plate whatever happens, so
		// a layer whose colours have drifted still produces a model - it just produces the wrong one, with
		// boundaries somewhere nobody put them.
		log("         %d of %d sampled cells are over %.0f from any plate colour (worst %.0f); the layer and "+
			"%s disagree", match.Far, match.Cells, lg.WarnDistance, match.MaxDistance,
			filepath.Base(legendPath))
	}
	return m, nil
}

// RebuildFaults draws the fault set again from the legend as it stands now.
//
// It exists for the studio's plan cache, which reuses a whole prepare when only the legend's *numbers*
// changed - and a class's `faults` block is a number that changes the set without changing a pixel of the
// raster the cache is keyed on. Cheap: a strided scan and a few dozen walks, against the six seconds the
// cache is there to avoid.
func (in *Inputs) RebuildFaults() {
	in.Faults = buildFaultSet(in.Map, in.Legend, in.M.Planet.FaultGrainKm, in.M.Source.Seed)
	// The belt set comes back too. It is not the legend's, but it is in the same slice, and a rebuild that
	// dropped it would silently unfault every margin on the planet the first time a class number changed.
	quiet := func(string, ...any) {}
	in.Faults = append(in.Faults,
		buildBeltFaults(in.P, in.Map, in.Plates, in.M.Planet.Plates.Faults, in.M.Source.Seed, quiet)...)
}

// faultClasses is how many classes asked for traces, for the log line.
func faultClasses(lg *template.Legend) int {
	n := 0
	for i := range lg.Classes {
		if lg.Classes[i].Faults != nil {
			n++
		}
	}
	return n
}

// OverlayScale is how an overlay pixel maps to world metres. The overlay is registered to the template and
// shares its frame, so this is the template's scale and not the geology grid's - a pixel is 12.9 m where a
// cell is 8.
func (in *Inputs) OverlayScale() overlay.Scale {
	w, h := in.PaintW, in.PaintH
	if in.OverlayRaster != nil {
		w, h = in.OverlayRaster.W, in.OverlayRaster.H
	}
	circ := in.P.CircumferenceM()
	return overlay.Scale{
		MetresPerPxX:   circ / float64(w),
		MetresPerPxY:   in.P.HeightM() / float64(h),
		CircumferenceM: circ,
	}
}

// loadOverlay reads and classifies the annotation layer, from memory when the studio has one and from disk
// otherwise. Returns nils all round when the manifest configures none, which is not an error anywhere.
//
// The overlay must be the same size as the template. It is registered to it - a mark means "here", and here
// is a place on the painting - so two different sizes is not something to resample past, it is an author who
// exported one of the two at the wrong scale and would otherwise find their villages drifting.
func loadOverlay(m *manifest.Manifest, art *Painting, paintW, paintH int, log func(string, ...any)) (
	*overlay.Legend, *overlay.Raster, overlay.Match, error) {

	var none overlay.Match
	if !m.HasOverlay() {
		return nil, nil, none, nil
	}
	ov, err := overlay.Load(m.OverlayLegendPath())
	if err != nil {
		return nil, nil, none, err
	}

	var px, alpha []uint8
	var w, h int
	if art != nil && art.Overlay != nil {
		px, alpha, w, h = art.Overlay, art.OverlayAlpha, art.OverlayW, art.OverlayH
	} else {
		path := m.OverlayPath()
		if path == "" {
			if ov.Image == "" {
				return nil, nil, none, fmt.Errorf("%s: planet.overlay_legend is set but neither it nor "+
					"planet.overlay names an image", m.Path)
			}
			path = filepath.Join(filepath.Dir(m.OverlayLegendPath()), ov.Image)
		}
		if _, statErr := os.Stat(path); statErr != nil {
			// A configured overlay whose image is not there yet is the state the studio starts an author in:
			// the legend is written and the sheet is blank. Worth saying, not worth failing on.
			log("overlay  %s: no image yet (%s); nothing is marked",
				m.Planet.OverlayLegend, filepath.Base(path))
			return ov, nil, none, nil
		}
		px, alpha, w, h, err = template.DecodeRGBA(path)
		if err != nil {
			return nil, nil, none, err
		}
	}
	if w != paintW || h != paintH {
		return nil, nil, none, fmt.Errorf("the overlay is %dx%d and the template is %dx%d; they are "+
			"registered to each other, so they have to be the same size", w, h, paintW, paintH)
	}
	ras, match := ov.Classify(px, alpha, w, h)
	log("overlay  %d marks: %s", len(ov.Marks), match)
	return ov, ras, match, nil
}

// SolveCells is how many cells the geology solve will actually visit, summed over regions. It is the number
// the bake time is proportional to, and it is well above the land area because every region carries water.
func (in *Inputs) SolveCells() int {
	n := 0
	for _, r := range in.Part.Regions {
		n += r.Cells()
	}
	return n
}

// LandCells is how many painted land cells the regions own.
func (in *Inputs) LandCells() int {
	n := 0
	for _, r := range in.Part.Regions {
		n += r.LandCells
	}
	return n
}

// The measurement the estimates below are scaled from, and the thing it cannot know.
//
// Docs/Terrain.md's time budget records 256 s for 3.2 M cells over 1000 steps on the development machine's
// 16 cores, which is 8.0e-8 s a cell-step. Measured again on a lowland region of this planet - 14.0 M cells,
// 200 steps, 415 s - it is 1.48e-7, very nearly twice as slow, most likely because the square canvas is two
// thirds land while a region is two thirds water: a cheap ocean cell is not a free one.
//
// What no single constant can capture is that **the cost per cell depends on the uplift rate, and by a lot**.
// Measured on the same bake at 1000 steps with four regions in flight:
//
//	lowland  0.08 mm/yr   14.0 M cells   1014 s     72 s per million cells
//	highland 0.90 mm/yr    4.0 M cells   1394 s    350 s per million cells
//	crater   1.60 mm/yr    1.4 M cells   1829 s   1278 s per million cells
//
// Eighteen-fold, and it is not the stream power. It is the hillslope: DiffuseNonlinear sub-steps to stay
// stable, the count rises with the steepest slope on the grid, and it saturates at max_hillslope_substeps -
// 24 by default. Steep ground pays all 24 every step; a plain pays one.
//
// So the estimate is calibrated on the plains and **badly under-predicts a mountainous template**. It is a
// floor rather than a forecast, the printed line says so, and the practical consequence for an author is
// that raising an uplift rate does not only change the terrain, it changes how long the bake takes.
const secondsPerCellStep = 415.0 / (14.02e6 * 200)

// EstimateSeconds is how long a region's solve should take at the manifest's step count.
func (in *Inputs) EstimateSeconds(cells int) float64 {
	return float64(cells) * float64(in.M.Pipeline.Fluvial.Steps) * secondsPerCellStep
}

// bytesPerCell is what a region costs while it is being solved: the fluvial.Grid's eight int32/float32
// arrays and three masks, plus the height, uplift and erodibility fields the solve reads. It is an estimate
// and it is labelled as one wherever it is printed.
const bytesPerCell = 35 + 12 + 16

// EstimateBytes is roughly how much memory a region's solve holds at once.
func (in *Inputs) EstimateBytes(cells int) int64 { return int64(cells) * bytesPerCell }