package game

import (
	"bindbox-game/internal/code"
	"bindbox-game/internal/pkg/core"
	"bindbox-game/internal/pkg/logger"
	"bindbox-game/internal/pkg/validation"
	"bindbox-game/internal/repository/mysql"
	"bindbox-game/internal/repository/mysql/dao"
	"bindbox-game/internal/service/game"
	usersvc "bindbox-game/internal/service/user"
	"context"
	"encoding/json"
	"fmt"
	"net/http"
	"strconv"
	"strings"
	"time"

	"github.com/redis/go-redis/v9"
	"go.uber.org/zap"
)

type handler struct {
	logger       logger.CustomLogger
	db           mysql.Repo
	redis        *redis.Client
	ticketSvc    game.TicketService
	gameTokenSvc game.GameTokenService
	userSvc      usersvc.Service
	readDB       *dao.Query
}

func New(l logger.CustomLogger, db mysql.Repo, rdb *redis.Client, userSvc usersvc.Service) *handler {
	return &handler{
		logger:       l,
		db:           db,
		redis:        rdb,
		ticketSvc:    game.NewTicketService(l, db),
		gameTokenSvc: game.NewGameTokenService(l, db, rdb),
		userSvc:      userSvc,
		readDB:       dao.Use(db.GetDbR()),
	}
}

// ========== Admin API ==========

type grantTicketRequest struct {
	GameCode string `json:"game_code" binding:"required"`
	Amount   int    `json:"amount" binding:"required,min=1"`
	Remark   string `json:"remark"`
}

// GrantUserTicket Admin为用户发放游戏资格
// @Summary 发放游戏资格
// @Tags 管理端.游戏
// @Param user_id path int true "用户ID"
// @Param RequestBody body grantTicketRequest true "请求参数"
// @Success 200 {object} map[string]any
// @Router /api/admin/users/{user_id}/game_tickets [post]
func (h *handler) GrantUserTicket() core.HandlerFunc {
	return func(ctx core.Context) {
		userID, err := strconv.ParseInt(ctx.Param("user_id"), 10, 64)
		if err != nil || userID <= 0 {
			ctx.AbortWithError(core.Error(http.StatusBadRequest, code.ParamBindError, "invalid user_id"))
			return
		}

		req := new(grantTicketRequest)
		if err := ctx.ShouldBindJSON(req); err != nil {
			ctx.AbortWithError(core.Error(http.StatusBadRequest, code.ParamBindError, validation.Error(err)))
			return
		}

		err = h.ticketSvc.GrantTicket(ctx.RequestContext(), userID, req.GameCode, req.Amount, "admin", 0, req.Remark)
		if err != nil {
			ctx.AbortWithError(core.Error(http.StatusInternalServerError, code.ServerError, err.Error()))
			return
		}

		ctx.Payload(map[string]any{"success": true})
	}
}

// ListUserTickets Admin查询用户游戏资格日志
// @Summary 查询用户游戏资格日志
// @Tags 管理端.游戏
// @Param user_id path int true "用户ID"
// @Param page query int false "页码"
// @Param page_size query int false "每页数量"
// @Success 200 {object} map[string]any
// @Router /api/admin/users/{user_id}/game_tickets [get]
func (h *handler) ListUserTickets() core.HandlerFunc {
	return func(ctx core.Context) {
		userID, err := strconv.ParseInt(ctx.Param("user_id"), 10, 64)
		if err != nil || userID <= 0 {
			ctx.AbortWithError(core.Error(http.StatusBadRequest, code.ParamBindError, "invalid user_id"))
			return
		}

		var req struct {
			Page     int `form:"page"`
			PageSize int `form:"page_size"`
		}
		_ = ctx.ShouldBindQuery(&req)

		if req.Page <= 0 {
			req.Page = 1
		}
		if req.PageSize <= 0 {
			req.PageSize = 20
		}

		logs, total, err := h.ticketSvc.GetTicketLogs(ctx.RequestContext(), userID, req.Page, req.PageSize)
		if err != nil {
			ctx.AbortWithError(core.Error(http.StatusInternalServerError, code.ServerError, err.Error()))
			return
		}

		ctx.Payload(map[string]any{
			"list":      logs,
			"total":     total,
			"page":      req.Page,
			"page_size": req.PageSize,
		})
	}
}

// ========== App API ==========

