package game

import (
	"context"
	"crypto/rand"
	"crypto/sha256"
	"encoding/hex"
	"encoding/json"
	"fmt"
	"net/url"
	"sort"
	"strconv"
	"strings"
	"sync"
	"time"

	"google.golang.org/grpc"
	activityv1 "hyapp.local/api/proto/activity/v1"
	gamev1 "hyapp.local/api/proto/game/v1"
	userv1 "hyapp.local/api/proto/user/v1"
	walletv1 "hyapp.local/api/proto/wallet/v1"
	"hyapp/pkg/appcode"
	"hyapp/pkg/xerr"
	gamedomain "hyapp/services/game-service/internal/domain/game"
)

const defaultScene = gamedomain.SceneVoiceRoom

// Repository 隔离 game-service 持久化事实，订单和 session 不能只放内存。
type Repository interface {
	Ping(ctx context.Context) error
	ListGames(ctx context.Context, query ListGamesQuery) ([]gamedomain.AppGame, error)
	ListRecentGames(ctx context.Context, query ListRecentGamesQuery) ([]gamedomain.AppGame, error)
	GetLaunchableGame(ctx context.Context, appCode string, gameID string) (gamedomain.LaunchableGame, error)
	GetPlatform(ctx context.Context, appCode string, platformCode string) (gamedomain.Platform, error)
	CreateLaunchSession(ctx context.Context, session gamedomain.LaunchSession) error
	GetLaunchSessionByToken(ctx context.Context, appCode string, token string) (gamedomain.LaunchSession, error)
	InsertCallbackLog(ctx context.Context, log gamedomain.CallbackLog) error
	CreateGameOrder(ctx context.Context, order gamedomain.GameOrder) (gamedomain.GameOrder, bool, error)
	MarkOrderSucceeded(ctx context.Context, appCode string, orderID string, walletTransactionID string, balanceAfter int64, nowMs int64) error
	MarkOrderFailed(ctx context.Context, appCode string, orderID string, status string, code string, message string, nowMs int64) error
	CreateRepairOrder(ctx context.Context, order gamedomain.RepairOrder) (gamedomain.RepairOrder, bool, error)
	ClaimPendingLevelEvents(ctx context.Context, workerID string, nowMS int64, lockTTL time.Duration, batchSize int) ([]gamedomain.LevelEventOutbox, error)
	MarkLevelEventDelivered(ctx context.Context, eventID string, nowMS int64) error
	MarkLevelEventFailed(ctx context.Context, eventID string, failureReason string, nextRetryAtMS int64, nowMS int64) error
	ListPlatforms(ctx context.Context, appCode string, status string) ([]gamedomain.Platform, error)
	UpsertPlatform(ctx context.Context, platform gamedomain.Platform) (gamedomain.Platform, error)
	ListCatalog(ctx context.Context, query ListCatalogQuery) ([]gamedomain.CatalogItem, string, error)
	UpsertCatalog(ctx context.Context, item gamedomain.CatalogItem) (gamedomain.CatalogItem, error)
	SetGameStatus(ctx context.Context, appCode string, gameID string, status string, nowMs int64) (gamedomain.CatalogItem, error)
	DeleteCatalog(ctx context.Context, appCode string, gameID string) error
}

// WalletClient 是 game-service 调 wallet-service 的最小改账依赖。
type WalletClient interface {
	ApplyGameCoinChange(ctx context.Context, req *walletv1.ApplyGameCoinChangeRequest) (*walletv1.ApplyGameCoinChangeResponse, error)
	GetBalances(ctx context.Context, req *walletv1.GetBalancesRequest) (*walletv1.GetBalancesResponse, error)
}

// UserClient 只暴露平台回调需要的用户展示资料查询能力。
type UserClient interface {
	GetUser(ctx context.Context, req *userv1.GetUserRequest) (*userv1.GetUserResponse, error)
}

// ActivityClient 是 game-service 向等级系统投递游戏消耗事实的最小依赖。
type ActivityClient interface {
	ConsumeLevelEvent(ctx context.Context, req *activityv1.ConsumeLevelEventRequest, opts ...grpc.CallOption) (*activityv1.ConsumeLevelEventResponse, error)
}

type Config struct {
	LaunchSessionTTL time.Duration
}

type Service struct {
	config     Config
	repository Repository
	wallet     WalletClient
	user       UserClient
	activity   ActivityClient
	now        func() time.Time

	signatureNonceMu sync.Mutex
	signatureNonces  map[string]int64
}

type ListGamesQuery struct {
	AppCode        string
	UserID         int64
	Scene          string
	RoomID         string
	RegionID       int64
	Language       string
	ClientPlatform string
}

type ListRecentGamesQuery struct {
	AppCode        string
	UserID         int64
	Scene          string
	RoomID         string
	RegionID       int64
	Language       string
	ClientPlatform string
	PageSize       int32
}

type ListCatalogQuery struct {
	AppCode      string
	PlatformCode string
	Status       string
	PageSize     int32
	Cursor       string
}

type LaunchCommand struct {
	AppCode       string
	RequestID     string
	UserID        int64
	DisplayUserID string
	GameID        string
	Scene         string
	RoomID        string
	RegionID      int64
	AccessToken   string
}

type LaunchResult struct {
	SessionID    string
	LaunchURL    string
	ExpiresAtMS  int64
	Orientation  string
	SafeHeight   int32
	ServerTimeMS int64
}

type BridgeScriptResult struct {
	URL          string
	Version      string
	SHA256       string
	ServerTimeMS int64
}

