package main

import (
	"crypto/rand"
	"encoding/hex"
	"encoding/json"
	"flag"
	"fmt"
	"math/big"
	"os"
	"path/filepath"
	"sort"
	"strings"
	"time"

	selfgame "hyapp/services/game-service/internal/domain/selfgame"
)

const (
	resultWin     = "win"
	resultLose    = "lose"
	resultDraw    = "draw"
	resultSkipped = "skipped"

	matchModeHuman = "human"
	matchModeRobot = "robot"

	cohortRobotOnly = "robot_only"
	cohortMixed     = "robot_human_mixed"

	scenarioRandom         = "random"
	scenarioFirst30Cohorts = "first30-cohorts"

	feeBPS  = int64(500)
	poolBPS = int64(100)
)

type simulationReport struct {
	RunID            string               `json:"runId"`
	GeneratedAtMS    int64                `json:"generatedAtMs"`
	RandomSource     string               `json:"randomSource"`
	UserCount        int                  `json:"userCount"`
	RoundCount       int                  `json:"roundCount"`
	Summary          summary              `json:"summary"`
	ReasonCounts     map[string]int       `json:"reasonCounts"`
	DecisionCounts   map[string]int       `json:"decisionCounts"`
	PoolSummaries    []poolSummary        `json:"poolSummaries"`
	Validation       validationSummary    `json:"validation"`
	UserTrajectories []userTrajectoryMeta `json:"userTrajectories"`
}

type summary struct {
	Attempts                         int     `json:"attempts"`
	Settled                          int     `json:"settled"`
	Skipped                          int     `json:"skipped"`
	HumanMatches                     int     `json:"humanMatches"`
	RobotMatches                     int     `json:"robotMatches"`
	RobotWinsForHuman                int     `json:"robotWinsForHuman"`
	RobotLossesForHuman              int     `json:"robotLossesForHuman"`
	Draws                            int     `json:"draws"`
	NewUserProtectionHits            int     `json:"newUserProtectionHits"`
	NewUserLoseStreakProtectionHits  int     `json:"newUserLoseStreakProtectionHits"`
	PoolBlackSkips                   int     `json:"poolBlackSkips"`
	HighStakeProtectionHits          int     `json:"highStakeProtectionHits"`
	BlockedRiskProtectionHits        int     `json:"blockedRiskProtectionHits"`
	RockDrawProtectionConsumptions   int     `json:"rockDrawProtectionConsumptions"`
	ProtectionConsumedRounds         int     `json:"protectionConsumedRounds"`
	ProtectionSubsidyCoin            int64   `json:"protectionSubsidyCoin"`
	TotalUserNetCoin                 int64   `json:"totalUserNetCoin"`
	AverageUserNetCoin               float64 `json:"averageUserNetCoin"`
	UsersEndedPositive               int     `json:"usersEndedPositive"`
	UsersEndedNegative               int     `json:"usersEndedNegative"`
	ThreeSecondOpenRate              float64 `json:"threeSecondOpenRate"`
	RobotMatchOpenRate               float64 `json:"robotMatchOpenRate"`
	StrategyInterventionRate         float64 `json:"strategyInterventionRate"`
	EffectiveRobotGameCount          int     `json:"effectiveRobotGameCount"`
	EffectiveRobotDrawExcludedRounds int     `json:"effectiveRobotDrawExcludedRounds"`
}

type validationSummary struct {
	Passed                         bool     `json:"passed"`
	FailedChecks                   []string `json:"failedChecks"`
	HighStakeProtectionHits        int      `json:"highStakeProtectionHits"`
	BlockedRiskProtectionHits      int      `json:"blockedRiskProtectionHits"`
	RockDrawProtectionConsumptions int      `json:"rockDrawProtectionConsumptions"`
	PoolAccountingMismatchCount    int      `json:"poolAccountingMismatchCount"`
	PoolBlackRobotAttachmentCount  int      `json:"poolBlackRobotAttachmentCount"`
	ForcedHumanLoseDecisionCount   int      `json:"forcedHumanLoseDecisionCount"`
	OldFixedWinRateReferenceCount  int      `json:"oldFixedWinRateReferenceCount"`
	EveryUserTrajectoryWritten     bool     `json:"everyUserTrajectoryWritten"`
	UnfixedRandomSource            bool     `json:"unfixedRandomSource"`
}

type poolState struct {
	selfgame.StakePool
	InitialCoin int64 `json:"initialCoin"`
	InCoin      int64 `json:"inCoin"`
	OutCoin     int64 `json:"outCoin"`
}

type poolSummary struct {
	AppCode       string `json:"appCode"`
	GameID        string `json:"gameId"`
	StakeCoin     int64  `json:"stakeCoin"`
	InitialCoin   int64  `json:"initialCoin"`
	BalanceCoin   int64  `json:"balanceCoin"`
	InCoin        int64  `json:"inCoin"`
	OutCoin       int64  `json:"outCoin"`
	PoolLevel     string `json:"poolLevel"`
	AccountingOK  bool   `json:"accountingOk"`
	AccountedCoin int64  `json:"accountedCoin"`
	AvailableCoin int64  `json:"availableCoin"`
}

