package engine

import "fmt"

// Strategy selects who gets educated.
type Strategy string

const (
	StrategyNone          Strategy = "none"
	StrategyRandom        Strategy = "random"
	StrategyMostConnected Strategy = "most-connected"
)

// AllStrategies lists every strategy in display order. The CLI, and later
// the API and frontend, read this one list; nothing redefines it.
func AllStrategies() []Strategy {
	return []Strategy{StrategyNone, StrategyRandom, StrategyMostConnected}
}

// Config fully describes one simulation world. It is the single source of
// truth for parameters: API and frontend types will be generated from the
// structs in this file, never redefined by hand. Identical configs produce
// identical results; all randomness flows from the three seeds.
type Config struct {
	NumStudents  int     `json:"numStudents"`
	EdgesPerNode int     `json:"edgesPerNode"` // attachment edges per new student (network density)
	TriangleProb float64 `json:"triangleProb"` // chance to close a friend-of-a-friend triangle
	ForwardProb  float64 `json:"forwardProb"`  // chance a student forwards the fake along an edge
	NumEducated  int     `json:"numEducated"`  // students the education program reaches
	Origin       int     `json:"origin"`       // student who first posts the fake

	GraphSeed     uint64 `json:"graphSeed"`
	ThresholdSeed uint64 `json:"thresholdSeed"`
	EducationSeed uint64 `json:"educationSeed"` // used by the random strategy only
}

// DefaultConfig mirrors the Python prototype: a school year of 120
// students, educate 30% of them, forwarding probability 0.38.
func DefaultConfig() Config {
	return Config{
		NumStudents:   120,
		EdgesPerNode:  3,
		TriangleProb:  0.45,
		ForwardProb:   0.38,
		NumEducated:   36,
		Origin:        0,
		GraphSeed:     17,
		ThresholdSeed: 2,
		EducationSeed: 1,
	}
}

// IntBounds is an inclusive allowed range for an integer Config field.
type IntBounds struct {
	Min int `json:"min"`
	Max int `json:"max"`
}

// FloatBounds is an inclusive allowed range for a float Config field.
type FloatBounds struct {
	Min float64 `json:"min"`
	Max float64 `json:"max"`
}

// Bounds gives the allowed range for every absolute Config field. These
// are realism limits, not mathematical ones: a student does not keep 150
// close friendships, and a guaranteed forward is not a plausible base
// rate. numEducated and origin are relational (0..numStudents and
// 0..numStudents-1) and therefore not listed; seeds are unrestricted.
type Bounds struct {
	NumStudents  IntBounds   `json:"numStudents"`
	EdgesPerNode IntBounds   `json:"edgesPerNode"`
	TriangleProb FloatBounds `json:"triangleProb"`
	ForwardProb  FloatBounds `json:"forwardProb"`
}

// ConfigBounds returns the bounds the engine enforces. The frontend
// receives this verbatim (with the default config) and drives its
// sliders and clamping from the same numbers.
func ConfigBounds() Bounds {
	return Bounds{
		NumStudents:  IntBounds{Min: 10, Max: 500},
		EdgesPerNode: IntBounds{Min: 1, Max: 8},
		TriangleProb: FloatBounds{Min: 0, Max: 1},
		ForwardProb:  FloatBounds{Min: 0, Max: 0.9},
	}
}