// New 创建 game-service 用例层。
func New(config Config, repository Repository, wallet WalletClient, user UserClient, activity ...ActivityClient) *Service {
	if config.LaunchSessionTTL <= 0 {
		config.LaunchSessionTTL = 15 * time.Minute
	}
	var activityClient ActivityClient
	if len(activity) > 0 {
		activityClient = activity[0]
	}
	return &Service{
		config:     config,
		repository: repository,
		wallet:     wallet,
		user:       user,
		activity:   activityClient,
		now:        time.Now,

		signatureNonces: make(map[string]int64),
	}
}

// Repository 只给 transport/admin 薄封装复用；业务主链路仍通过 Service 方法表达。
func (s *Service) Repository() Repository {
	if s == nil {
		return nil
	}
	return s.repository
}

// ListGames 返回 App 语音房里的跨平台合并游戏列表。
func (s *Service) ListGames(ctx context.Context, query ListGamesQuery) ([]gamedomain.AppGame, int64, error) {
	if query.UserID <= 0 {
		return nil, 0, xerr.New(xerr.InvalidArgument, "user_id is required")
	}
	if s.repository == nil {
		return nil, 0, xerr.New(xerr.Unavailable, "game repository is not configured")
	}
	query.AppCode = appcode.Normalize(query.AppCode)
	query.Scene = normalizeScene(query.Scene)
	query.Language = strings.ToLower(strings.TrimSpace(query.Language))
	query.ClientPlatform = strings.ToLower(strings.TrimSpace(query.ClientPlatform))
	ctx = appcode.WithContext(ctx, query.AppCode)

	games, err := s.repository.ListGames(ctx, query)
	return games, s.now().UnixMilli(), err
}

// ListRecentGames 返回当前用户最近启动过的语音房游戏，供 App 的 My Games tab 直接展示。
func (s *Service) ListRecentGames(ctx context.Context, query ListRecentGamesQuery) ([]gamedomain.AppGame, int64, error) {
	if query.UserID <= 0 {
		return nil, 0, xerr.New(xerr.InvalidArgument, "user_id is required")
	}
	if s.repository == nil {
		return nil, 0, xerr.New(xerr.Unavailable, "game repository is not configured")
	}
	query.AppCode = appcode.Normalize(query.AppCode)
	query.Scene = normalizeScene(query.Scene)
	query.Language = strings.ToLower(strings.TrimSpace(query.Language))
	query.ClientPlatform = strings.ToLower(strings.TrimSpace(query.ClientPlatform))
	query.PageSize = normalizeRecentGamesPageSize(query.PageSize)
	ctx = appcode.WithContext(ctx, query.AppCode)

	// 最近常玩只信任 game_launch_sessions 的真实启动事实，同时在仓储层重新套当前展示规则；
	// 这样旧游戏下架、维护、区域不可见后不会继续出现在 My Games tab。
	games, err := s.repository.ListRecentGames(ctx, query)
	return games, s.now().UnixMilli(), err
}

// GetBridgeScript 返回 App 通用游戏桥接脚本配置，供客户端启动预热和打开游戏面板时做轻量刷新。
func (s *Service) GetBridgeScript(ctx context.Context, appCode string) (BridgeScriptResult, error) {
	if s.repository == nil {
		return BridgeScriptResult{}, xerr.New(xerr.Unavailable, "game repository is not configured")
	}
	appCode = appcode.Normalize(appCode)
	ctx = appcode.WithContext(ctx, appCode)

	platforms, err := s.repository.ListPlatforms(ctx, appCode, gamedomain.StatusActive)
	if err != nil {
		return BridgeScriptResult{}, err
	}
	// admin 会把通用桥接脚本同步写入所有平台；这里仍按 sort/code 排序后读取第一份有效配置，
	// 避免数据库返回顺序变化导致 App 在相同配置之间来回切换。
	sort.SliceStable(platforms, func(left, right int) bool {
		if platforms[left].SortOrder != platforms[right].SortOrder {
			return platforms[left].SortOrder < platforms[right].SortOrder
		}
		return strings.Compare(platforms[left].PlatformCode, platforms[right].PlatformCode) < 0
	})
	for _, platform := range platforms {
		config := bridgeScriptConfigFromPlatform(platform)
		if strings.TrimSpace(config.URL) == "" {
			continue
		}
		return BridgeScriptResult{
			URL:          strings.TrimSpace(config.URL),
			Version:      strings.TrimSpace(config.Version),
			SHA256:       strings.TrimSpace(config.SHA256),
			ServerTimeMS: s.now().UnixMilli(),
		}, nil
	}
	return BridgeScriptResult{ServerTimeMS: s.now().UnixMilli()}, nil
}