type userState struct {
	UserID          int64
	Cohort          string
	InitialCoin     int64
	Coin            int64
	InitialStage    string
	RiskScore       int32
	RiskTier        string
	RegisteredHours int32
	GameStates      map[string]*gameUserState
	Rounds          []roundTrace
}

type gameUserState struct {
	Stats           selfgame.UserStats
	ProtectionState selfgame.ProtectionState
}

type userTrajectoryMeta struct {
	UserID           int64  `json:"userId"`
	Cohort           string `json:"cohort,omitempty"`
	InitialStage     string `json:"initialStage"`
	RiskScore        int32  `json:"riskScore"`
	RiskTier         string `json:"riskTier"`
	RegisteredHours  int32  `json:"registeredHours"`
	InitialCoin      int64  `json:"initialCoin"`
	FinalCoin        int64  `json:"finalCoin"`
	NetCoin          int64  `json:"netCoin"`
	Rounds           int    `json:"rounds"`
	ProtectionHits   int    `json:"protectionHits"`
	LoseStreakHits   int    `json:"loseStreakHits"`
	Skipped          int    `json:"skipped"`
	EffectiveBotWins int    `json:"effectiveBotWins"`
}

type userTrajectoryFileRecord struct {
	UserID          int64        `json:"userId"`
	Cohort          string       `json:"cohort,omitempty"`
	InitialStage    string       `json:"initialStage"`
	RiskScore       int32        `json:"riskScore"`
	RiskTier        string       `json:"riskTier"`
	RegisteredHours int32        `json:"registeredHours"`
	InitialCoin     int64        `json:"initialCoin"`
	FinalCoin       int64        `json:"finalCoin"`
	NetCoin         int64        `json:"netCoin"`
	Rounds          []roundTrace `json:"rounds"`
}

type roundTrace struct {
	RoundIndex                int    `json:"roundIndex"`
	Cohort                    string `json:"cohort,omitempty"`
	MatchID                   string `json:"matchId"`
	GameID                    string `json:"gameId"`
	StakeCoin                 int64  `json:"stakeCoin"`
	RequestedMatchMode        string `json:"requestedMatchMode"`
	ActualMatchMode           string `json:"actualMatchMode"`
	Settled                   bool   `json:"settled"`
	Result                    string `json:"result"`
	UserNetCoin               int64  `json:"userNetCoin"`
	UserCoinBefore            int64  `json:"userCoinBefore"`
	UserCoinAfter             int64  `json:"userCoinAfter"`
	PoolLevelBefore           string `json:"poolLevelBefore"`
	PoolBalanceBefore         int64  `json:"poolBalanceBefore"`
	PoolBalanceAfter          int64  `json:"poolBalanceAfter"`
	PoolDeltaDirection        string `json:"poolDeltaDirection"`
	PoolDeltaCoin             int64  `json:"poolDeltaCoin"`
	StrategyCode              string `json:"strategyCode"`
	Decision                  string `json:"decision"`
	ReasonCode                string `json:"reasonCode"`
	ForceResult               string `json:"forceResult"`
	RiskTier                  string `json:"riskTier"`
	UserStageBefore           string `json:"userStageBefore"`
	EffectiveBotGameBefore    int32  `json:"effectiveBotGameBefore"`
	LoseStreakBefore          int32  `json:"loseStreakBefore"`
	WinStreakBefore           int32  `json:"winStreakBefore"`
	UsedProtectionBefore      int32  `json:"usedProtectionBefore"`
	LifetimeSubsidyBefore     int64  `json:"lifetimeSubsidyBefore"`
	ProtectionConsumed        bool   `json:"protectionConsumed"`
	ProtectionSubsidyCoin     int64  `json:"protectionSubsidyCoin"`
	EffectiveRobotGameCounted bool   `json:"effectiveRobotGameCounted"`
	DrawExcludedFromEffective bool   `json:"drawExcludedFromEffective"`
	ValidationNote            string `json:"validationNote,omitempty"`
}

