package activity

import (
	"context"
	"crypto/hmac"
	"crypto/sha256"
	"encoding/binary"
	"encoding/hex"
	"encoding/json"
	"fmt"
	"log"
	"strings"
	"sync"
	"time"
)

// 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"`
	CardIDCounter    int64            `json:"card_id_counter"`
	TotalPairs       int64            `json:"total_pairs"`
	MaxPossiblePairs int64            `json:"max_possible_pairs"`
	LastActivity     time.Time        `json:"last_activity"`
	Position         string           `json:"position"`   // 用户选择的类型，用于服务端验证
	CreatedAt        time.Time        `json:"created_at"` // 游戏创建时间，用于自动开奖超时判断

	ActivityID int64 `json:"activity_id"`
	IssueID    int64 `json:"issue_id"`
	OrderID    int64 `json:"order_id"`
	UserID     int64 `json:"user_id"`
}

const MatchingGameKeyPrefix = "bindbox:matching_game:"

// NewMatchingGameWithConfig 使用配置创建游戏
func NewMatchingGameWithConfig(configs []CardTypeConfig, position string, masterSeed []byte) *MatchingGame {
	if len(masterSeed) == 0 {
		return nil
	}

	g := &MatchingGame{
		CardConfigs:  configs,
		Board:        [9]*MatchingCard{},
		LastActivity: time.Now(),
	}

	h := hmac.New(sha256.New, masterSeed)
	h.Write([]byte(position))
	h.Write([]byte(fmt.Sprintf("%d", time.Now().UnixNano())))
	g.ServerSeed = h.Sum(nil)

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

	totalCards := 0
	for _, cfg := range configs {
		totalCards += int(cfg.Quantity)
	}

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

	var theoreticalMax int64
	for _, cfg := range configs {
		theoreticalMax += int64(cfg.Quantity / 2)
	}
	g.MaxPossiblePairs = theoreticalMax

	return g
}

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

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

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

// SimulateMaxPairs 服务端模拟计算给定牌组和选中类型的理论最大对数
// 返回值：理论最大可消除对数
func (g *MatchingGame) SimulateMaxPairs() int64 {
	// 重建完整牌组：Board + Deck
	allCards := make([]*MatchingCard, 0, len(g.Board)+len(g.Deck))
	for _, c := range g.Board {
		if c != nil {
			allCards = append(allCards, c)
		}
	}
	allCards = append(allCards, g.Deck...)

	// 🔍 详细日志：牌组信息
	boardTypes := make([]string, 0, 9)
	for _, c := range g.Board {
		if c != nil {
			boardTypes = append(boardTypes, string(c.Type))
		}
	}
	log.Printf("[SimulateMaxPairs] Board(%d张): %s", len(boardTypes), strings.Join(boardTypes, ","))
	log.Printf("[SimulateMaxPairs] Deck长度: %d, 总牌数: %d", len(g.Deck), len(allCards))
	log.Printf("[SimulateMaxPairs] Position: '%s'", g.Position)

	if len(allCards) < 9 {
		log.Printf("[SimulateMaxPairs] 牌数不足9张，返回0")
		return 0
	}

	selectedType := CardType(g.Position)

	// 模拟游戏
	hand := make([]*MatchingCard, 9)
	copy(hand, allCards[:9])
	deckIndex := 9

	// 初始机会 = 手牌中选中类型的数量
	chance := int64(0)
	for _, c := range hand {
		if c != nil && c.Type == selectedType {
			chance++
		}
	}

	// 🔍 详细日志：初始状态
	handTypes := make([]string, 0, len(hand))
	for _, c := range hand {
		if c != nil {
			handTypes = append(handTypes, string(c.Type))
		}
	}
	log.Printf("[SimulateMaxPairs] 初始手牌: %s", strings.Join(handTypes, ","))
	log.Printf("[SimulateMaxPairs] 选中类型: '%s', 初始机会: %d", selectedType, chance)

	totalPairs := int64(0)

	// canEliminate 检查是否有可配对的牌
	canEliminate := func() CardType {
		counts := make(map[CardType]int)
		for _, c := range hand {
			if c == nil {
				continue
			}
			counts[c.Type]++
			if counts[c.Type] >= 2 {
				return c.Type
			}
		}
		return ""
	}

	// eliminatePair 消除一对
	eliminatePair := func(targetType CardType) bool {
		first, second := -1, -1
		for i, c := range hand {
			if c == nil || c.Type != targetType {
				continue
			}
			if first < 0 {
				first = i
			} else {
				second = i
				break
			}
		}
		if first >= 0 && second >= 0 {
			// 移除两张牌（从切片中删除）
			newHand := make([]*MatchingCard, 0, len(hand)-2)
			for i, c := range hand {
				if i != first && i != second {
					newHand = append(newHand, c)
				}
			}
			hand = newHand
			totalPairs++
			chance++
			return true
		}
		return false
	}

	// 游戏循环
	guard := 0
	for guard < 1000 {
		guard++

		// 尝试消除
		if pairType := canEliminate(); pairType != "" {
			eliminatePair(pairType)
			continue
		}

		// 不能消除，尝试摸牌
		if chance > 0 && deckIndex < len(allCards) {
			newCard := allCards[deckIndex]
			hand = append(hand, newCard)
			deckIndex++
			chance--

			continue
		}

		// 既不能消除也不能摸牌，游戏结束
		break
	}

	log.Printf("[SimulateMaxPairs] 模拟结束, 最终对数: %d, 剩余手牌: %d, 已摸牌数: %d", totalPairs, len(hand), deckIndex-9)
	return totalPairs
}