// LaunchGame 创建短期 H5 启动会话，并把原始钱包能力限制在服务端。
func (s *Service) LaunchGame(ctx context.Context, command LaunchCommand) (LaunchResult, error) {
	if command.UserID <= 0 || strings.TrimSpace(command.GameID) == "" {
		return LaunchResult{}, xerr.New(xerr.InvalidArgument, "launch command is incomplete")
	}
	if s.repository == nil {
		return LaunchResult{}, xerr.New(xerr.Unavailable, "game repository is not configured")
	}
	command.AppCode = appcode.Normalize(command.AppCode)
	command.Scene = normalizeScene(command.Scene)
	command.DisplayUserID = strings.TrimSpace(command.DisplayUserID)
	if command.DisplayUserID == "" {
		command.DisplayUserID = strconv.FormatInt(command.UserID, 10)
	}
	ctx = appcode.WithContext(ctx, command.AppCode)

	game, err := s.repository.GetLaunchableGame(ctx, command.AppCode, strings.TrimSpace(command.GameID))
	if err != nil {
		return LaunchResult{}, err
	}
	if game.PlatformStatus != gamedomain.StatusActive || game.Status != gamedomain.StatusActive {
		return LaunchResult{}, xerr.New(xerr.Conflict, "game is not launchable")
	}
	regionID := command.RegionID
	if regionID <= 0 {
		var err error
		regionID, err = s.resolveUserRegion(ctx, command.AppCode, command.RequestID, command.UserID)
		if err != nil {
			return LaunchResult{}, err
		}
	}

	now := s.now()
	sessionID := "game_sess_" + strconv.FormatInt(now.UnixMilli(), 10) + "_" + randomHex(6)
	token := strings.TrimSpace(command.AccessToken)
	if token == "" {
		if strings.EqualFold(game.AdapterType, gamedomain.AdapterYomiV4) || strings.EqualFold(game.AdapterType, gamedomain.AdapterLeaderCCV1) || strings.EqualFold(game.AdapterType, gamedomain.AdapterZeeOneV1) || strings.EqualFold(game.AdapterType, gamedomain.AdapterBaishunV1) || strings.EqualFold(game.AdapterType, gamedomain.AdapterVivaGamesV1) || strings.EqualFold(game.AdapterType, gamedomain.AdapterReyouV1) {
			return LaunchResult{}, xerr.New(xerr.InvalidArgument, "access token is required for provider game launch")
		}
		token = "gt_" + randomHex(24)
	}
	sessionTTL := s.config.LaunchSessionTTL
	// 三方游戏会在 H5 运行期间持续回调 token；厂商适配器可以把默认 15 分钟启动 TTL 拉长。
	if strings.EqualFold(game.AdapterType, gamedomain.AdapterYomiV4) {
		sessionTTL = maxDuration(sessionTTL, yomiConfigFromPlatform(game).TokenTTL())
	} else if strings.EqualFold(game.AdapterType, gamedomain.AdapterLeaderCCV1) {
		sessionTTL = maxDuration(sessionTTL, leaderccConfigFromPlatform(game).TokenTTL())
	} else if strings.EqualFold(game.AdapterType, gamedomain.AdapterZeeOneV1) {
		sessionTTL = maxDuration(sessionTTL, zeeoneConfigFromPlatform(game).TokenTTL())
	} else if strings.EqualFold(game.AdapterType, gamedomain.AdapterBaishunV1) {
		sessionTTL = maxDuration(sessionTTL, baishunConfigFromPlatform(game).TokenTTL())
	} else if strings.EqualFold(game.AdapterType, gamedomain.AdapterVivaGamesV1) {
		sessionTTL = maxDuration(sessionTTL, vivaGamesConfigFromPlatform(game).TokenTTL())
	} else if strings.EqualFold(game.AdapterType, gamedomain.AdapterReyouV1) {
		sessionTTL = maxDuration(sessionTTL, reyouConfigFromPlatform(game).TokenTTL())
	}
	expiresAt := now.Add(sessionTTL).UnixMilli()
	session := gamedomain.LaunchSession{
		AppCode:        command.AppCode,
		SessionID:      sessionID,
		UserID:         command.UserID,
		DisplayUserID:  command.DisplayUserID,
		RoomID:         strings.TrimSpace(command.RoomID),
		RegionID:       regionID,
		Scene:          command.Scene,
		PlatformCode:   game.PlatformCode,
		GameID:         game.GameID,
		ProviderGameID: game.ProviderGameID,
		// 明文 token 只返回给客户端和厂商，库里只保存 hash，回调时通过 hash 查 session。
		LaunchTokenHash: stableHash(token),
		Status:          gamedomain.SessionActive,
		ExpiresAtMS:     expiresAt,
		CreatedAtMS:     now.UnixMilli(),
		UpdatedAtMS:     now.UnixMilli(),
	}
	if err := s.repository.CreateLaunchSession(ctx, session); err != nil {
		return LaunchResult{}, err
	}

	launchURL, err := buildLaunchURL(game, session, token)
	if err != nil {
		return LaunchResult{}, err
	}
	return LaunchResult{
		SessionID:    sessionID,
		LaunchURL:    launchURL,
		ExpiresAtMS:  expiresAt,
		Orientation:  game.Orientation,
		SafeHeight:   game.SafeHeight,
		ServerTimeMS: now.UnixMilli(),
	}, nil
}