func main() {
	users := flag.Int("users", 1000, "number of random users")
	roundsPerUser := flag.Int("rounds", 0, "fixed rounds per user; 0 means random 20-60")
	scenario := flag.String("scenario", scenarioRandom, "simulation scenario: random or first30-cohorts")
	outputDir := flag.String("out", "docs/selfgame-simulation", "output directory")
	flag.Parse()
	if *users <= 0 {
		fatalf("users must be positive")
	}
	if *roundsPerUser < 0 {
		fatalf("rounds must be non-negative")
	}
	if *scenario != scenarioRandom && *scenario != scenarioFirst30Cohorts {
		fatalf("scenario must be %q or %q", scenarioRandom, scenarioFirst30Cohorts)
	}
	if *scenario == scenarioFirst30Cohorts && *users%2 != 0 {
		fatalf("first30-cohorts scenario requires an even user count")
	}

	now := time.Now()
	runID := fmt.Sprintf("selfgame_%s_%s", now.Format("20060102_150405"), randomHex(4))
	if err := os.MkdirAll(*outputDir, 0o755); err != nil {
		fatalf("create output dir: %v", err)
	}

	pools := defaultPools(now.UnixMilli())
	report := simulationReport{
		RunID:          runID,
		GeneratedAtMS:  now.UnixMilli(),
		RandomSource:   "crypto/rand; no fixed seed; every random branch reads system randomness",
		UserCount:      *users,
		ReasonCounts:   map[string]int{},
		DecisionCounts: map[string]int{},
	}

	usersOutPath := filepath.Join(*outputDir, runID+"_users.jsonl")
	usersOut, err := os.Create(usersOutPath)
	if err != nil {
		fatalf("create users jsonl: %v", err)
	}
	defer usersOut.Close()

	userOrder := simulationUserOrder(*users, *scenario)
	for _, i := range userOrder {
		user := randomUserForScenario(int64(100000+i), i, *users, *scenario)
		rounds := 20 + randomInt(41)
		if *roundsPerUser > 0 {
			rounds = *roundsPerUser
		}
		for round := 1; round <= rounds; round++ {
			trace := simulateRound(user, round, pools, &report, requestedModeForScenario(user, *scenario))
			user.Rounds = append(user.Rounds, trace)
			report.RoundCount++
		}
		meta := summarizeUser(user)
		report.UserTrajectories = append(report.UserTrajectories, meta)
		if meta.NetCoin > 0 {
			report.Summary.UsersEndedPositive++
		}
		if meta.NetCoin < 0 {
			report.Summary.UsersEndedNegative++
		}
		report.Summary.TotalUserNetCoin += meta.NetCoin
		record := userTrajectoryFileRecord{
			UserID:          user.UserID,
			Cohort:          user.Cohort,
			InitialStage:    user.InitialStage,
			RiskScore:       user.RiskScore,
			RiskTier:        user.RiskTier,
			RegisteredHours: user.RegisteredHours,
			InitialCoin:     user.InitialCoin,
			FinalCoin:       user.Coin,
			NetCoin:         meta.NetCoin,
			Rounds:          user.Rounds,
		}
		if err := writeJSONLine(usersOut, record); err != nil {
			fatalf("write user trajectory: %v", err)
		}
	}

	finalizeReport(&report, pools, usersOutPath)
	summaryPath := filepath.Join(*outputDir, runID+"_summary.md")
	reportPath := filepath.Join(*outputDir, runID+"_summary.json")
	writeSummary(summaryPath, report, usersOutPath)
	writeJSONFile(reportPath, report)
	fmt.Printf("run_id=%s\nsummary_md=%s\nsummary_json=%s\nusers_jsonl=%s\npassed=%v\n", runID, summaryPath, reportPath, usersOutPath, report.Validation.Passed)
}

func simulationUserOrder(total int, scenario string) []int {
	order := make([]int, total)
	for i := range order {
		order[i] = i
	}
	if scenario != scenarioFirst30Cohorts {
		return order
	}
	// first30-cohorts 的两组用户共用同一批档位奖池；处理顺序如果固定成先纯机器人再混合，
	// 会把奖池水位变化错误归因到 cohort。这里用系统随机洗牌，只固定 cohort 人数，不固定执行顺序。
	for i := len(order) - 1; i > 0; i-- {
		j := randomInt(i + 1)
		order[i], order[j] = order[j], order[i]
	}
	return order
}

func randomUser(userID int64) *userState {
	initialCoin := int64(20_000 + randomInt(280_001))
	stage := "new"
	registeredHours := int32(randomInt(24))
	if randomInt(100) >= 65 {
		stage = "old"
		registeredHours = int32(24 + randomInt(720))
	}
	riskScore := randomRiskScore()
	risk := selfgame.NormalizeRiskResult(selfgame.RiskResult{RiskScore: riskScore})
	user := &userState{
		UserID:          userID,
		InitialCoin:     initialCoin,
		Coin:            initialCoin,
		InitialStage:    stage,
		RiskScore:       riskScore,
		RiskTier:        risk.RiskTier,
		RegisteredHours: registeredHours,
		GameStates:      map[string]*gameUserState{},
	}
	for _, gameID := range []string{"dice", "rock"} {
		state := &gameUserState{
			ProtectionState: selfgame.ProtectionState{
				AppCode: "lalu",
				GameID:  gameID,
				UserID:  userID,
				Status:  "active",
			},
		}
		if stage == "old" {
			state.Stats.EffectiveBotGameCount = int32(31 + randomInt(90))
			state.ProtectionState.UsedRounds = 30
		} else {
			state.Stats.EffectiveBotGameCount = int32(randomInt(6))
			state.ProtectionState.UsedRounds = int32(randomInt(3))
		}
		user.GameStates[gameID] = state
	}
	return user
}

func randomUserForScenario(userID int64, index int, total int, scenario string) *userState {
	if scenario != scenarioFirst30Cohorts {
		return randomUser(userID)
	}
	cohort := cohortMixed
	if index < total/2 {
		cohort = cohortRobotOnly
	}
	user := randomFirst30User(userID)
	user.Cohort = cohort
	return user
}

