package app

import (
	"bindbox-game/internal/pkg/logger"
	"bindbox-game/internal/repository/mysql/dao"
	"bindbox-game/internal/repository/mysql/model"
	usersvc "bindbox-game/internal/service/user"
	"context"
	"crypto/hmac"
	"crypto/sha256"
	"encoding/binary"
	"encoding/hex"
	"encoding/json"
	"fmt"
	"sync"
	"time"

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

// CardType 卡牌类型
type CardType string

// CardTypeConfig 卡牌类型配置（从数据库加载）
type CardTypeConfig struct {
	Code     CardType `json:"code"`
	Name     string   `json:"name"`
	ImageURL string   `json:"image_url"`
	Quantity int32    `json:"quantity"`
}

// MatchingCard 游戏中的卡牌实例
type MatchingCard struct {
	ID   string   `json:"id"`
	Type CardType `json:"type"`
}

// MatchingGame 对对碰游戏结构
type MatchingGame struct {
	Mu               sync.Mutex            `json:"-"` // 互斥锁保护并发访问
	ServerSeed       []byte                `json:"server_seed"`
	ServerSeedHash   string                `json:"server_seed_hash"`
	Nonce            int64                 `json:"nonce"`
	CardConfigs      []CardTypeConfig      `json:"card_configs"`
	Deck             []*MatchingCard       `json:"deck"`            // 牌堆 (预生成的卡牌对象)
	Board            [9]*MatchingCard      `json:"board"`           // 固定9格棋盘
	CardIDCounter    int64                 `json:"card_id_counter"` // 用于生成唯一ID
	TotalPairs       int64                 `json:"total_pairs"`
	MaxPossiblePairs int64                 `json:"max_possible_pairs"` // 最大可能消除对数 (安全校验)
	Round            int64                 `json:"round"`
	RoundHistory     []MatchingRoundResult `json:"round_history"`
	LastActivity     time.Time             `json:"last_activity"`

	// Context info for reward granting
	ActivityID int64 `json:"activity_id"`
	IssueID    int64 `json:"issue_id"`
	OrderID    int64 `json:"order_id"`
	UserID     int64 `json:"user_id"`
}

type MatchingRoundResult struct {
	Round       int64            `json:"round"`
	Board       [9]*MatchingCard `json:"board"`
	Pairs       []MatchingPair   `json:"pairs"`
	PairsCount  int64            `json:"pairs_count"`
	DrawnCards  []DrawnCardInfo  `json:"drawn_cards"` // 优化：包含位置信息
	Reshuffled  bool             `json:"reshuffled"`
	CanContinue bool             `json:"can_continue"`
}

type DrawnCardInfo struct {
	SlotIndex int          `json:"slot_index"`
	Card      MatchingCard `json:"card"`
}

type MatchingPair struct {
	CardType    CardType `json:"card_type"`
	Count       int64    `json:"count"`
	CardIDs     []string `json:"card_ids"`
	SlotIndices []int    `json:"slot_indices"` // 新增：消除的格子索引
}

// loadCardTypesFromDB 从数据库加载启用的卡牌类型配置
func loadCardTypesFromDB(ctx context.Context, readDB *dao.Query) ([]CardTypeConfig, error) {
	items, err := readDB.MatchingCardTypes.WithContext(ctx).Where(readDB.MatchingCardTypes.Status.Eq(1)).Order(readDB.MatchingCardTypes.Sort.Asc()).Find()
	if err != nil {
		return nil, err
	}
	configs := make([]CardTypeConfig, len(items))
	for i, item := range items {
		configs[i] = CardTypeConfig{
			Code:     CardType(item.Code),
			Name:     item.Name,
			ImageURL: item.ImageURL,
			Quantity: item.Quantity,
		}
	}
	return configs, nil
}

// NewMatchingGameWithConfig 使用数据库配置创建游戏
// position: 用户选择的位置（可选），用于增加随机熵值
// masterSeed: 活动的主承诺种子（可选），如果提供则用作随机源的基础
func NewMatchingGameWithConfig(configs []CardTypeConfig, position string, masterSeed []byte) *MatchingGame {
	g := &MatchingGame{
		CardConfigs:  configs,
		RoundHistory: []MatchingRoundResult{},
		Board:        [9]*MatchingCard{},
		LastActivity: time.Now(),
	}

	// 生成服务器种子 - 必须有 masterSeed（承诺）
	if len(masterSeed) == 0 {
		// 没有承诺则返回 nil（让调用方处理错误）
		return nil
	}

	// 使用主承诺种子作为基础
	// ServerSeed = HMAC(MasterSeed, Position + Timestamp)
	// 这样保证了基于主承诺的确定性派生
	h := hmac.New(sha256.New, masterSeed)
	h.Write([]byte(position))
	h.Write([]byte(fmt.Sprintf("%d", time.Now().UnixNano())))
	g.ServerSeed = h.Sum(nil) // 32 bytes

	hash := sha256.Sum256(g.ServerSeed)
	g.ServerSeedHash = fmt.Sprintf("%x", hash)

	// 根据配置生成所有卡牌 (99张)
	totalCards := 0
	for _, cfg := range configs {
		totalCards += int(cfg.Quantity)
	}
	// 创建所有卡牌对象
	g.CardIDCounter = 0
	allCards := make([]*MatchingCard, 0, totalCards)
	for _, cfg := range configs {
		for i := int32(0); i < cfg.Quantity; i++ {
			// 创建卡牌对象
			g.CardIDCounter++
			id := fmt.Sprintf("c%d", g.CardIDCounter)
			mc := &MatchingCard{
				ID:   id,
				Type: cfg.Code,
			}
			allCards = append(allCards, mc)
		}
	}
	g.Deck = allCards

	// 安全洗牌
	g.secureShuffle()

	// 初始填充棋盘
	for i := 0; i < 9; i++ {
		if len(g.Deck) > 0 {
			// 从牌堆顶取一张
			card := g.Deck[0]
			g.Deck = g.Deck[1:]
			g.Board[i] = card
		} else {
			g.Board[i] = nil
		}
	}

	// 计算理论最大对数 (Sanity Check)
	// 遍历所有生成的卡牌配置
	var theoreticalMax int64
	for _, cfg := range configs {
		pairs := int64(cfg.Quantity / 2)
		theoreticalMax += pairs // 向下取整，每2张算1对
		fmt.Printf("[对对碰生成] 卡牌类型:%s(%s) 数量:%d 可组成对数:%d\n", cfg.Code, cfg.Name, cfg.Quantity, pairs)
	}
	g.MaxPossiblePairs = theoreticalMax
	fmt.Printf("[对对碰生成] 总卡牌数:%d 理论最大对数:%d\n", totalCards, theoreticalMax)

	return g
}

// getCardConfig 获取指定卡牌类型的配置
func (g *MatchingGame) getCardConfig(cardType CardType) *CardTypeConfig {
	for i := range g.CardConfigs {
		if g.CardConfigs[i].Code == cardType {
			return &g.CardConfigs[i]
		}
	}
	return nil
}

// secureShuffle 使用 HMAC-SHA256 的 Fisher-Yates 洗牌
func (g *MatchingGame) secureShuffle() {
	n := len(g.Deck)
	for i := n - 1; i > 0; i-- {
		j := g.secureRandInt(i+1, fmt.Sprintf("shuffle:%d", i))
		g.Deck[i], g.Deck[j] = g.Deck[j], g.Deck[i]
	}
}

// secureRandInt 使用 HMAC-SHA256 生成安全随机数
func (g *MatchingGame) secureRandInt(max int, context string) int {
	g.Nonce++
	message := fmt.Sprintf("%s|nonce:%d", context, g.Nonce)
	mac := hmac.New(sha256.New, g.ServerSeed)
	mac.Write([]byte(message))
	sum := mac.Sum(nil)
	val := binary.BigEndian.Uint64(sum[:8])
	return int(val % uint64(max))
}

// reshuffleBoard 重洗棋盘和牌堆
func (g *MatchingGame) reshuffleBoard() {
	// 1. 回收所有卡牌（板上 + 牌堆）
	tempDeck := make([]*MatchingCard, 0, len(g.Deck)+9)
	tempDeck = append(tempDeck, g.Deck...)
	for i := 0; i < 9; i++ {
		if g.Board[i] != nil {
			tempDeck = append(tempDeck, g.Board[i])
			g.Board[i] = nil
		}
	}

	// 2. 循环尝试洗牌，直到开局有解（或者尝试一定次数）
	// 尝试最多 10 次，寻找一个起手就有解的局面
	bestDeck := make([]*MatchingCard, len(tempDeck))
	copy(bestDeck, tempDeck)

	for retry := 0; retry < 10; retry++ {
		// 复制一份进行尝试
		currentDeck := make([]*MatchingCard, len(tempDeck))
		copy(currentDeck, tempDeck)
		g.Deck = currentDeck
		g.secureShuffle()

		// 检查前9张（或更少）是否有对子
		checkCount := 9
		if len(g.Deck) < 9 {
			checkCount = len(g.Deck)
		}

		counts := make(map[CardType]int)
		hasPair := false
		for k := 0; k < checkCount; k++ {
			t := g.Deck[k].Type
			counts[t]++
			if counts[t] >= 2 {
				hasPair = true
				break
			}
		}

		if hasPair {
			// 找到有解的洗牌结果，采用之
			// g.deck 已经是洗好的状态
			break
		}
	}

	// 3. 重新填满棋盘
	for i := 0; i < 9; i++ {
		if len(g.Deck) > 0 {
			card := g.Deck[0]
			g.Deck = g.Deck[1:]
			g.Board[i] = card
		} else {
			g.Board[i] = nil
		}
	}
}

// GetGameState 获取游戏状态
func (g *MatchingGame) GetGameState() map[string]any {
	return map[string]any{
		"board":            g.Board,
		"deck_count":       len(g.Deck),
		"total_pairs":      g.TotalPairs,
		"round":            g.Round,
		"server_seed_hash": g.ServerSeedHash,
	}
}

// Redis Key Prefix
const matchingGameKeyPrefix = "bindbox:matching_game:"

// saveGameToRedis 保存游戏状态到 Redis
func (h *handler) saveGameToRedis(ctx context.Context, gameID string, game *MatchingGame) error {
	data, err := json.Marshal(game)
	if err != nil {
		return err
	}
	// TTL: 30 minutes
	return h.redis.Set(ctx, matchingGameKeyPrefix+gameID, data, 30*time.Minute).Err()
}

// loadGameFromRedis 从 Redis 加载游戏状态
// 如果 Redis 中没有找到，则尝试从数据库恢复
func (h *handler) loadGameFromRedis(ctx context.Context, gameID string) (*MatchingGame, error) {
	data, err := h.redis.Get(ctx, matchingGameKeyPrefix+gameID).Bytes()
	if err == nil {
		var game MatchingGame
		if err := json.Unmarshal(data, &game); err != nil {
			return nil, err
		}
		return &game, nil
	}
	// Redis miss - try to recover from DB
	if err == redis.Nil {
		game, recoverErr := h.recoverGameFromDB(ctx, gameID)
		if recoverErr != nil {
			return nil, redis.Nil // Return original error to indicate session not found
		}
		// Cache the recovered game back to Redis
		_ = h.saveGameToRedis(ctx, gameID, game)
		return game, nil
	}
	return nil, err
}

// recoverGameFromDB 从数据库恢复游戏状态
// 通过 game_id 解析 user_id，然后查找对应的 activity_draw_receipts 记录
// 使用 ServerSubSeed 重建游戏状态
func (h *handler) recoverGameFromDB(ctx context.Context, gameID string) (*MatchingGame, error) {
	// Parse user_id from game_id (format: MG{userID}{timestamp})
	// Example: MG121766299471192637903
	if len(gameID) < 3 || gameID[:2] != "MG" {
		return nil, fmt.Errorf("invalid game_id format")
	}

	// Extract user_id: find the first digit sequence after "MG"
	// The user_id is typically short (1-5 digits), timestamp is long (19 digits)
	numPart := gameID[2:]
	var userID int64
	if len(numPart) > 19 {
		// User ID is everything before the last 19 chars (nanosecond timestamp)
		userIDStr := numPart[:len(numPart)-19]
		userID = parseInt64(userIDStr)
	} else {
		return nil, fmt.Errorf("cannot parse user_id from game_id")
	}

	if userID <= 0 {
		return nil, fmt.Errorf("invalid user_id in game_id")
	}

	// Find the most recent matching game receipt for this user
	receipt, err := h.readDB.ActivityDrawReceipts.WithContext(ctx).
		Where(h.readDB.ActivityDrawReceipts.ClientID.Eq(userID)).
		Where(h.readDB.ActivityDrawReceipts.AlgoVersion.Eq("HMAC-SHA256-v1")).
		Order(h.readDB.ActivityDrawReceipts.ID.Desc()).
		First()
	if err != nil || receipt == nil {
		return nil, fmt.Errorf("no matching game receipt found for user %d", userID)
	}

	// Decode ServerSubSeed (hex -> bytes)
	serverSeed, err := hex.DecodeString(receipt.ServerSubSeed)
	if err != nil || len(serverSeed) == 0 {
		return nil, fmt.Errorf("invalid server seed in receipt")
	}

	// Get DrawLog to find IssueID and OrderID
	drawLog, err := h.readDB.ActivityDrawLogs.WithContext(ctx).
		Where(h.readDB.ActivityDrawLogs.ID.Eq(receipt.DrawLogID)).
		First()
	if err != nil || drawLog == nil {
		return nil, fmt.Errorf("draw log not found")
	}

	// Load card configs
	configs, err := loadCardTypesFromDB(ctx, h.readDB)
	if err != nil || len(configs) == 0 {
		// Fallback to default configs
		configs = []CardTypeConfig{
			{Code: "A", Name: "类型A", Quantity: 9},
			{Code: "B", Name: "类型B", Quantity: 9},
			{Code: "C", Name: "类型C", Quantity: 9},
			{Code: "D", Name: "类型D", Quantity: 9},
			{Code: "E", Name: "类型E", Quantity: 9},
			{Code: "F", Name: "类型F", Quantity: 9},
			{Code: "G", Name: "类型G", Quantity: 9},
			{Code: "H", Name: "类型H", Quantity: 9},
			{Code: "I", Name: "类型I", Quantity: 9},
			{Code: "J", Name: "类型J", Quantity: 9},
			{Code: "K", Name: "类型K", Quantity: 9},
		}
	}

	// Reconstruct game with the same seed
	game := &MatchingGame{
		CardConfigs:    configs,
		RoundHistory:   []MatchingRoundResult{},
		Board:          [9]*MatchingCard{},
		LastActivity:   time.Now(),
		ServerSeed:     serverSeed,
		ServerSeedHash: receipt.ServerSeedHash,
		Nonce:          0, // Reset nonce for reconstruction
		IssueID:        drawLog.IssueID,
		OrderID:        drawLog.OrderID,
		UserID:         userID,
	}

	// Get ActivityID from Issue
	if issue, _ := h.readDB.ActivityIssues.WithContext(ctx).Where(h.readDB.ActivityIssues.ID.Eq(drawLog.IssueID)).First(); issue != nil {
		game.ActivityID = issue.ActivityID
	}

	// Generate all cards
	totalCards := 0
	for _, cfg := range configs {
		totalCards += int(cfg.Quantity)
	}
	game.CardIDCounter = 0
	allCards := make([]*MatchingCard, 0, totalCards)
	for _, cfg := range configs {
		for i := int32(0); i < cfg.Quantity; i++ {
			game.CardIDCounter++
			id := fmt.Sprintf("c%d", game.CardIDCounter)
			mc := &MatchingCard{
				ID:   id,
				Type: cfg.Code,
			}
			allCards = append(allCards, mc)
		}
	}
	game.Deck = allCards

	// Shuffle with the same seed (deterministic)
	game.secureShuffle()

	// Fill board
	for i := 0; i < 9; i++ {
		if len(game.Deck) > 0 {
			card := game.Deck[0]
			game.Deck = game.Deck[1:]
			game.Board[i] = card
		} else {
			game.Board[i] = nil
		}
	}

	// Calculate max possible pairs
	var theoreticalMax int64
	for _, cfg := range configs {
		theoreticalMax += int64(cfg.Quantity / 2)
	}
	game.MaxPossiblePairs = theoreticalMax

	fmt.Printf("[会话恢复] 成功从数据库恢复游戏 game_id=%s user_id=%d issue_id=%d\n", gameID, userID, drawLog.IssueID)

	return game, nil
}

// startMatchingGameCleanup ... (Deprecated since we use Redis TTL)
func (h *handler) startMatchingGameCleanup() {
	// No-op
}

// cleanupExpiredMatchingGames ... (Deprecated)
func cleanupExpiredMatchingGames(logger logger.CustomLogger) {
	// No-op
}

// grantRewardHelper 发放奖励辅助函数
func (h *handler) grantRewardHelper(ctx context.Context, userID, orderID int64, r *model.ActivityRewardSettings, quantity int, remark string) error {
	// 1. Grant to Order (Delegating stock check to user service)
	issue, _ := h.readDB.ActivityIssues.WithContext(ctx).Where(h.readDB.ActivityIssues.ID.Eq(r.IssueID)).First()
	var actID int64
	if issue != nil {
		actID = issue.ActivityID
	}

	rid := r.ID
	_, err := h.user.GrantRewardToOrder(ctx, userID, usersvc.GrantRewardToOrderRequest{
		OrderID:    orderID,
		ProductID:  r.ProductID,
		Quantity:   quantity,
		ActivityID: &actID,
		RewardID:   &rid,
		Remark:     remark,
	})
	if err != nil {
		h.logger.Error("Failed to grant reward to order", zap.Int64("order_id", orderID), zap.Error(err))
		return err
	}

	// 2. Update Draw Log (IsWinner = 1)
	_, err = h.writeDB.ActivityDrawLogs.WithContext(ctx).Where(
		h.writeDB.ActivityDrawLogs.OrderID.Eq(orderID),
	).Updates(&model.ActivityDrawLogs{
		IsWinner: 1,
		RewardID: r.ID,
		Level:    r.Level,
	})

	return err
}

// parseInt64 将字符串转换为int64
func parseInt64(s string) int64 {
	var n int64
	for i := 0; i < len(s); i++ {
		c := s[i]
		if c < '0' || c > '9' {
			break
		}
		n = n*10 + int64(c-'0')
	}
	return n
}