// HandleCallback 保留 provider 原始请求摘要，并对 demo adapter 支持余额查询和金币改账。
func (s *Service) HandleCallback(ctx context.Context, req *gamev1.CallbackRequest) ([]byte, string, error) {
	if req == nil || strings.TrimSpace(req.GetPlatformCode()) == "" || strings.TrimSpace(req.GetOperation()) == "" {
		return nil, "", xerr.New(xerr.InvalidArgument, "callback request is incomplete")
	}
	if s.repository == nil {
		return nil, "", xerr.New(xerr.Unavailable, "game repository is not configured")
	}
	app := appcode.Normalize(req.GetMeta().GetAppCode())
	ctx = appcode.WithContext(ctx, app)
	operation := strings.ToLower(strings.TrimSpace(req.GetOperation()))
	// requestHash 是回调原文摘要，用于审计和钱包幂等校验，避免落库保存完整敏感 body。
	requestHash := stableHashBytes(req.GetRawBody())
	callbackID := "gcb_" + stableHash(fmt.Sprintf("%s|%s|%s|%d", app, req.GetPlatformCode(), requestHash, s.now().UnixNano()))

	signatureValid := false
	providerRequestID := ""
	var responseBody []byte
	var contentType string
	var statusCode string
	var err error
	if platform, platformErr := s.repository.GetPlatform(ctx, app, req.GetPlatformCode()); platformErr == nil {
		// adapter_type 是三方协议边界：新增厂商时只新增适配器，不改钱包/用户主流程。
		switch {
		case strings.EqualFold(platform.AdapterType, gamedomain.AdapterYomiV4):
			responseBody, contentType, statusCode, signatureValid, providerRequestID, err = s.handleYomiOperation(ctx, app, platform, req, operation, requestHash)
		case strings.EqualFold(platform.AdapterType, gamedomain.AdapterLeaderCCV1):
			responseBody, contentType, statusCode, signatureValid, providerRequestID, err = s.handleLeaderCCOperation(ctx, app, platform, req, operation, requestHash)
		case strings.EqualFold(platform.AdapterType, gamedomain.AdapterZeeOneV1):
			responseBody, contentType, statusCode, signatureValid, providerRequestID, err = s.handleZeeOneOperation(ctx, app, platform, req, operation, requestHash)
		case strings.EqualFold(platform.AdapterType, gamedomain.AdapterBaishunV1):
			responseBody, contentType, statusCode, signatureValid, providerRequestID, err = s.handleBaishunOperation(ctx, app, platform, req, operation, requestHash)
		case strings.EqualFold(platform.AdapterType, gamedomain.AdapterVivaGamesV1):
			responseBody, contentType, statusCode, signatureValid, providerRequestID, err = s.handleVivaGamesOperation(ctx, app, platform, req, operation, requestHash)
		case strings.EqualFold(platform.AdapterType, gamedomain.AdapterReyouV1):
			responseBody, contentType, statusCode, signatureValid, providerRequestID, err = s.handleReyouOperation(ctx, app, platform, req, operation, requestHash)
		default:
			responseBody, contentType, statusCode, err = s.handleDemoOperation(ctx, app, req, operation, requestHash)
		}
	} else {
		// 找不到平台时退回 demo，保留旧测试入口行为，避免管理后台未配置时直接打断联调。
		responseBody, contentType, statusCode, err = s.handleDemoOperation(ctx, app, req, operation, requestHash)
	}
	responseHash := stableHashBytes(responseBody)
	logStatus := "succeeded"
	if err != nil {
		logStatus = "failed"
		responseBody, contentType = jsonResponse(map[string]any{"code": string(xerr.CodeOf(err)), "message": xerr.MessageOf(err)})
		statusCode = string(xerr.CodeOf(err))
		responseHash = stableHashBytes(responseBody)
	}
	_ = s.repository.InsertCallbackLog(ctx, gamedomain.CallbackLog{
		AppCode:           app,
		CallbackID:        callbackID,
		PlatformCode:      strings.TrimSpace(req.GetPlatformCode()),
		Operation:         operation,
		RequestID:         req.GetMeta().GetRequestId(),
		ProviderRequestID: providerRequestID,
		SignatureValid:    signatureValid,
		RequestHash:       requestHash,
		ResponseCode:      statusCode,
		ResponseBodyHash:  responseHash,
		Status:            logStatus,
		CreatedAtMS:       s.now().UnixMilli(),
	})
	// InsertCallbackLog 失败不影响厂商响应；回调主链路优先保证游戏侧不超时。
	return responseBody, contentType, err
}

func (s *Service) handleDemoOperation(ctx context.Context, app string, req *gamev1.CallbackRequest, operation string, requestHash string) ([]byte, string, string, error) {
	switch operation {
	case "get_user_info":
		result, err := s.getCallbackUserInfo(ctx, app, req)
		if err != nil {
			return nil, "", "", err
		}
		raw, contentType := jsonResponse(result)
		return raw, contentType, "OK", nil
	case "get_balance":
		if s.wallet == nil {
			return nil, "", "", xerr.New(xerr.Unavailable, "wallet client is not configured")
		}
		var body struct {
			UserID int64 `json:"user_id"`
		}
		if err := json.Unmarshal(req.GetRawBody(), &body); err != nil || body.UserID <= 0 {
			return nil, "", "", xerr.New(xerr.InvalidArgument, "invalid get_balance payload")
		}
		resp, err := s.wallet.GetBalances(ctx, &walletv1.GetBalancesRequest{
			RequestId:  req.GetMeta().GetRequestId(),
			AppCode:    app,
			UserId:     body.UserID,
			AssetTypes: []string{"COIN"},
		})
		if err != nil {
			return nil, "", "", err
		}
		var balance int64
		for _, item := range resp.GetBalances() {
			if item.GetAssetType() == "COIN" {
				balance = item.GetAvailableAmount()
			}
		}
		raw, contentType := jsonResponse(map[string]any{"code": 0, "balance": balance})
		return raw, contentType, "OK", nil
	case "change_coin":
		result, err := s.applyCallbackCoinChange(ctx, app, req, requestHash)
		if err != nil {
			return nil, "", "", err
		}
		raw, contentType := jsonResponse(result)
		return raw, contentType, "OK", nil
	default:
		raw, contentType := jsonResponse(map[string]any{"code": 0, "message": "ok"})
		return raw, contentType, "OK", nil
	}
}