// ValidateConfig rejects configs outside ConfigBounds or with relational
// fields out of range. Error messages contain the offending field's JSON
// name; the frontend matches on it to mark the right control invalid.
func ValidateConfig(config Config) error {
	bounds := ConfigBounds()
	if config.NumStudents < bounds.NumStudents.Min || config.NumStudents > bounds.NumStudents.Max {
		return fmt.Errorf("scenario: need %d <= numStudents <= %d, got %d",
			bounds.NumStudents.Min, bounds.NumStudents.Max, config.NumStudents)
	}
	if config.EdgesPerNode < bounds.EdgesPerNode.Min || config.EdgesPerNode > bounds.EdgesPerNode.Max {
		return fmt.Errorf("scenario: need %d <= edgesPerNode <= %d, got %d",
			bounds.EdgesPerNode.Min, bounds.EdgesPerNode.Max, config.EdgesPerNode)
	}
	if config.TriangleProb < bounds.TriangleProb.Min || config.TriangleProb > bounds.TriangleProb.Max {
		return fmt.Errorf("scenario: need %v <= triangleProb <= %v, got %v",
			bounds.TriangleProb.Min, bounds.TriangleProb.Max, config.TriangleProb)
	}
	if config.ForwardProb < bounds.ForwardProb.Min || config.ForwardProb > bounds.ForwardProb.Max {
		return fmt.Errorf("scenario: need %v <= forwardProb <= %v, got %v",
			bounds.ForwardProb.Min, bounds.ForwardProb.Max, config.ForwardProb)
	}
	if config.NumEducated < 0 || config.NumEducated > config.NumStudents {
		return fmt.Errorf("scenario: need 0 <= numEducated <= %d students, got %d",
			config.NumStudents, config.NumEducated)
	}
	if config.Origin < 0 || config.Origin >= config.NumStudents {
		return fmt.Errorf("scenario: origin %d outside 0..%d", config.Origin, config.NumStudents-1)
	}
	return nil
}

// Result is the outcome of one scenario run.
type Result struct {
	Strategy       Strategy `json:"strategy"`
	Educated       []int    `json:"educated"`
	ReachedAtRound []int    `json:"reachedAtRound"` // per node; -1 means never reached
	NumReached     int      `json:"numReached"`
	NumRounds      int      `json:"numRounds"`
	ReachedPct     float64  `json:"reachedPct"`
}

// GraphEdges builds the world's social network from the config's graph
// fields and returns its undirected edge list. The same config always
// yields the same edges (seeded generator), so the API can expose
// topology separately without every Result carrying it.
func GraphEdges(config Config) ([][2]int, error) {
	graph, err := HolmeKim(config.NumStudents, config.EdgesPerNode, config.TriangleProb, newRand(config.GraphSeed))
	if err != nil {
		return nil, err
	}
	return graph.Edges(), nil
}

// RunScenario builds the world the config describes (network plus edge
// thresholds), picks the educated students per strategy, and runs the
// cascade. Scenarios with the same config share the same world, so
// comparing strategies compares only the lever.
func RunScenario(config Config, strategy Strategy) (Result, error) {
	if err := ValidateConfig(config); err != nil {
		return Result{}, err
	}

	graph, err := HolmeKim(config.NumStudents, config.EdgesPerNode, config.TriangleProb, newRand(config.GraphSeed))
	if err != nil {
		return Result{}, err
	}
	thresholds := NewEdgeThresholds(graph, newRand(config.ThresholdSeed))

	var educated []int
	switch strategy {
	case StrategyNone:
		// nobody educated; the baseline
	case StrategyRandom:
		educated = EducateRandom(graph, config.Origin, config.NumEducated, newRand(config.EducationSeed))
	case StrategyMostConnected:
		educated = EducateMostConnected(graph, config.Origin, config.NumEducated)
	default:
		return Result{}, fmt.Errorf("scenario: unknown strategy %q", strategy)
	}

	if educated == nil {
		educated = []int{} // a nil slice marshals to JSON null, not []
	}
	cascade := RunCascade(graph, config.Origin, config.ForwardProb, educated, thresholds)
	return Result{
		Strategy:       strategy,
		Educated:       educated,
		ReachedAtRound: cascade.ReachedAtRound,
		NumReached:     cascade.NumReached,
		NumRounds:      cascade.NumRounds,
		ReachedPct:     100 * float64(cascade.NumReached) / float64(config.NumStudents),
	}, nil
}