// GetMyTickets App获取我的游戏资格
// @Summary 获取我的游戏资格
// @Tags APP端.游戏
// @Param user_id path int true "用户ID"
// @Success 200 {object} map[string]int
// @Router /api/app/users/{user_id}/game_tickets [get]
func (h *handler) GetMyTickets() core.HandlerFunc {
	return func(ctx core.Context) {
		userID := int64(ctx.SessionUserInfo().Id)

		tickets, err := h.ticketSvc.GetUserTickets(ctx.RequestContext(), userID)
		if err != nil {
			ctx.AbortWithError(core.Error(http.StatusInternalServerError, code.ServerError, err.Error()))
			return
		}

		ctx.Payload(tickets)
	}
}

type enterGameRequest struct {
	GameCode string `json:"game_code" binding:"required"`
}

type enterGameResponse struct {
	GameToken      string `json:"game_token"`
	ExpiresAt      string `json:"expires_at"`
	NakamaServer   string `json:"nakama_server"`
	NakamaKey      string `json:"nakama_key"`
	RemainingTimes int    `json:"remaining_times"`
	ClientUrl      string `json:"client_url"`
}

// EnterGame App进入游戏(消耗资格)
// @Summary 进入游戏
// @Tags APP端.游戏
// @Param RequestBody body enterGameRequest true "请求参数"
// @Success 200 {object} enterGameResponse
// @Router /api/app/games/enter [post]
func (h *handler) EnterGame() core.HandlerFunc {
	return func(ctx core.Context) {
		sessionInfo := ctx.SessionUserInfo()
		userID := int64(sessionInfo.Id)
		username := sessionInfo.NickName
		avatar := "" // Avatar not in session, could be fetched from user profile if needed

		req := new(enterGameRequest)
		if err := ctx.ShouldBindJSON(req); err != nil {
			ctx.AbortWithError(core.Error(http.StatusBadRequest, code.ParamBindError, validation.Error(err)))
			return
		}

		// 生成安全的 GameToken (会自动扣减游戏次数)
		gameToken, _, expiresAt, err := h.gameTokenSvc.GenerateToken(
			ctx.RequestContext(),
			userID,
			username,
			avatar,
			req.GameCode,
		)
		if err != nil {
			h.logger.Error("Failed to generate game token", zap.Error(err))
			ctx.AbortWithError(core.Error(http.StatusBadRequest, 180001, "游戏次数不足或生成Token失败"))
			return
		}

		// 查询剩余次数
		remaining := 0
		if req.GameCode == "minesweeper_free" {
			remaining = 999999 // Represent infinite for free mode
		} else {
			ticket, _ := h.ticketSvc.GetUserTicketByGame(ctx.RequestContext(), userID, req.GameCode)
			if ticket != nil {
				remaining = int(ticket.Available)
			}
		}

		// 从系统配置读取Nakama服务器信息
		nakamaServer := "ws://127.0.0.1:7350"
		nakamaKey := "defaultkey"
		clientUrl := "http://127.0.0.1:9991" // 指向当前后端地址作为默认
		configKey := "game_" + req.GameCode + "_config"
		// map generic game code to specific config key if needed, or just use convention
		if req.GameCode == "minesweeper" {
			configKey = "game_minesweeper_config"
		}

		conf, _ := h.readDB.SystemConfigs.WithContext(ctx.RequestContext()).Where(h.readDB.SystemConfigs.ConfigKey.Eq(configKey)).First()
		if conf != nil {
			var gameConfig struct {
				Server    string `json:"server"`
				Key       string `json:"key"`
				ClientUrl string `json:"client_url"`
			}
			if json.Unmarshal([]byte(conf.ConfigValue), &gameConfig) == nil {
				if gameConfig.Server != "" {
					nakamaServer = gameConfig.Server
				}
				if gameConfig.Key != "" {
					nakamaKey = gameConfig.Key
				}
				if gameConfig.ClientUrl != "" {
					clientUrl = gameConfig.ClientUrl
				}
			}
		}

		ctx.Payload(&enterGameResponse{
			GameToken:      gameToken,
			ExpiresAt:      expiresAt.Format("2006-01-02T15:04:05Z07:00"),
			NakamaServer:   nakamaServer,
			NakamaKey:      nakamaKey,
			RemainingTimes: remaining,
			ClientUrl:      clientUrl,
		})
	}
}

// ========== Internal API (Nakama调用) ==========

type validateTokenRequest struct {
	GameToken string `json:"game_token" binding:"required"`
}

type validateTokenResponse struct {
	Valid    bool   `json:"valid"`
	UserID   int64  `json:"user_id,omitempty"`
	Username string `json:"username,omitempty"`
	Avatar   string `json:"avatar,omitempty"`
	GameType string `json:"game_type,omitempty"`
	Ticket   string `json:"ticket,omitempty"`
	Error    string `json:"error,omitempty"`
}