func (s *Service) getCallbackUserInfo(ctx context.Context, app string, req *gamev1.CallbackRequest) (map[string]any, error) {
	if s.user == nil || s.wallet == nil {
		return nil, xerr.New(xerr.Unavailable, "user or wallet client is not configured")
	}
	var body struct {
		UserID int64 `json:"user_id"`
	}
	if err := json.Unmarshal(req.GetRawBody(), &body); err != nil || body.UserID <= 0 {
		return nil, xerr.New(xerr.InvalidArgument, "invalid get_user_info payload")
	}
	userResp, err := s.user.GetUser(ctx, &userv1.GetUserRequest{
		Meta: &userv1.RequestMeta{
			RequestId: req.GetMeta().GetRequestId(),
			Caller:    "game-service",
			SentAtMs:  s.now().UnixMilli(),
			AppCode:   app,
		},
		UserId: body.UserID,
	})
	if err != nil {
		return nil, err
	}
	balanceResp, err := s.wallet.GetBalances(ctx, &walletv1.GetBalancesRequest{
		RequestId:  req.GetMeta().GetRequestId(),
		AppCode:    app,
		UserId:     body.UserID,
		AssetTypes: []string{"COIN"},
	})
	if err != nil {
		return nil, err
	}
	var balance int64
	for _, item := range balanceResp.GetBalances() {
		if item.GetAssetType() == "COIN" {
			balance = item.GetAvailableAmount()
			break
		}
	}
	user := userResp.GetUser()
	return map[string]any{
		"code":            0,
		"user_id":         body.UserID,
		"display_user_id": user.GetDisplayUserId(),
		"nickname":        user.GetUsername(),
		"avatar":          user.GetAvatar(),
		"country":         user.GetCountry(),
		"region_id":       user.GetRegionId(),
		"balance":         balance,
	}, nil
}

func (s *Service) resolveUserRegion(ctx context.Context, app string, requestID string, userID int64) (int64, error) {
	if userID <= 0 || s.user == nil {
		return 0, nil
	}
	userResp, err := s.user.GetUser(ctx, &userv1.GetUserRequest{
		Meta: &userv1.RequestMeta{
			RequestId: requestID,
			Caller:    "game-service",
			SentAtMs:  s.now().UnixMilli(),
			AppCode:   app,
		},
		UserId: userID,
	})
	if err != nil {
		return 0, err
	}
	return userResp.GetUser().GetRegionId(), nil
}

func (s *Service) applyCallbackCoinChange(ctx context.Context, app string, req *gamev1.CallbackRequest, requestHash string) (map[string]any, error) {
	if s.wallet == nil {
		return nil, xerr.New(xerr.Unavailable, "wallet client is not configured")
	}
	var body struct {
		UserID          int64  `json:"user_id"`
		GameID          string `json:"game_id"`
		ProviderGameID  string `json:"provider_game_id"`
		ProviderOrderID string `json:"provider_order_id"`
		ProviderRoundID string `json:"provider_round_id"`
		OpType          string `json:"op_type"`
		CoinAmount      int64  `json:"coin_amount"`
		RoomID          string `json:"room_id"`
	}
	if err := json.Unmarshal(req.GetRawBody(), &body); err != nil {
		return nil, xerr.New(xerr.InvalidArgument, "invalid change_coin payload")
	}
	body.GameID = strings.TrimSpace(body.GameID)
	body.ProviderOrderID = strings.TrimSpace(body.ProviderOrderID)
	body.OpType = strings.TrimSpace(body.OpType)
	if body.UserID <= 0 || body.GameID == "" || body.ProviderOrderID == "" || body.OpType == "" || body.CoinAmount <= 0 {
		return nil, xerr.New(xerr.InvalidArgument, "change_coin payload is incomplete")
	}
	if body.ProviderGameID == "" {
		game, err := s.repository.GetLaunchableGame(ctx, app, body.GameID)
		if err != nil {
			return nil, err
		}
		body.ProviderGameID = game.ProviderGameID
	}
	regionID, err := s.resolveUserRegion(ctx, app, req.GetMeta().GetRequestId(), body.UserID)
	if err != nil {
		return nil, err
	}
	order := gamedomain.GameOrder{
		AppCode:         app,
		OrderID:         "gord_" + stableHash(app+"|"+req.GetPlatformCode()+"|"+body.ProviderOrderID),
		PlatformCode:    strings.TrimSpace(req.GetPlatformCode()),
		ProviderOrderID: body.ProviderOrderID,
		ProviderRoundID: body.ProviderRoundID,
		GameID:          body.GameID,
		ProviderGameID:  body.ProviderGameID,
		UserID:          body.UserID,
		RoomID:          strings.TrimSpace(body.RoomID),
		RegionID:        regionID,
		OpType:          body.OpType,
		CoinAmount:      body.CoinAmount,
		Status:          gamedomain.OrderStatusWalletApplying,
		RequestHash:     requestHash,
	}
	order, exists, err := s.repository.CreateGameOrder(ctx, order)
	if err != nil {
		return nil, err
	}
	if exists && order.Status == gamedomain.OrderStatusSucceeded {
		return map[string]any{"code": 0, "order_id": order.OrderID, "wallet_transaction_id": order.WalletTransactionID, "balance_after": order.WalletBalanceAfter, "idempotent_replay": true}, nil
	}

	walletResp, err := s.wallet.ApplyGameCoinChange(ctx, &walletv1.ApplyGameCoinChangeRequest{
		RequestId:       req.GetMeta().GetRequestId(),
		AppCode:         app,
		CommandId:       "game:" + strings.TrimSpace(req.GetPlatformCode()) + ":" + body.ProviderOrderID,
		UserId:          body.UserID,
		PlatformCode:    strings.TrimSpace(req.GetPlatformCode()),
		GameId:          body.GameID,
		ProviderOrderId: body.ProviderOrderID,
		ProviderRoundId: body.ProviderRoundID,
		OpType:          body.OpType,
		CoinAmount:      body.CoinAmount,
		RoomId:          body.RoomID,
		RequestHash:     requestHash,
	})
	nowMs := s.now().UnixMilli()
	if err != nil {
		status := gamedomain.OrderStatusFailed
		if xerr.IsCode(err, xerr.IdempotencyConflict) {
			status = gamedomain.OrderStatusConflict
		}
		_ = s.repository.MarkOrderFailed(ctx, app, order.OrderID, status, string(xerr.ReasonFromGRPC(err)), err.Error(), nowMs)
		return nil, err
	}
	if err := s.repository.MarkOrderSucceeded(ctx, app, order.OrderID, walletResp.GetWalletTransactionId(), walletResp.GetBalanceAfter(), nowMs); err != nil {
		return nil, err
	}
	return map[string]any{"code": 0, "order_id": order.OrderID, "wallet_transaction_id": walletResp.GetWalletTransactionId(), "balance_after": walletResp.GetBalanceAfter(), "idempotent_replay": walletResp.GetIdempotentReplay()}, nil
}