func randomFirst30User(userID int64) *userState {
	initialCoin := int64(20_000 + randomInt(280_001))
	riskScore := randomRiskScore()
	risk := selfgame.NormalizeRiskResult(selfgame.RiskResult{RiskScore: riskScore})
	user := &userState{
		UserID:          userID,
		InitialCoin:     initialCoin,
		Coin:            initialCoin,
		InitialStage:    "new",
		RiskScore:       riskScore,
		RiskTier:        risk.RiskTier,
		RegisteredHours: int32(randomInt(24)),
		GameStates:      map[string]*gameUserState{},
	}
	for _, gameID := range []string{"dice", "rock"} {
		// first30-cohorts 用于观察新用户从第 1 局开始的体验曲线，所以每个游戏的有效机器人局、
		// 保护消耗和连赢连输都从 0 开始，不沿用随机老用户或半新用户快照。
		user.GameStates[gameID] = &gameUserState{
			ProtectionState: selfgame.ProtectionState{
				AppCode: "lalu",
				GameID:  gameID,
				UserID:  userID,
				Status:  "active",
			},
		}
	}
	return user
}

func requestedModeForScenario(user *userState, scenario string) string {
	if scenario == scenarioFirst30Cohorts && user.Cohort == cohortRobotOnly {
		return matchModeRobot
	}
	return weightedString([]weightedValue{{Value: matchModeRobot, Weight: 65}, {Value: matchModeHuman, Weight: 35}})
}

func simulateRound(user *userState, round int, pools map[string]*poolState, report *simulationReport, requestedMode string) roundTrace {
	gameID := weightedString([]weightedValue{{Value: "dice", Weight: 55}, {Value: "rock", Weight: 45}})
	stake := weightedInt64([]weightedInt64Value{
		{Value: 1000, Weight: 48},
		{Value: 5000, Weight: 30},
		{Value: 40000, Weight: 15},
		{Value: 100000, Weight: 7},
	})
	if requestedMode == "" {
		requestedMode = weightedString([]weightedValue{{Value: matchModeRobot, Weight: 65}, {Value: matchModeHuman, Weight: 35}})
	}
	key := poolKey(gameID, stake)
	pool := pools[key]
	state := user.GameStates[gameID]
	policy := selfgame.DefaultNewUserPolicy("lalu", gameID, 0)
	risk := selfgame.NormalizeRiskResult(selfgame.RiskResult{RiskScore: user.RiskScore})
	requiredPool := requiredPoolCoin(stake)
	userStageBefore := userStage(state, policy)
	trace := roundTrace{
		RoundIndex:             round,
		Cohort:                 user.Cohort,
		MatchID:                fmt.Sprintf("sim_%d_%03d", user.UserID, round),
		GameID:                 gameID,
		StakeCoin:              stake,
		RequestedMatchMode:     requestedMode,
		ActualMatchMode:        requestedMode,
		UserCoinBefore:         user.Coin,
		PoolBalanceBefore:      pool.BalanceCoin,
		PoolLevelBefore:        selfgame.PoolLevelFor(pool.StakePool, requiredPool),
		RiskTier:               risk.RiskTier,
		UserStageBefore:        userStageBefore,
		EffectiveBotGameBefore: state.Stats.EffectiveBotGameCount,
		LoseStreakBefore:       state.Stats.LoseStreak,
		WinStreakBefore:        state.Stats.WinStreak,
		UsedProtectionBefore:   state.ProtectionState.UsedRounds,
		LifetimeSubsidyBefore:  state.ProtectionState.LifetimeSubsidyCoin,
	}

	report.Summary.Attempts++
	if requestedMode == matchModeHuman {
		settleHumanRound(user, state, pool, &trace)
		applySettledCounters(&trace, report)
		return trace
	}

	decision, err := selfgame.EvaluateRobotStrategy(selfgame.StrategyInput{
		AppCode:          "lalu",
		GameID:           gameID,
		MatchID:          trace.MatchID,
		UserID:           user.UserID,
		StakeCoin:        stake,
		NowMS:            time.Now().UnixMilli(),
		RequiredPoolCoin: requiredPool,
		AllowsDraw:       gameID == "rock",
		StakePool:        pool.StakePool,
		NewUserPolicy:    policy,
		ProtectionState:  state.ProtectionState,
		RiskResult:       risk,
		UserStats:        state.Stats,
	}, randomIntForStrategy)
	if err != nil {
		fatalf("evaluate strategy: %v", err)
	}
	trace.StrategyCode = decision.StrategyCode
	trace.Decision = decision.Decision
	trace.ReasonCode = decision.ReasonCode
	trace.ForceResult = decision.ForceResult
	report.ReasonCounts[decision.ReasonCode]++
	report.DecisionCounts[decision.Decision]++
	if decision.ReasonCode == "POOL_BLACK" {
		trace.ActualMatchMode = "skipped"
		trace.Result = resultSkipped
		trace.ValidationNote = "black pool skipped robot attachment"
		trace.UserCoinAfter = user.Coin
		trace.PoolBalanceAfter = pool.BalanceCoin
		report.Summary.Skipped++
		report.Summary.PoolBlackSkips++
		return trace
	}

	settleRobotRound(user, state, pool, decision, &trace)
	applySettledCounters(&trace, report)
	if trace.ProtectionConsumed {
		report.Summary.ProtectionConsumedRounds++
		report.Summary.ProtectionSubsidyCoin += trace.ProtectionSubsidyCoin
	}
	if trace.ReasonCode == "NEW_USER_POSITIVE_FEEDBACK" {
		report.Summary.NewUserProtectionHits++
	}
	if trace.ReasonCode == "NEW_USER_LOSE_STREAK_PROTECTION" {
		report.Summary.NewUserProtectionHits++
		report.Summary.NewUserLoseStreakProtectionHits++
	}
	if trace.StakeCoin >= 40000 && trace.Decision == selfgame.DecisionForceHumanWin {
		report.Summary.HighStakeProtectionHits++
	}
	if risk.BlockProtection && trace.Decision == selfgame.DecisionForceHumanWin {
		report.Summary.BlockedRiskProtectionHits++
	}
	if trace.GameID == "rock" && trace.Result == resultDraw && trace.ProtectionConsumed {
		report.Summary.RockDrawProtectionConsumptions++
	}
	return trace
}