// ValidateGameToken Internal验证GameToken
// @Summary 验证GameToken
// @Tags Internal.游戏
// @Param RequestBody body validateTokenRequest true "请求参数"
// @Success 200 {object} validateTokenResponse
// @Router /internal/game/validate-token [post]
func (h *handler) ValidateGameToken() core.HandlerFunc {
	return func(ctx core.Context) {
		req := new(validateTokenRequest)
		if err := ctx.ShouldBindJSON(req); err != nil {
			ctx.Payload(&validateTokenResponse{Valid: false, Error: "invalid request"})
			return
		}

		claims, err := h.gameTokenSvc.ValidateToken(ctx.RequestContext(), req.GameToken)
		if err != nil {
			h.logger.Warn("GameToken validation failed", zap.Error(err))
			ctx.Payload(&validateTokenResponse{Valid: false, Error: err.Error()})
			return
		}

		ctx.Payload(&validateTokenResponse{
			Valid:    true,
			UserID:   claims.UserID,
			Username: claims.Username,
			Avatar:   claims.Avatar,
			GameType: claims.GameType,
			Ticket:   claims.Ticket,
		})
	}
}

type verifyRequest struct {
	UserID string `json:"user_id"`
	Ticket string `json:"ticket"`
}

type verifyResponse struct {
	Valid      bool           `json:"valid"`
	UserID     string         `json:"user_id"`
	GameConfig map[string]any `json:"game_config,omitempty"`
}

// VerifyTicket Internal验证游戏票据
// @Summary 验证票据
// @Tags Internal.游戏
// @Param RequestBody body verifyRequest true "请求参数"
// @Success 200 {object} verifyResponse
// @Router /internal/game/verify [post]
func (h *handler) VerifyTicket() core.HandlerFunc {
	return func(ctx core.Context) {
		req := new(verifyRequest)
		if err := ctx.ShouldBindJSON(req); err != nil {
			ctx.AbortWithError(core.Error(http.StatusBadRequest, code.ParamBindError, validation.Error(err)))
			return
		}

		// 从Redis验证token
		storedValue, err := h.redis.Get(ctx.RequestContext(), "game:token:ticket:"+req.Ticket).Result()
		if err != nil {
			ctx.Payload(&verifyResponse{Valid: false})
			return
		}

		// Parse "userID:gameType"
		parts := strings.Split(storedValue, ":")
		if len(parts) < 2 {
			ctx.Payload(&verifyResponse{Valid: false})
			return
		}
		storedUserID := parts[0]

		if storedUserID != req.UserID {
			ctx.Payload(&verifyResponse{Valid: false})
			return
		}

		// 获取游戏配置
		gameConfig := make(map[string]any)
		configKey := "game_minesweeper_config"
		conf, err := h.readDB.SystemConfigs.WithContext(ctx.RequestContext()).Where(h.readDB.SystemConfigs.ConfigKey.Eq(configKey)).First()
		if err == nil && conf != nil {
			json.Unmarshal([]byte(conf.ConfigValue), &gameConfig)
		}

		ctx.Payload(&verifyResponse{Valid: true, UserID: req.UserID, GameConfig: gameConfig})
	}
}

type settlePlayerRecord struct {
	UserID          int64  `json:"user_id"`
	Ticket          string `json:"ticket"`
	Win             bool   `json:"win"`
	Rank            int    `json:"rank"`
	Score           int    `json:"score"`
	DamageDealt     int    `json:"damage_dealt"`
	DamageTaken     int    `json:"damage_taken"`
	Kills           int    `json:"kills"`
	ChestsCollected int    `json:"chests_collected"`
	RoundsSurvived  int    `json:"rounds_survived"`
}

type settleRequest struct {
	MatchID     string               `json:"match_id"`
	GameType    string               `json:"game_type"`
	TotalRounds int                  `json:"total_rounds"`
	Players     []settlePlayerRecord `json:"players"`
	// 兼容旧版单人结算字段
	UserID string `json:"user_id"`
	Ticket string `json:"ticket"`
	Win    bool   `json:"win"`
	Score  int    `json:"score"`
}

type settleResponse struct {
	Success bool   `json:"success"`
	Reward  string `json:"reward,omitempty"`
}

func calcRankPoints(rank int) int64 {
	switch rank {
	case 1:
		return 1000
	case 2:
		return -900
	case 3:
		return -1100
	case 4:
		return -1300
	default:
		return 0
	}
}