// ProcessLevelEventOutboxBatch 把成功游戏扣费订单异步投递给 activity-service 的游戏等级轨道。
func (s *Service) ProcessLevelEventOutboxBatch(ctx context.Context, runID string, workerID string, batchSize int, lockTTL time.Duration) (claimed int32, processed int32, success int32, failure int32, hasMore bool, err error) {
	if s.repository == nil {
		return 0, 0, 0, 0, false, xerr.New(xerr.Unavailable, "game repository is not configured")
	}
	if s.activity == nil {
		return 0, 0, 0, 0, false, xerr.New(xerr.Unavailable, "activity client is not configured")
	}
	if batchSize <= 0 {
		batchSize = 100
	}
	if lockTTL <= 0 {
		lockTTL = 30 * time.Second
	}
	if strings.TrimSpace(workerID) == "" {
		workerID = "game-level-relay"
	}
	events, err := s.repository.ClaimPendingLevelEvents(ctx, workerID, s.now().UnixMilli(), lockTTL, batchSize)
	if err != nil {
		return 0, 0, 0, 0, false, err
	}
	for _, event := range events {
		processed++
		eventCtx := appcode.WithContext(ctx, event.AppCode)
		resp, relayErr := s.activity.ConsumeLevelEvent(eventCtx, &activityv1.ConsumeLevelEventRequest{
			Meta: &activityv1.RequestMeta{
				RequestId: event.EventID,
				Caller:    "game-service",
				SentAtMs:  s.now().UnixMilli(),
				AppCode:   event.AppCode,
			},
			EventId:         event.EventID,
			SourceEventId:   event.OrderID,
			SourceService:   "game-service",
			SourceEventType: "GameCoinDebited",
			UserId:          event.UserID,
			Track:           "game",
			MetricType:      "game_spend_coin",
			ValueDelta:      event.CoinAmount,
			OccurredAtMs:    event.OccurredAtMS,
			DimensionsJson:  event.PayloadJSON,
		})
		if relayErr != nil {
			failure++
			nextRetry := s.now().Add(time.Minute).UnixMilli()
			_ = s.repository.MarkLevelEventFailed(eventCtx, event.EventID, xerr.MessageOf(relayErr), nextRetry, s.now().UnixMilli())
			continue
		}
		if resp.GetStatus() != "consumed" && resp.GetStatus() != "duplicate" {
			failure++
			nextRetry := s.now().Add(time.Minute).UnixMilli()
			_ = s.repository.MarkLevelEventFailed(eventCtx, event.EventID, "activity returned "+resp.GetStatus(), nextRetry, s.now().UnixMilli())
			continue
		}
		if err := s.repository.MarkLevelEventDelivered(eventCtx, event.EventID, s.now().UnixMilli()); err != nil {
			failure++
			continue
		}
		success++
	}
	return int32(len(events)), processed, success, failure, len(events) == batchSize, nil
}

func normalizeScene(scene string) string {
	scene = strings.ToLower(strings.TrimSpace(scene))
	if scene == "" {
		return defaultScene
	}
	return scene
}

func normalizeRecentGamesPageSize(pageSize int32) int32 {
	if pageSize <= 0 {
		return 4
	}
	if pageSize > 20 {
		return 20
	}
	return pageSize
}