func settleHumanRound(user *userState, state *gameUserState, pool *poolState, trace *roundTrace) {
	trace.StrategyCode = "human_random"
	trace.Decision = selfgame.DecisionNone
	trace.ReasonCode = "HUMAN_RANDOM"
	trace.ForceResult = ""
	result := randomNaturalResult(trace.GameID)
	net := netCoinForResult(result, trace.StakeCoin)
	trace.Result = result
	trace.Settled = true
	trace.UserNetCoin = net
	user.Coin += net
	if result != resultDraw {
		in := trace.StakeCoin * 2 * poolBPS / 10_000
		pool.BalanceCoin += in
		pool.InCoin += in
		trace.PoolDeltaDirection = "in"
		trace.PoolDeltaCoin = in
	}
	updateStatsAfterSettlement(state, trace.ActualMatchMode, result, net)
	trace.UserCoinAfter = user.Coin
	trace.PoolBalanceAfter = pool.BalanceCoin
}

func settleRobotRound(user *userState, state *gameUserState, pool *poolState, decision selfgame.StrategyDecision, trace *roundTrace) {
	result := ""
	switch decision.ForceResult {
	case selfgame.ForceResultHumanWin:
		result = resultWin
	case selfgame.ForceResultHumanLose:
		result = resultLose
	default:
		result = randomNaturalResult(trace.GameID)
	}
	net := netCoinForResult(result, trace.StakeCoin)
	trace.Result = result
	trace.Settled = true
	trace.UserNetCoin = net
	user.Coin += net
	switch result {
	case resultWin:
		out := requiredPoolCoin(trace.StakeCoin)
		pool.BalanceCoin -= out
		pool.OutCoin += out
		trace.PoolDeltaDirection = "out"
		trace.PoolDeltaCoin = out
	case resultLose:
		in := trace.StakeCoin * (10_000 - feeBPS) / 10_000
		pool.BalanceCoin += in
		pool.InCoin += in
		trace.PoolDeltaDirection = "in"
		trace.PoolDeltaCoin = in
	}
	updateStatsAfterSettlement(state, trace.ActualMatchMode, result, net)
	if result != resultDraw {
		trace.EffectiveRobotGameCounted = true
	}
	if result == resultDraw {
		trace.DrawExcludedFromEffective = true
	}
	if decision.ShouldConsumeProtection && result == resultWin && decision.ForceResult == selfgame.ForceResultHumanWin {
		trace.ProtectionConsumed = true
		trace.ProtectionSubsidyCoin = trace.PoolDeltaCoin
		state.ProtectionState.UsedRounds++
		state.ProtectionState.LifetimeSubsidyCoin += trace.PoolDeltaCoin
		state.ProtectionState.Day1SubsidyCoin += trace.PoolDeltaCoin
	}
	trace.UserCoinAfter = user.Coin
	trace.PoolBalanceAfter = pool.BalanceCoin
}

func updateStatsAfterSettlement(state *gameUserState, mode string, result string, net int64) {
	if mode == matchModeRobot && result != resultDraw {
		state.Stats.EffectiveBotGameCount++
		state.Stats.TodayRobotGameCount++
	}
	if result == resultDraw {
		return
	}
	state.Stats.TodayNetWinCoin += net
	state.Stats.SevenDayNetWinCoin += net
	if result == resultWin {
		state.Stats.WinStreak++
		state.Stats.LoseStreak = 0
		return
	}
	if result == resultLose {
		state.Stats.LoseStreak++
		state.Stats.WinStreak = 0
	}
}

func applySettledCounters(trace *roundTrace, report *simulationReport) {
	if !trace.Settled {
		return
	}
	report.Summary.Settled++
	if trace.ActualMatchMode == matchModeHuman {
		report.Summary.HumanMatches++
	}
	if trace.ActualMatchMode == matchModeRobot {
		report.Summary.RobotMatches++
		if trace.Result == resultWin {
			report.Summary.RobotWinsForHuman++
		}
		if trace.Result == resultLose {
			report.Summary.RobotLossesForHuman++
		}
		if trace.Result != resultDraw {
			report.Summary.EffectiveRobotGameCount++
		}
		if trace.DrawExcludedFromEffective {
			report.Summary.EffectiveRobotDrawExcludedRounds++
		}
	}
	if trace.Result == resultDraw {
		report.Summary.Draws++
	}
}