// SettleGame Internal游戏结算（批量全员）
// @Summary 游戏结算
// @Tags Internal.游戏
// @Param RequestBody body settleRequest true "请求参数"
// @Success 200 {object} settleResponse
// @Router /internal/game/settle [post]
func (h *handler) SettleGame() core.HandlerFunc {
	return func(ctx core.Context) {
		req := new(settleRequest)
		if err := ctx.ShouldBindJSON(req); err != nil {
			ctx.AbortWithError(core.Error(http.StatusBadRequest, code.ParamBindError, validation.Error(err)))
			return
		}

		// 兼容旧版单人结算（Nakama 未升级时的过渡）
		if len(req.Players) == 0 && req.UserID != "" {
			uid, _ := strconv.ParseInt(req.UserID, 10, 64)
			if uid > 0 {
				rank := 2
				if req.Win {
					rank = 1
				}
				req.Players = []settlePlayerRecord{{
					UserID: uid,
					Ticket: req.Ticket,
					Win:    req.Win,
					Rank:   rank,
					Score:  req.Score,
				}}
				if req.GameType == "" {
					req.GameType = "minesweeper"
				}
			}
		}

		if len(req.Players) == 0 {
			ctx.Payload(&settleResponse{Success: true})
			return
		}

		// 幂等检查：match_id 已结算则直接返回
		if req.MatchID != "" {
			var count int64
			h.db.GetDbR().Table("minesweeper_game_records").Where("match_id = ?", req.MatchID).Count(&count)
			if count > 0 {
				h.logger.Info("Game already settled, skip", zap.String("match_id", req.MatchID))
				ctx.Payload(&settleResponse{Success: true})
				return
			}
		}

		isFreeMode := req.GameType == "minesweeper_free"
		now := time.Now()

		// 读取奖励配置（付费场用）
		var msConfig struct {
			WinnerRewardPoints        int64 `json:"winner_reward_points"`
			WinnerRewardProductID     int64 `json:"winner_reward_product_id"`
			ParticipationRewardPoints int64 `json:"participation_reward_points"`
		}
		if !isFreeMode {
			conf, _ := h.readDB.SystemConfigs.WithContext(ctx.RequestContext()).
				Where(h.readDB.SystemConfigs.ConfigKey.Eq("game_minesweeper_config")).First()
			if conf != nil {
				json.Unmarshal([]byte(conf.ConfigValue), &msConfig)
			}
		}

		for _, p := range req.Players {
			// 兜底：旧客户端漏传 Rank 时按 Win 推断
			rank := p.Rank
			if rank == 0 {
				rank = 2
				if p.Win {
					rank = 1
				}
			}
			p.Rank = rank
			p.Win = p.Rank == 1
			rankPoints := calcRankPoints(p.Rank)

			rawJSON, _ := json.Marshal(p)

			// 写入游戏记录（忽略 duplicate key 错误）
			h.db.GetDbW().Exec(`
				INSERT IGNORE INTO minesweeper_game_records
				(match_id, user_id, game_type, ticket, is_winner, rank_position, total_players,
				 total_rounds, rounds_survived, score, damage_dealt, damage_taken, kills,
				 chests_collected, rank_points, raw_summary, settled_at, created_at)
				VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
				req.MatchID, p.UserID, req.GameType, p.Ticket,
				p.Win, p.Rank, len(req.Players),
				req.TotalRounds, p.RoundsSurvived, p.Score,
				p.DamageDealt, p.DamageTaken, p.Kills,
				p.ChestsCollected, rankPoints, string(rawJSON), now, now,
			)

			// UPSERT 聚合榜
			wins, losses := 0, 1
			if p.Win {
				wins, losses = 1, 0
			}
			h.db.GetDbW().Exec(`
				INSERT INTO minesweeper_leaderboard
				(user_id, game_type, matches_played, wins, losses, win_rate,
				 total_score, best_score, avg_score,
				 total_damage_dealt, total_damage_taken, avg_damage_dealt,
				 total_chests_collected, total_rounds_survived,
				 total_rank_points, last_match_id, last_settled_at, created_at, updated_at)
				VALUES (?, ?, 1, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
				ON DUPLICATE KEY UPDATE
				  matches_played = matches_played + 1,
				  wins = wins + VALUES(wins),
				  losses = losses + VALUES(losses),
				  win_rate = ROUND((wins + VALUES(wins)) / (matches_played + 1), 4),
				  total_score = total_score + VALUES(total_score),
				  best_score = GREATEST(best_score, VALUES(best_score)),
				  avg_score = ROUND((total_score + VALUES(total_score)) / (matches_played + 1), 2),
				  total_damage_dealt = total_damage_dealt + VALUES(total_damage_dealt),
				  total_damage_taken = total_damage_taken + VALUES(total_damage_taken),
				  avg_damage_dealt = ROUND((total_damage_dealt + VALUES(total_damage_dealt)) / (matches_played + 1), 2),
				  total_chests_collected = total_chests_collected + VALUES(total_chests_collected),
				  total_rounds_survived = total_rounds_survived + VALUES(total_rounds_survived),
				  total_rank_points = total_rank_points + VALUES(total_rank_points),
				  last_match_id = VALUES(last_match_id),
				  last_settled_at = VALUES(last_settled_at),
				  updated_at = VALUES(updated_at)`,
				p.UserID, req.GameType, wins, losses, float64(wins),
				p.Score, p.Score, float64(p.Score),
				p.DamageDealt, p.DamageTaken, float64(p.DamageDealt),
				p.ChestsCollected, p.RoundsSurvived,
				rankPoints, req.MatchID, now, now, now,
			)

			// 清除 Redis ticket
			if p.Ticket != "" {
				h.redis.Del(ctx.RequestContext(), "game:token:ticket:"+p.Ticket)
			}

			// 付费场发奖励（仅赢家）
			if !isFreeMode && p.Win && p.UserID > 0 {
				if msConfig.WinnerRewardProductID > 0 {
					h.userSvc.GrantReward(ctx.RequestContext(), p.UserID, usersvc.GrantRewardRequest{
						ProductID: msConfig.WinnerRewardProductID,
						Quantity:  1,
						Remark:    "扫雷游戏奖励",
					})
				} else {
					pts := msConfig.WinnerRewardPoints
					if pts == 0 {
						pts = 100
					}
					h.userSvc.AddPointsWithAction(ctx.RequestContext(), p.UserID, pts, "game_reward", "扫雷游戏奖励", "minesweeper_settle", nil, nil)
				}
			}
		}

		// 异步刷新排行榜缓存
		go h.refreshLeaderboardCache(req.GameType)

		ctx.Payload(&settleResponse{Success: true})
	}
}

func (h *handler) refreshLeaderboardCache(gameType string) {
	type lbRow struct {
		UserID             int64   `json:"user_id"`
		Nickname           string  `json:"nickname"`
		Avatar             string  `json:"avatar"`
		TotalRankPoints    int64   `json:"total_rank_points"`
		MatchesPlayed      int     `json:"matches_played"`
		Wins               int     `json:"wins"`
		Losses             int     `json:"losses"`
		WinRate            float64 `json:"win_rate"`
		BestScore          int     `json:"best_score"`
		AvgScore           float64 `json:"avg_score"`
		AvgDamageDealt     float64 `json:"avg_damage_dealt"`
		TotalChests        int64   `json:"total_chests_collected"`
	}

	var rows []lbRow
	h.db.GetDbR().Raw(`
		SELECT l.user_id,
		       COALESCE(u.nick_name, '') AS nickname,
		       COALESCE(u.avatar_url, '') AS avatar,
		       l.total_rank_points, l.matches_played, l.wins, l.losses,
		       CAST(l.win_rate AS DECIMAL(7,4)) AS win_rate,
		       l.best_score,
		       CAST(l.avg_score AS DECIMAL(12,2)) AS avg_score,
		       CAST(l.avg_damage_dealt AS DECIMAL(12,2)) AS avg_damage_dealt,
		       l.total_chests_collected
		FROM minesweeper_leaderboard l
		LEFT JOIN users u ON u.id = l.user_id
		WHERE l.game_type = ?
		ORDER BY l.total_rank_points DESC, l.wins DESC, l.best_score DESC, l.user_id ASC
		LIMIT 100`, gameType).Scan(&rows)

	if len(rows) == 0 {
		return
	}
	data, _ := json.Marshal(rows)
	cacheKey := fmt.Sprintf("ms:lb:v1:%s:top100", gameType)
	h.redis.Set(context.Background(), cacheKey, string(data), 5*time.Minute)
}

type consumeTicketRequest struct {
	UserID   string `json:"user_id"`
	GameCode string `json:"game_code"`
	Ticket   string `json:"ticket"`
}

type consumeTicketResponse struct {
	Success bool   `json:"success"`
	Error   string `json:"error,omitempty"`
}

// ConsumeTicket Internal扣减游戏次数（匹配成功后由Nakama调用）
// @Summary 扣减游戏次数
// @Tags Internal.游戏
// @Param RequestBody body consumeTicketRequest true "请求参数"
// @Success 200 {object} consumeTicketResponse
// @Router /internal/game/consume-ticket [post]
func (h *handler) ConsumeTicket() core.HandlerFunc {
	return func(ctx core.Context) {
		req := new(consumeTicketRequest)
		if err := ctx.ShouldBindJSON(req); err != nil {
			ctx.Payload(&consumeTicketResponse{Success: false, Error: "参数错误"})
			return
		}

		uid, _ := strconv.ParseInt(req.UserID, 10, 64)
		if uid <= 0 {
			ctx.Payload(&consumeTicketResponse{Success: false, Error: "无效的用户ID"})
			return
		}

		gameCode := req.GameCode
		if gameCode == "" {
			gameCode = "minesweeper"
		}

		// 扣减游戏次数
		if gameCode == "minesweeper_free" {
			// 免费场场不扣减次数，直接通过
			h.logger.Info("Free mode consume ticket skipped deduction", zap.Int64("user_id", uid))
		} else {
			err := h.ticketSvc.UseTicket(ctx.RequestContext(), uid, gameCode)
			if err != nil {
				h.logger.Error("Failed to consume ticket", zap.Int64("user_id", uid), zap.String("game_code", gameCode), zap.Error(err))
				ctx.Payload(&consumeTicketResponse{Success: false, Error: err.Error()})
				return
			}
		}

		// 使 ticket 失效（防止重复扣减）
		if req.Ticket != "" {
			h.gameTokenSvc.InvalidateTicket(ctx.RequestContext(), req.Ticket)
		}

		h.logger.Info("Ticket consumed on match success", zap.Int64("user_id", uid), zap.String("game_code", gameCode))
		ctx.Payload(&consumeTicketResponse{Success: true})
	}
}

// GetMinesweeperConfig Internal获取扫雷配置
// @Summary 获取扫雷配置
// @Tags Internal.游戏
// @Success 200 {object} map[string]interface{}
// @Router /internal/game/minesweeper/config [get]
func (h *handler) GetMinesweeperConfig() core.HandlerFunc {
	return func(ctx core.Context) {
		configKey := "game_minesweeper_config"
		conf, err := h.readDB.SystemConfigs.WithContext(ctx.RequestContext()).Where(h.readDB.SystemConfigs.ConfigKey.Eq(configKey)).First()
		if err != nil {
			ctx.AbortWithError(core.Error(http.StatusBadRequest, code.ServerError, "获取配置失败"))
			return
		}

		var gameConfig map[string]interface{}
		if err := json.Unmarshal([]byte(conf.ConfigValue), &gameConfig); err != nil {
			ctx.AbortWithError(core.Error(http.StatusBadRequest, code.ServerError, "解析配置失败"))
			return
		}

		ctx.Payload(gameConfig)
	}
}

// GetLeaderboard App端排行榜查询
// @Summary 扫雷排行榜
// @Tags APP端.游戏
// @Param game_type query string false "游戏类型 minesweeper|minesweeper_free"
// @Param page query int false "页码"
// @Param page_size query int false "每页数量"
// @Success 200 {object} map[string]any
// @Router /api/app/games/leaderboard [get]
func (h *handler) GetLeaderboard() core.HandlerFunc {
	return func(ctx core.Context) {
		var req struct {
			GameType string `form:"game_type"`
			Page     int    `form:"page"`
			PageSize int    `form:"page_size"`
		}
		_ = ctx.ShouldBindQuery(&req)
		if req.GameType == "" {
			req.GameType = "minesweeper"
		}
		if req.Page <= 0 {
			req.Page = 1
		}
		if req.PageSize <= 0 || req.PageSize > 100 {
			req.PageSize = 20
		}

		si := ctx.SessionUserInfo()
		myUserID := int64(si.Id)

		gameType := req.GameType
		page := req.Page
		pageSize := req.PageSize

		// 直接查 MySQL（实时数据，不走缓存）
		type lbRow struct {
			UserID          int64   `json:"user_id"`
			Nickname        string  `json:"nickname"`
			Avatar          string  `json:"avatar"`
			TotalRankPoints int64   `json:"total_rank_points"`
			MatchesPlayed   int     `json:"matches_played"`
			Wins            int     `json:"wins"`
			Losses          int     `json:"losses"`
			WinRate         float64 `json:"win_rate"`
			BestScore       int     `json:"best_score"`
			AvgScore        float64 `json:"avg_score"`
		}

		var rows []lbRow
		var total int64
		offset := (page - 1) * pageSize

		h.db.GetDbR().Table("minesweeper_leaderboard").Where("game_type = ?", gameType).Count(&total)
		h.db.GetDbR().Raw(`
			SELECT l.user_id,
			       COALESCE(u.nick_name, '') AS nickname,
			       COALESCE(u.avatar_url, '') AS avatar,
			       l.total_rank_points, l.matches_played, l.wins, l.losses,
			       CAST(l.win_rate AS DECIMAL(7,4)) AS win_rate,
			       l.best_score,
			       CAST(l.avg_score AS DECIMAL(12,2)) AS avg_score
			FROM minesweeper_leaderboard l
			LEFT JOIN users u ON u.id = l.user_id
			WHERE l.game_type = ?
			ORDER BY l.total_rank_points DESC, l.wins DESC, l.best_score DESC, l.user_id ASC
			LIMIT ? OFFSET ?`, gameType, pageSize, offset).Scan(&rows)

		// 补名次
		list := make([]map[string]any, 0, len(rows))
		for i, r := range rows {
			m := map[string]any{
				"rank":              offset + i + 1,
				"user_id":          r.UserID,
				"nickname":         r.Nickname,
				"avatar":           r.Avatar,
				"total_rank_points": r.TotalRankPoints,
				"matches_played":   r.MatchesPlayed,
				"wins":             r.Wins,
				"losses":           r.Losses,
				"win_rate":         r.WinRate,
				"best_score":       r.BestScore,
				"avg_score":        r.AvgScore,
			}
			list = append(list, m)
		}

		ctx.Payload(map[string]any{
			"game_type": gameType,
			"page":      page,
			"page_size": pageSize,
			"total":     total,
			"list":      list,
			"me":        h.queryMyRank(ctx.RequestContext(), myUserID, gameType),
		})
	}
}

// GetLeaderboardInternal 内部排行榜查询（供 Nakama RPC 代理）
func (h *handler) GetLeaderboardInternal() core.HandlerFunc {
	return h.GetLeaderboard()
}

func (h *handler) queryMyRank(ctx context.Context, userID int64, gameType string) map[string]any {
	if userID <= 0 {
		return nil
	}
	var count int64
	h.db.GetDbR().Table("minesweeper_leaderboard").
		Where("user_id = ? AND game_type = ?", userID, gameType).
		Count(&count)
	if count == 0 {
		return nil
	}
	var myPoints int64
	h.db.GetDbR().Table("minesweeper_leaderboard").
		Select("total_rank_points").
		Where("user_id = ? AND game_type = ?", userID, gameType).
		Scan(&myPoints)
	var myRank int64
	h.db.GetDbR().Table("minesweeper_leaderboard").
		Where("game_type = ? AND total_rank_points > ?", gameType, myPoints).
		Count(&myRank)

	var row struct {
		Wins          int     `json:"wins"`
		MatchesPlayed int     `json:"matches_played"`
		WinRate       float64 `json:"win_rate"`
		BestScore     int     `json:"best_score"`
	}
	h.db.GetDbR().Table("minesweeper_leaderboard").
		Select("wins, matches_played, CAST(win_rate AS DECIMAL(7,4)) as win_rate, best_score").
		Where("user_id = ? AND game_type = ?", userID, gameType).
		Scan(&row)

	return map[string]any{
		"rank":              myRank + 1,
		"user_id":          userID,
		"total_rank_points": myPoints,
		"wins":             row.Wins,
		"matches_played":   row.MatchesPlayed,
		"win_rate":         row.WinRate,
		"best_score":       row.BestScore,
	}
}

// ========== Admin API: 排行榜 & 对战记录 ==========

// GetAdminLeaderboard Admin查询扫雷排行榜
// @Summary 查询扫雷排行榜
// @Tags 管理端.游戏
// @Param page query int false "页码"
// @Param page_size query int false "每页数量"
// @Param nickname query string false "按玩家昵称模糊搜索"
// @Success 200 {object} map[string]any
// @Router /api/admin/games/leaderboard [get]
func (h *handler) GetAdminLeaderboard() core.HandlerFunc {
	return func(ctx core.Context) {
		var req struct {
			Page     int    `form:"page"`
			PageSize int    `form:"page_size"`
			Nickname string `form:"nickname"`
		}
		_ = ctx.ShouldBindQuery(&req)
		if req.Page <= 0 {
			req.Page = 1
		}
		if req.PageSize <= 0 || req.PageSize > 100 {
			req.PageSize = 20
		}
		offset := (req.Page - 1) * req.PageSize

		type lbRow struct {
			UserID          int64   `json:"user_id"`
			Nickname        string  `json:"nickname"`
			Avatar          string  `json:"avatar"`
			TotalRankPoints int64   `json:"total_rank_points"`
			MatchesPlayed   int     `json:"matches_played"`
			Wins            int     `json:"wins"`
			Losses          int     `json:"losses"`
			WinRate         float64 `json:"win_rate"`
			BestScore       int     `json:"best_score"`
			AvgScore        float64 `json:"avg_score"`
		}

		query := h.db.GetDbR().Table("minesweeper_leaderboard l").
			Select("l.user_id, COALESCE(u.nick_name,'') AS nickname, COALESCE(u.avatar_url,'') AS avatar, l.total_rank_points, l.matches_played, l.wins, l.losses, CAST(l.win_rate AS DECIMAL(7,4)) AS win_rate, l.best_score, CAST(l.avg_score AS DECIMAL(12,2)) AS avg_score").
			Joins("LEFT JOIN users u ON u.id = l.user_id").
			Where("l.game_type = ?", "minesweeper")

		if req.Nickname != "" {
			query = query.Where("u.nick_name LIKE ?", "%"+req.Nickname+"%")
		}

		var total int64
		query.Count(&total)

		var rows []lbRow
		query.Order("l.total_rank_points DESC, l.wins DESC, l.best_score DESC").
			Limit(req.PageSize).Offset(offset).Scan(&rows)

		list := make([]map[string]any, 0, len(rows))
		for i, r := range rows {
			list = append(list, map[string]any{
				"rank":               offset + i + 1,
				"user_id":            r.UserID,
				"nickname":           r.Nickname,
				"avatar":             r.Avatar,
				"total_rank_points":  r.TotalRankPoints,
				"matches_played":     r.MatchesPlayed,
				"wins":               r.Wins,
				"losses":             r.Losses,
				"win_rate":           r.WinRate,
				"best_score":         r.BestScore,
				"avg_score":          r.AvgScore,
			})
		}

		ctx.Payload(map[string]any{
			"total":     total,
			"page":      req.Page,
			"page_size": req.PageSize,
			"list":      list,
		})
	}
}

// GetAdminGameRecords Admin查询扫雷对战记录
// @Summary 查询扫雷对战记录
// @Tags 管理端.游戏
// @Param page query int false "页码"
// @Param page_size query int false "每页数量"
// @Param user_id query int false "按用户ID筛选"
// @Param match_id query string false "按局ID筛选"
// @Success 200 {object} map[string]any
// @Router /api/admin/games/records [get]
func (h *handler) GetAdminGameRecords() core.HandlerFunc {
	return func(ctx core.Context) {
		var req struct {
			Page     int    `form:"page"`
			PageSize int    `form:"page_size"`
			UserID   int64  `form:"user_id"`
			MatchID  string `form:"match_id"`
		}
		_ = ctx.ShouldBindQuery(&req)
		if req.Page <= 0 {
			req.Page = 1
		}
		if req.PageSize <= 0 || req.PageSize > 100 {
			req.PageSize = 20
		}
		offset := (req.Page - 1) * req.PageSize

		type recRow struct {
			ID              int64  `json:"id"`
			MatchID         string `json:"match_id"`
			UserID          int64  `json:"user_id"`
			Nickname        string `json:"nickname"`
			IsWinner        bool   `json:"is_winner"`
			RankPosition    int    `json:"rank_position"`
			TotalPlayers    int    `json:"total_players"`
			Score           int    `json:"score"`
			DamageDealt     int    `json:"damage_dealt"`
			ChestsCollected int    `json:"chests_collected"`
			RankPoints      int    `json:"rank_points"`
			SettledAt       string `json:"settled_at"`
		}

		query := h.db.GetDbR().Table("minesweeper_game_records r").
			Select("r.id, r.match_id, r.user_id, COALESCE(u.nick_name,'') AS nickname, r.is_winner, r.rank_position, r.total_players, r.score, r.damage_dealt, r.chests_collected, r.rank_points, r.settled_at").
			Joins("LEFT JOIN users u ON u.id = r.user_id").
			Where("r.game_type = ?", "minesweeper")

		if req.UserID > 0 {
			query = query.Where("r.user_id = ?", req.UserID)
		}
		if req.MatchID != "" {
			query = query.Where("r.match_id = ?", req.MatchID)
		}

		var total int64
		query.Count(&total)

		var rows []recRow
		query.Order("r.settled_at DESC").Limit(req.PageSize).Offset(offset).Scan(&rows)

		ctx.Payload(map[string]any{
			"total":     total,
			"page":      req.Page,
			"page_size": req.PageSize,
			"list":      rows,
		})
	}
}

// ========== Helpers ==========

func generateTicketToken(userID int64) string {
	return "GT" + randomString(16)
}

func randomString(n int) string {
	const letters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
	b := make([]byte, n)
	for i := range b {
		b[i] = letters[i%len(letters)]
	}
	return string(b)
}