gameanalysis

type AnalysisConfig struct {
	// Early/mid game (>7 tiles in bag)
	SimPlaysEarlyMid int
	SimPliesEarlyMid int
	SimStopEarlyMid  int // 90, 95, 98, 99, or 999

	// Early pre-endgame (2-7 tiles in bag)
	SimPlaysEarlyPreEndgame int
	SimPliesEarlyPreEndgame int
	SimStopEarlyPreEndgame  int

	// Pre-endgame (1 tile in bag) - uses PEG solver
	PEGEarlyCutoff bool

	Threads int

	// Optional: analyze only one player (-1 = both, 0 = player 0, 1 = player 1, or player nickname)
	OnlyPlayer       int
	OnlyPlayerByName string

	// UseExposedOppRacks enables using opponent rack information revealed
	// through challenged phonies when analyzing the subsequent turn.
	UseExposedOppRacks bool
}

type AnalysisStore struct {
	// contains filtered or unexported fields
}

type Analyzer struct {
	// contains filtered or unexported fields
}

type BatchAnalysisResult struct {
	Games           []*BatchGameResult
	PlayerStats     map[string]*BatchPlayerStats
	TotalGames      int
	SuccessfulGames int
	FailedGames     int
}

type BatchGameResult struct {
	GameID      string              // e.g., "woogles:ABC123", "xt:12345", "/path/to/game.gcg"
	GameInfo    string              // e.g., "Player1 vs Player2"
	LoadError   error               // Error during game loading
	AnalysisErr error               // Error during game analysis
	Result      *GameAnalysisResult // Analysis result if successful
}

type BatchPlayerStats struct {
	PlayerName      string
	GamesPlayed     int
	TotalTurns      int
	TotalOptimal    int
	TotalSmall      int     // Small mistakes count
	TotalMedium     int     // Medium mistakes count
	TotalLarge      int     // Large mistakes count
	TotalMistakeIdx float64 // Sum of mistake indices
	AvgMistakeIndex float64 // Average mistake index
	AvgEstimatedELO float64 // Average estimated ELO

	// Bingo tracking
	TotalAvailableBingos int // Total number of bingo opportunities
	TotalMissedBingos    int // Total number of missed bingos
}

type EndgameMoveResult struct {
	MoveDescription string
	Score           int
	MoveNumber      int
}

type EndgameVariationResult struct {
	Moves       []*EndgameMoveResult
	FinalSpread int16
}

type GameAnalysisResult struct {
	Turns           []*TurnAnalysis
	PlayerSummaries [2]*PlayerSummary
	AnalysisVersion int
	AnalyzerVersion string
}

type GamePhase int

type PEGOutcomeResult struct {
	Tiles   string // human-readable, e.g. "A", "EI"
	Outcome string // "win", "draw", "loss", "unknown"
	Count   int
}

type PEGPlayResult struct {
	MoveDescription string
	Score           int
	Leave           string
	IsBingo         bool
	WinProb         float64
	Outcomes        []*PEGOutcomeResult
	HasSpread       bool
	AvgSpread       float64
	IsPlayedMove    bool
	IsIgnored       bool
}

type PlayerSummary struct {
	PlayerName     string
	TurnsPlayed    int
	OptimalMoves   int
	AvgWinProbLoss float64

	// Mistake breakdown
	SmallMistakes  int
	MediumMistakes int
	LargeMistakes  int

	MistakeIndex float64 // Sum of mistake points (0.2 for small, 0.5 for medium, 1.0 for large)
	EstimatedELO float64 // Estimated ELO based on mistake index

	// Bingo tracking
	AvailableBingos int // Number of turns where optimal move was a bingo
	MissedBingos    int // Number of times player didn't play a bingo when optimal was a bingo
}

type PlyStatResult struct {
	Ply        int
	ScoreMean  float64
	ScoreStdev float64
	BingoPct   float64
}

type SimPlayResult struct {
	MoveDescription string
	Score           int
	Leave           string
	IsBingo         bool
	WinProb         float64
	WinProbStdErr   float64
	Equity          float64
	EquityStdErr    float64
	Iterations      int
	PlyStats        []*PlyStatResult
	IsPlayedMove    bool
	IsIgnored       bool
}

type StoredAnalysis struct {
	ID              int
	Name            string
	BatchName       string
	PlayerInfo      string
	Lexicon         string
	AnalysisVersion int
	AnalyzerVersion string
	ResultJSON      []byte
	CreatedAt       time.Time
	UpdatedAt       time.Time
}

type TurnAnalysis struct {
	TurnNumber  int
	PlayerIndex int
	PlayerName  string
	Rack        string
	Phase       GamePhase
	TilesInBag  int // Number of tiles in bag at this turn

	// The move that was actually played
	PlayedMove *move.Move
	// The optimal move according to analysis
	OptimalMove *move.Move
	// Display strings used when loaded from storage (PlayedMove/OptimalMove are nil)
	PlayedMoveStr  string
	OptimalMoveStr string

	// For sim/PEG phases - win probability
	PlayedWinProb  float64
	OptimalWinProb float64
	WinProbLoss    float64 // OptimalWinProb - PlayedWinProb

	// For endgame phase - spread difference
	SpreadLoss         int16 // How much worse the played move is compared to optimal
	OptimalFinalSpread int16 // The final spread with the optimal move (endgame only)
	CurrentSpread      int   // The spread before this move (endgame only, for blown endgame detection)

	// Whether the played move was optimal
	WasOptimal bool

	// Mistake categorization
	MistakeCategory string // "Small", "Medium", "Large", or empty if optimal
	BlownEndgame    bool   // True if the mistake changed a win to a loss/tie in endgame

	// Bingo tracking
	OptimalIsBingo bool // True if the optimal move is a bingo (7 tiles)
	PlayedIsBingo  bool // True if the played move is a bingo (7 tiles)
	MissedBingo    bool // True if optimal was a bingo but player didn't play a bingo

	// Phony handling
	IsPhony         bool // The played move was a phony
	PhonyChallenged bool // A phony that was challenged off
	MissedChallenge bool // Player failed to challenge opponent's phony

	// KnownOppRack contains the known opponent tiles (if any) used in analysis.
	// This is populated when the opponent's phony was challenged off, exposing their rack.
	KnownOppRack string

	// Enriched data (v2+)
	TopSimPlays        []*SimPlayResult
	TopPEGPlays        []*PEGPlayResult
	PrincipalVariation *EndgameVariationResult
	OtherVariations    []*EndgameVariationResult
}