// ReconstructMatchingGame 根据订单号还原游戏状态
func (s *service) ReconstructMatchingGame(ctx context.Context, orderNo string) (*MatchingGame, error) {
	order, err := s.readDB.Orders.WithContext(ctx).Where(s.readDB.Orders.OrderNo.Eq(orderNo)).First()
	if err != nil {
		return nil, err
	}

	// 1. Get DrawLog first
	drawLog, err := s.readDB.ActivityDrawLogs.WithContext(ctx).
		Where(s.readDB.ActivityDrawLogs.OrderID.Eq(order.ID)).
		First()
	if err != nil {
		return nil, fmt.Errorf("draw log not found: %w", err)
	}

	// 2. Get Receipt using DrawLogID
	receipt, err := s.readDB.ActivityDrawReceipts.WithContext(ctx).
		Where(s.readDB.ActivityDrawReceipts.DrawLogID.Eq(drawLog.ID)).
		First()
	if err != nil {
		return nil, fmt.Errorf("draw receipt not found: %w", err)
	}

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

	// Retrieve ActivityID from Issue
	issue, err := s.readDB.ActivityIssues.WithContext(ctx).Where(s.readDB.ActivityIssues.ID.Eq(drawLog.IssueID)).First()
	var activityID int64
	if err == nil && issue != nil {
		activityID = issue.ActivityID
	}

	configs, err := s.loadCardTypesFromDB(ctx)
	if err != nil || len(configs) == 0 {
		return nil, fmt.Errorf("failed to load card types")
	}

	game := &MatchingGame{
		CardConfigs:    configs,
		Board:          [9]*MatchingCard{},
		LastActivity:   time.Now(),
		ServerSeed:     serverSeed,
		ServerSeedHash: receipt.ServerSeedHash,
		Nonce:          0,
		IssueID:        drawLog.IssueID,
		OrderID:        drawLog.OrderID,
		UserID:         order.UserID,
		ActivityID:     activityID,
	}

	allCards := make([]*MatchingCard, 0, 99)
	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

	game.SecureShuffle()

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

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

	return game, nil
}

func (s *service) ListMatchingCardTypes(ctx context.Context) ([]CardTypeConfig, error) {
	return s.loadCardTypesFromDB(ctx)
}

func (s *service) loadCardTypesFromDB(ctx context.Context) ([]CardTypeConfig, error) {
	items, err := s.readDB.MatchingCardTypes.WithContext(ctx).Where(s.readDB.MatchingCardTypes.Status.Eq(1)).Order(s.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
}

// GetMatchingGameFromRedis 从 Redis 加载游戏状态
func (s *service) GetMatchingGameFromRedis(ctx context.Context, gameID string) (*MatchingGame, error) {
	data, err := s.redis.Get(ctx, MatchingGameKeyPrefix+gameID).Bytes()
	if err != nil {
		return nil, err
	}
	var game MatchingGame
	if err := json.Unmarshal(data, &game); err != nil {
		return nil, err
	}
	return &game, nil
}

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