func buildLaunchURL(game gamedomain.LaunchableGame, session gamedomain.LaunchSession, token string) (string, error) {
	base := strings.TrimSpace(game.APIBaseURL)
	if strings.EqualFold(game.AdapterType, gamedomain.AdapterLeaderCCV1) && base == "" {
		// 灵仙当前只需要我们提供回调域名和接口，不要求服务端拼 H5/Auth URL。
		return "", nil
	}
	if strings.EqualFold(game.AdapterType, gamedomain.AdapterZeeOneV1) {
		// ZeeOne 的测试/正式游戏经常是同商户多条 H5 地址，优先读后台 JSON 的按游戏覆盖配置。
		if configuredBase := zeeoneLaunchBaseURL(game, zeeoneConfigFromPlatform(game)); configuredBase != "" {
			base = configuredBase
		}
	}
	if strings.EqualFold(game.AdapterType, gamedomain.AdapterBaishunV1) {
		// 百顺 H5 地址可能来自 one_game_info/download_url，也支持后台按游戏覆盖，避免按环境写死。
		if configuredBase := baishunLaunchBaseURL(game, baishunConfigFromPlatform(game)); configuredBase != "" {
			base = configuredBase
		}
	}
	if strings.EqualFold(game.AdapterType, gamedomain.AdapterVivaGamesV1) {
		// VIVAGAMES 文档说明游戏 URL 由厂商提供；后台按 game_id 保存 URL，启动时只拼客户端 getConfig 需要的热配置。
		if configuredBase := vivaGamesLaunchBaseURL(game, vivaGamesConfigFromPlatform(game)); configuredBase != "" {
			base = configuredBase
		}
	}
	if strings.EqualFold(game.AdapterType, gamedomain.AdapterReyouV1) {
		// 热游 H5 地址由厂商按游戏提供；后台配置 game_urls 后，上线新游戏无需改服务端配置文件。
		if configuredBase := reyouLaunchBaseURL(game, reyouConfigFromPlatform(game)); configuredBase != "" {
			base = configuredBase
		}
	}
	if base == "" {
		if strings.EqualFold(game.AdapterType, gamedomain.AdapterYomiV4) {
			return "", xerr.New(xerr.InvalidArgument, "yomi auth url is required")
		}
		if strings.EqualFold(game.AdapterType, gamedomain.AdapterZeeOneV1) {
			return "", xerr.New(xerr.InvalidArgument, "zeeone launch url is required")
		}
		if strings.EqualFold(game.AdapterType, gamedomain.AdapterBaishunV1) {
			return "", xerr.New(xerr.InvalidArgument, "baishun launch url is required")
		}
		if strings.EqualFold(game.AdapterType, gamedomain.AdapterVivaGamesV1) {
			return "", xerr.New(xerr.InvalidArgument, "vivagames launch url is required")
		}
		if strings.EqualFold(game.AdapterType, gamedomain.AdapterReyouV1) {
			return "", xerr.New(xerr.InvalidArgument, "reyou launch url is required")
		}
		// demo 平台可以没有真实厂商域名，保留本地默认地址用于开发自测。
		base = "https://game.example.local/h5"
	}
	parsed, err := url.Parse(base)
	if err != nil {
		return "", xerr.New(xerr.InvalidArgument, "platform launch url is invalid")
	}
	query := parsed.Query()
	if strings.EqualFold(game.AdapterType, gamedomain.AdapterYomiV4) {
		// Yomi 的启动地址是 auth/gateway，用户合法性通过 platAuthCode 在服务端 gettoken 二次校验。
		config := yomiConfigFromPlatform(game)
		lang := config.DefaultLang
		if lang == "" {
			lang = "en"
		}
		query.Set("gameUid", session.ProviderGameID)
		query.Set("platAuthCode", token)
		query.Set("platUserId", externalUserID(session, config.UIDMode))
		query.Set("lang", lang)
		// Yomi gameLevelUid 语义类似房间/场次，没有后台配置时必须显式传 0。
		if gameLevelUID := config.GameLevelUIDFor(game); gameLevelUID > 0 {
			query.Set("gameLevelUid", strconv.FormatInt(gameLevelUID, 10))
		} else {
			query.Set("gameLevelUid", "0")
		}
		if config.PlatPayload != "" {
			query.Set("platPayload", config.PlatPayload)
		}
		if session.RoomID != "" {
			query.Set("platRoomId", session.RoomID)
		}
		appendBridgeScriptQuery(query, game)
		parsed.RawQuery = query.Encode()
		return parsed.String(), nil
	}
	if strings.EqualFold(game.AdapterType, gamedomain.AdapterLeaderCCV1) {
		// 灵仙启动只需要 uid/token/lang/roomid，后续 userinfo/change_coin 通过 token + MD5 签名校验。
		config := leaderccConfigFromPlatform(game)
		lang := config.DefaultLang
		if lang == "" {
			lang = "en"
		}
		query.Set("uid", externalUserID(session, config.UIDMode))
		query.Set("token", token)
		query.Set("lang", lang)
		if session.RoomID != "" {
			query.Set("roomid", session.RoomID)
		}
		appendBridgeScriptQuery(query, game)
		parsed.RawQuery = query.Encode()
		return parsed.String(), nil
	}
	if strings.EqualFold(game.AdapterType, gamedomain.AdapterZeeOneV1) {
		// ZeeOne 直接加载指定游戏 H5，sessionId 使用 App access token，merchant/platform 来自后台热配置。
		config := zeeoneConfigFromPlatform(game)
		lang := config.DefaultLang
		if lang == "" {
			lang = "en"
		}
		query.Set("sessionId", token)
		query.Set("language", lang)
		if config.MerchantID > 0 {
			query.Set("merchant", strconv.FormatInt(config.MerchantID, 10))
		}
		if config.PlatformID > 0 {
			query.Set("platform", strconv.FormatInt(config.PlatformID, 10))
		}
		if session.RoomID != "" {
			query.Set("sid", session.RoomID)
		}
		if config.GameMode != "" {
			query.Set("gameMode", config.GameMode)
		}
		if config.Extra != "" {
			query.Set("extra", config.Extra)
		}
		appendBridgeScriptQuery(query, game)
		parsed.RawQuery = query.Encode()
		return parsed.String(), nil
	}
	if strings.EqualFold(game.AdapterType, gamedomain.AdapterBaishunV1) {
		// 百顺前端规范以 NativeBridge.getConfig 为准；这里把同一份配置也拼到 URL，方便 Flutter/H5 壳层读取。
		config := baishunConfigFromPlatform(game)
		query.Set("bridge_keys", "appChannel,appId,userId,code,gameMode,gsp,language,roomId,sceneMode,currencyIcon,isDataByUrl")
		query.Set("appChannel", config.AppChannel)
		if config.AppID > 0 {
			query.Set("appId", strconv.FormatInt(config.AppID, 10))
		}
		query.Set("userId", externalUserID(session, config.UIDMode))
		query.Set("code", token)
		query.Set("isDataByUrl", "1")
		if session.RoomID != "" {
			query.Set("roomId", session.RoomID)
		}
		query.Set("gameMode", config.GameModeValue())
		query.Set("language", config.LanguageValue())
		query.Set("sceneMode", strconv.FormatInt(config.SceneMode, 10))
		if config.CurrencyIcon != "" {
			query.Set("currencyIcon", config.CurrencyIcon)
		}
		query.Set("gsp", strconv.FormatInt(config.GSP, 10))
		appendBridgeScriptQuery(query, game)
		parsed.RawQuery = query.Encode()
		return parsed.String(), nil
	}
	if strings.EqualFold(game.AdapterType, gamedomain.AdapterVivaGamesV1) {
		// VIVAGAMES H5 通过 NativeBridge.getConfig 取 appId/userId/code；这里把同一份配置拼到 URL，供 App 壳层回写给 H5。
		config := vivaGamesConfigFromPlatform(game)
		query.Set("bridge_keys", "appId,userId,code,metadata,language,coinType,amountRate,bgmSwitch,gsp,currencyIcon,gameConfig,gameId")
		if config.AppID > 0 {
			query.Set("appId", strconv.FormatInt(config.AppID, 10))
		}
		query.Set("userId", externalUserID(session, config.UIDMode))
		query.Set("code", token)
		query.Set("gameId", strings.TrimSpace(session.ProviderGameID))
		query.Set("metadata", config.MetadataValue(session))
		query.Set("language", config.LanguageValue())
		query.Set("coinType", strconv.FormatInt(config.CoinType, 10))
		query.Set("amountRate", strconv.FormatInt(config.AmountRateValue(), 10))
		query.Set("bgmSwitch", strconv.FormatInt(config.BGMSwitchValue(), 10))
		query.Set("gsp", strconv.FormatInt(config.GSPValue(), 10))
		if config.CurrencyIcon != "" {
			query.Set("currencyIcon", config.CurrencyIcon)
			query.Set("gameConfig", vivaGamesGameConfigQuery(config.CurrencyIcon))
		}
		appendBridgeScriptQuery(query, game)
		parsed.RawQuery = query.Encode()
		return parsed.String(), nil
	}
	if strings.EqualFold(game.AdapterType, gamedomain.AdapterReyouV1) {
		// 热游文档只要求 uid/token/lang 三个启动参数；服务端回调再用 token 绑定用户、游戏和钱包订单。
		config := reyouConfigFromPlatform(game)
		query.Set("uid", externalUserID(session, config.UIDMode))
		query.Set("token", token)
		query.Set("lang", config.LanguageValue())
		appendBridgeScriptQuery(query, game)
		parsed.RawQuery = query.Encode()
		return parsed.String(), nil
	}
	// demo adapter 保持内部调试参数完整，方便用一个简单 H5 验证 session 和订单链路。
	query.Set("session_id", session.SessionID)
	query.Set("session_token", token)
	query.Set("game_id", session.GameID)
	query.Set("provider_game_id", session.ProviderGameID)
	query.Set("platform_code", session.PlatformCode)
	query.Set("user_id", strconv.FormatInt(session.UserID, 10))
	query.Set("display_user_id", session.DisplayUserID)
	query.Set("scene", session.Scene)
	query.Set("room_id", session.RoomID)
	appendBridgeScriptQuery(query, game)
	parsed.RawQuery = query.Encode()
	return parsed.String(), nil
}