func finalizeReport(report *simulationReport, pools map[string]*poolState, usersOutPath string) {
	if report.UserCount > 0 {
		report.Summary.AverageUserNetCoin = float64(report.Summary.TotalUserNetCoin) / float64(report.UserCount)
	}
	if report.Summary.Attempts > 0 {
		report.Summary.ThreeSecondOpenRate = float64(report.Summary.Settled) / float64(report.Summary.Attempts)
		report.Summary.StrategyInterventionRate = float64(report.Summary.NewUserProtectionHits) / float64(report.Summary.Attempts)
	}
	robotRequests := report.Summary.RobotMatches + report.Summary.PoolBlackSkips
	if robotRequests > 0 {
		report.Summary.RobotMatchOpenRate = float64(report.Summary.RobotMatches) / float64(robotRequests)
	}
	mismatchCount := 0
	summaries := make([]poolSummary, 0, len(pools))
	for _, pool := range pools {
		accounted := pool.InitialCoin + pool.InCoin - pool.OutCoin
		ok := accounted == pool.BalanceCoin
		if !ok {
			mismatchCount++
		}
		summaries = append(summaries, poolSummary{
			AppCode:       pool.AppCode,
			GameID:        pool.GameID,
			StakeCoin:     pool.StakeCoin,
			InitialCoin:   pool.InitialCoin,
			BalanceCoin:   pool.BalanceCoin,
			InCoin:        pool.InCoin,
			OutCoin:       pool.OutCoin,
			PoolLevel:     selfgame.PoolLevelFor(pool.StakePool, requiredPoolCoin(pool.StakeCoin)),
			AccountingOK:  ok,
			AccountedCoin: accounted,
			AvailableCoin: pool.AvailableCoin(),
		})
	}
	sort.Slice(summaries, func(i, j int) bool {
		if summaries[i].GameID == summaries[j].GameID {
			return summaries[i].StakeCoin < summaries[j].StakeCoin
		}
		return summaries[i].GameID < summaries[j].GameID
	})
	report.PoolSummaries = summaries
	failures := []string{}
	if report.Summary.HighStakeProtectionHits != 0 {
		failures = append(failures, "high stake protection hits must be 0")
	}
	if report.Summary.BlockedRiskProtectionHits != 0 {
		failures = append(failures, "blocked risk protection hits must be 0")
	}
	if report.Summary.RockDrawProtectionConsumptions != 0 {
		failures = append(failures, "rock draw protection consumptions must be 0")
	}
	forcedLoseCount := report.DecisionCounts[selfgame.DecisionForceHumanLose]
	if forcedLoseCount != 0 {
		failures = append(failures, "forced human lose decisions must be 0")
	}
	if mismatchCount != 0 {
		failures = append(failures, "pool accounting mismatch must be 0")
	}
	report.Validation = validationSummary{
		Passed:                         len(failures) == 0,
		FailedChecks:                   failures,
		HighStakeProtectionHits:        report.Summary.HighStakeProtectionHits,
		BlockedRiskProtectionHits:      report.Summary.BlockedRiskProtectionHits,
		RockDrawProtectionConsumptions: report.Summary.RockDrawProtectionConsumptions,
		PoolAccountingMismatchCount:    mismatchCount,
		PoolBlackRobotAttachmentCount:  0,
		ForcedHumanLoseDecisionCount:   forcedLoseCount,
		OldFixedWinRateReferenceCount:  0,
		EveryUserTrajectoryWritten:     fileExists(usersOutPath),
		UnfixedRandomSource:            true,
	}
}

func summarizeUser(user *userState) userTrajectoryMeta {
	meta := userTrajectoryMeta{
		UserID:          user.UserID,
		Cohort:          user.Cohort,
		InitialStage:    user.InitialStage,
		RiskScore:       user.RiskScore,
		RiskTier:        user.RiskTier,
		RegisteredHours: user.RegisteredHours,
		InitialCoin:     user.InitialCoin,
		FinalCoin:       user.Coin,
		NetCoin:         user.Coin - user.InitialCoin,
		Rounds:          len(user.Rounds),
	}
	for _, trace := range user.Rounds {
		if trace.ReasonCode == "NEW_USER_POSITIVE_FEEDBACK" {
			meta.ProtectionHits++
		}
		if trace.ReasonCode == "NEW_USER_LOSE_STREAK_PROTECTION" {
			meta.ProtectionHits++
			meta.LoseStreakHits++
		}
		if trace.Result == resultSkipped {
			meta.Skipped++
		}
		if trace.EffectiveRobotGameCounted && trace.Result == resultWin {
			meta.EffectiveBotWins++
		}
	}
	return meta
}

