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
}

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 GameAnalysisResult struct {
	Turns           []*TurnAnalysis
	PlayerSummaries [2]*PlayerSummary
}

type GamePhase int

type PlayerSummary struct {
	PlayerName     string
	TurnsPlayed    int
	OptimalMoves   int
	AvgWinProbLoss float64
	AvgSpreadLoss  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 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

	// 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
}