func maxDuration(left time.Duration, right time.Duration) time.Duration {
	if right > left {
		return right
	}
	return left
}

func (s *Service) rememberSignatureNonce(scope string, nonce string, requestAt time.Time, ttl time.Duration) bool {
	if s == nil {
		return false
	}
	scope = strings.TrimSpace(scope)
	nonce = strings.TrimSpace(nonce)
	if scope == "" || nonce == "" {
		return false
	}
	s.signatureNonceMu.Lock()
	defer s.signatureNonceMu.Unlock()
	if s.signatureNonces == nil {
		s.signatureNonces = make(map[string]int64)
	}
	nowMS := s.now().UnixMilli()
	for key, expiresAtMS := range s.signatureNonces {
		if expiresAtMS <= nowMS {
			delete(s.signatureNonces, key)
		}
	}
	key := scope + ":" + nonce
	if s.signatureNonces[key] > nowMS {
		return false
	}
	s.signatureNonces[key] = requestAt.Add(ttl).UnixMilli()
	return true
}

func jsonResponse(value any) ([]byte, string) {
	body, err := json.Marshal(value)
	if err != nil {
		return []byte(`{"code":"INTERNAL_ERROR","message":"internal error"}`), "application/json"
	}
	return body, "application/json"
}

func randomHex(size int) string {
	bytes := make([]byte, size)
	if _, err := rand.Read(bytes); err != nil {
		return strconv.FormatInt(time.Now().UnixNano(), 16)
	}
	return hex.EncodeToString(bytes)
}

func stableHash(value string) string {
	sum := sha256.Sum256([]byte(value))
	return hex.EncodeToString(sum[:])
}

func stableHashBytes(value []byte) string {
	sum := sha256.Sum256(value)
	return hex.EncodeToString(sum[:])
}