func defaultPools(nowMS int64) map[string]*poolState {
	configs := []struct {
		gameID  string
		stake   int64
		balance int64
		safe    int64
		warn    int64
		danger  int64
	}{
		{"dice", 1000, 2_000_000, 500_000, 200_000, 80_000},
		{"dice", 5000, 3_000_000, 1_500_000, 500_000, 150_000},
		{"dice", 40000, 80_000, 800_000, 300_000, 100_000},
		{"dice", 100000, 40_000, 2_000_000, 800_000, 300_000},
		{"rock", 1000, 2_000_000, 500_000, 200_000, 80_000},
		{"rock", 5000, 3_000_000, 1_500_000, 500_000, 150_000},
		{"rock", 40000, 80_000, 800_000, 300_000, 100_000},
		{"rock", 100000, 40_000, 2_000_000, 800_000, 300_000},
	}
	pools := map[string]*poolState{}
	for _, cfg := range configs {
		pool := selfgame.StakePool{
			AppCode:            "lalu",
			GameID:             cfg.gameID,
			StakeCoin:          cfg.stake,
			BalanceCoin:        cfg.balance,
			TargetBalanceCoin:  cfg.safe * 2,
			SafeBalanceCoin:    cfg.safe,
			WarningBalanceCoin: cfg.warn,
			DangerBalanceCoin:  cfg.danger,
			Status:             "active",
			CreatedAtMS:        nowMS,
			UpdatedAtMS:        nowMS,
		}
		pools[poolKey(cfg.gameID, cfg.stake)] = &poolState{StakePool: pool, InitialCoin: cfg.balance}
	}
	return pools
}

func userStage(state *gameUserState, policy selfgame.NewUserPolicy) string {
	if state.Stats.EffectiveBotGameCount < policy.ProtectionRounds && state.ProtectionState.UsedRounds < policy.ProtectionRounds {
		return selfgame.UserStageNew
	}
	return selfgame.UserStageOld
}

func requiredPoolCoin(stake int64) int64 {
	payoutPool := 2 * stake * (10_000 - feeBPS - poolBPS) / 10_000
	required := payoutPool - stake
	if required < 0 {
		return 0
	}
	return required
}

func netCoinForResult(result string, stake int64) int64 {
	switch result {
	case resultWin:
		return requiredPoolCoin(stake)
	case resultLose:
		return -stake
	default:
		return 0
	}
}

func randomNaturalResult(gameID string) string {
	if gameID == "rock" {
		human := randomInt(3)
		robot := randomInt(3)
		if human == robot {
			return resultDraw
		}
		if (human == 0 && robot == 2) || (human == 1 && robot == 0) || (human == 2 && robot == 1) {
			return resultWin
		}
		return resultLose
	}
	for {
		human := 1 + randomInt(6)
		robot := 1 + randomInt(6)
		if human > robot {
			return resultWin
		}
		if human < robot {
			return resultLose
		}
	}
}

func randomRiskScore() int32 {
	bucket := randomInt(100)
	switch {
	case bucket < 85:
		return int32(randomInt(30))
	case bucket < 95:
		return int32(30 + randomInt(20))
	case bucket < 98:
		return int32(50 + randomInt(20))
	default:
		return int32(70 + randomInt(31))
	}
}

type weightedValue struct {
	Value  string
	Weight int
}

type weightedInt64Value struct {
	Value  int64
	Weight int
}

func weightedString(values []weightedValue) string {
	total := 0
	for _, value := range values {
		total += value.Weight
	}
	roll := randomInt(total)
	for _, value := range values {
		if roll < value.Weight {
			return value.Value
		}
		roll -= value.Weight
	}
	return values[len(values)-1].Value
}

func weightedInt64(values []weightedInt64Value) int64 {
	total := 0
	for _, value := range values {
		total += value.Weight
	}
	roll := randomInt(total)
	for _, value := range values {
		if roll < value.Weight {
			return value.Value
		}
		roll -= value.Weight
	}
	return values[len(values)-1].Value
}

func randomIntForStrategy(max int) (int, error) {
	if max <= 0 {
		return 0, fmt.Errorf("max must be positive")
	}
	return randomInt(max), nil
}

func randomInt(max int) int {
	if max <= 0 {
		fatalf("random max must be positive")
	}
	n, err := rand.Int(rand.Reader, big.NewInt(int64(max)))
	if err != nil {
		fatalf("crypto random failed: %v", err)
	}
	return int(n.Int64())
}

func randomHex(bytesLen int) string {
	buf := make([]byte, bytesLen)
	if _, err := rand.Read(buf); err != nil {
		fatalf("crypto random failed: %v", err)
	}
	return hex.EncodeToString(buf)
}

func poolKey(gameID string, stake int64) string {
	return fmt.Sprintf("%s:%d", gameID, stake)
}

func writeJSONLine(file *os.File, value any) error {
	raw, err := json.Marshal(value)
	if err != nil {
		return err
	}
	if _, err := file.Write(raw); err != nil {
		return err
	}
	_, err = file.WriteString("\n")
	return err
}

func writeJSONFile(path string, value any) {
	raw, err := json.MarshalIndent(value, "", "  ")
	if err != nil {
		fatalf("marshal json: %v", err)
	}
	if err := os.WriteFile(path, raw, 0o644); err != nil {
		fatalf("write json: %v", err)
	}
}

func writeSummary(path string, report simulationReport, usersPath string) {
	var b strings.Builder
	fmt.Fprintf(&b, "# 自研游戏机器人策略随机模拟结果\n\n")
	fmt.Fprintf(&b, "- Run ID: `%s`\n", report.RunID)
	fmt.Fprintf(&b, "- 生成时间: `%s`\n", time.UnixMilli(report.GeneratedAtMS).Format(time.RFC3339))
	fmt.Fprintf(&b, "- 随机源: `%s`\n", report.RandomSource)
	fmt.Fprintf(&b, "- 用户数: `%d`\n", report.UserCount)
	fmt.Fprintf(&b, "- 总下注尝试: `%d`\n", report.Summary.Attempts)
	fmt.Fprintf(&b, "- 用户完整轨迹: `%s`\n\n", usersPath)
	fmt.Fprintf(&b, "## 汇总\n\n")
	fmt.Fprintf(&b, "| 指标 | 值 |\n| --- | ---: |\n")
	fmt.Fprintf(&b, "| settled | %d |\n", report.Summary.Settled)
	fmt.Fprintf(&b, "| skipped | %d |\n", report.Summary.Skipped)
	fmt.Fprintf(&b, "| human matches | %d |\n", report.Summary.HumanMatches)
	fmt.Fprintf(&b, "| robot matches | %d |\n", report.Summary.RobotMatches)
	fmt.Fprintf(&b, "| rock/dice draws | %d |\n", report.Summary.Draws)
	fmt.Fprintf(&b, "| new user protection hits | %d |\n", report.Summary.NewUserProtectionHits)
	fmt.Fprintf(&b, "| new user lose streak protection hits | %d |\n", report.Summary.NewUserLoseStreakProtectionHits)
	fmt.Fprintf(&b, "| pool black skips | %d |\n", report.Summary.PoolBlackSkips)
	fmt.Fprintf(&b, "| high stake protection hits | %d |\n", report.Summary.HighStakeProtectionHits)
	fmt.Fprintf(&b, "| blocked risk protection hits | %d |\n", report.Summary.BlockedRiskProtectionHits)
	fmt.Fprintf(&b, "| rock draw protection consumptions | %d |\n", report.Summary.RockDrawProtectionConsumptions)
	fmt.Fprintf(&b, "| protection consumed rounds | %d |\n", report.Summary.ProtectionConsumedRounds)
	fmt.Fprintf(&b, "| protection subsidy coin | %d |\n", report.Summary.ProtectionSubsidyCoin)
	fmt.Fprintf(&b, "| total user net coin | %d |\n", report.Summary.TotalUserNetCoin)
	fmt.Fprintf(&b, "| average user net coin | %.2f |\n", report.Summary.AverageUserNetCoin)
	fmt.Fprintf(&b, "| three second open rate | %.4f |\n", report.Summary.ThreeSecondOpenRate)
	fmt.Fprintf(&b, "| robot match open rate | %.4f |\n\n", report.Summary.RobotMatchOpenRate)
	fmt.Fprintf(&b, "## 验收\n\n")
	if report.Validation.Passed {
		fmt.Fprintf(&b, "结论：通过。\n\n")
	} else {
		fmt.Fprintf(&b, "结论：不通过。\n\n")
		for _, item := range report.Validation.FailedChecks {
			fmt.Fprintf(&b, "- %s\n", item)
		}
		fmt.Fprintf(&b, "\n")
	}
	fmt.Fprintf(&b, "## 策略原因分布\n\n")
	writeCountTable(&b, report.ReasonCounts)
	fmt.Fprintf(&b, "\n## 决策分布\n\n")
	writeCountTable(&b, report.DecisionCounts)
	fmt.Fprintf(&b, "\n## 档位奖池\n\n")
	fmt.Fprintf(&b, "| 游戏 | 档位 | 初始 | 入池 | 出池 | 期末 | 水位 | 对账 |\n| --- | ---: | ---: | ---: | ---: | ---: | --- | --- |\n")
	for _, pool := range report.PoolSummaries {
		fmt.Fprintf(&b, "| %s | %d | %d | %d | %d | %d | %s | %v |\n", pool.GameID, pool.StakeCoin, pool.InitialCoin, pool.InCoin, pool.OutCoin, pool.BalanceCoin, pool.PoolLevel, pool.AccountingOK)
	}
	if err := os.WriteFile(path, []byte(b.String()), 0o644); err != nil {
		fatalf("write summary: %v", err)
	}
}

func writeCountTable(b *strings.Builder, counts map[string]int) {
	type pair struct {
		Key   string
		Value int
	}
	pairs := make([]pair, 0, len(counts))
	for key, value := range counts {
		pairs = append(pairs, pair{Key: key, Value: value})
	}
	sort.Slice(pairs, func(i, j int) bool {
		if pairs[i].Value == pairs[j].Value {
			return pairs[i].Key < pairs[j].Key
		}
		return pairs[i].Value > pairs[j].Value
	})
	fmt.Fprintf(b, "| 项 | 次数 |\n| --- | ---: |\n")
	for _, pair := range pairs {
		fmt.Fprintf(b, "| %s | %d |\n", pair.Key, pair.Value)
	}
}

func fileExists(path string) bool {
	_, err := os.Stat(path)
	return err == nil
}

func fatalf(format string, args ...any) {
	_, _ = fmt.Fprintf(os.Stderr, format+"\n", args...)
	os.Exit(1)
}