package game

import (
	"context"
	"crypto/sha256"
	"crypto/subtle"
	"encoding/hex"
	"encoding/json"
	"fmt"
	"math"
	"strconv"
	"strings"
	"time"

	gamev1 "hyapp.local/api/proto/game/v1"
	"hyapp/pkg/xerr"
	gamedomain "hyapp/services/game-service/internal/domain/game"
)

const (
	// ZGame 文档的业务码会被游戏服务端直接消费；HTTP 200 只表示网关成功接收并处理回调。
	zgameCodeOK                  = 0
	zgameCodeInvalidSession      = 201
	zgameCodeInvalidSignature    = 400
	zgameCodeUnauthorized        = 401
	zgameCodeInvalidCode         = 403
	zgameCodeInsufficientBalance = 501
	zgameCodeInternalError       = 500

	zgameDefaultTokenTTL = 24 * time.Hour
)

type zgameAdapterConfig struct {
	// uid_mode 必须和启动链接、login open_id、后续签名 open_id 保持一致，避免同一 token 被不同用户标识复用。
	UIDMode         string `json:"uid_mode"`
	DefaultLang     string `json:"default_lang"`
	TokenTTLSeconds int64  `json:"token_ttl_seconds"`
	// game_urls 支持 ZGame 每款游戏独立 H5 地址；launch_url_template 用于批量上新时按 provider_game_id 生成地址。
	GameURLs          map[string]string `json:"game_urls"`
	LaunchURLTemplate string            `json:"launch_url_template"`
	// callback_base 可按环境覆盖为完整公网 HTTPS 地址，避免 H5 在第三方域名下把相对路径解析到厂商域名。
	CallbackBase      string `json:"callback_base"`
	CallbackBaseAlias string `json:"callbackBase"`
	// merchant_payload 是 ZGame consume 回调的透传字段来源；只参与厂商回传，不进入内部业务判断。
	MerchantPayload string `json:"merchant_payload"`
	// level/gender 是 ZGame 用户资料响应里的展示字段；真实等级接入前保持显式默认值，避免从其它体系误推。
	Level  int32 `json:"level"`
	Gender int32 `json:"gender"`
}

func zgameConfigFromPlatform(value any) zgameAdapterConfig {
	var raw string
	switch typed := value.(type) {
	case gamedomain.Platform:
		raw = typed.AdapterConfigJSON
	case gamedomain.LaunchableGame:
		raw = typed.AdapterConfigJSON
	}
	var config zgameAdapterConfig
	_ = json.Unmarshal([]byte(strings.TrimSpace(raw)), &config)
	config.UIDMode = strings.ToLower(strings.TrimSpace(config.UIDMode))
	if config.UIDMode == "" {
		// laluparty 游戏侧展示和签名都用短号作为 open_id；历史配置未写 uid_mode 时按文档默认走 display_user_id。
		config.UIDMode = "display_user_id"
	}
	config.DefaultLang = strings.TrimSpace(config.DefaultLang)
	config.LaunchURLTemplate = strings.TrimSpace(config.LaunchURLTemplate)
	config.CallbackBase = strings.TrimSpace(firstNonEmpty(config.CallbackBase, config.CallbackBaseAlias))
	config.MerchantPayload = strings.TrimSpace(config.MerchantPayload)
	config.GameURLs = normalizeStringMap(config.GameURLs)
	return config
}

func (c zgameAdapterConfig) TokenTTL() time.Duration {
	if c.TokenTTLSeconds > 0 {
		return time.Duration(c.TokenTTLSeconds) * time.Second
	}
	return zgameDefaultTokenTTL
}

func (c zgameAdapterConfig) CallbackBaseValue() string {
	if c.CallbackBase != "" {
		return c.CallbackBase
	}
	return "/api/v1/zgame/callback"
}

func zgameLaunchBaseURL(game gamedomain.LaunchableGame, config zgameAdapterConfig) string {
	for _, key := range []string{game.ProviderGameID, game.GameID, strings.ToLower(game.GameID)} {
		if raw := strings.TrimSpace(config.GameURLs[strings.TrimSpace(key)]); raw != "" {
			return raw
		}
	}
	if config.LaunchURLTemplate == "" {
		return ""
	}
	replacer := strings.NewReplacer(
		"{provider_game_id}", strings.TrimSpace(game.ProviderGameID),
		"{providerGameId}", strings.TrimSpace(game.ProviderGameID),
		"{game_id}", strings.TrimSpace(game.GameID),
		"{gameId}", strings.TrimSpace(game.GameID),
	)
	return strings.TrimSpace(replacer.Replace(config.LaunchURLTemplate))
}

func (s *Service) handleZGameOperation(ctx context.Context, app string, platform gamedomain.Platform, req *gamev1.CallbackRequest, operation string, requestHash string) ([]byte, string, string, bool, string, error) {
	// IP 白名单为空时兼容联调环境；一旦后台配置，固定回调入口先挡掉非厂商来源。
	if !callbackIPAllowed(req, platform.CallbackIPWhitelist) {
		return zgameAdapterError(zgameCodeUnauthorized, "Unauthorized", false, "")
	}
	config := zgameConfigFromPlatform(platform)
	switch zgameOperation(operation) {
	case "login":
		return s.handleZGameLogin(ctx, app, config, req)
	case "session_renew":
		return s.handleZGameSessionRenew(ctx, app, config, platform.CallbackSecretCiphertext, req)
	case "user_info_batch":
		return s.handleZGameUserInfoBatch(ctx, app, config, platform.CallbackSecretCiphertext, req)
	case "consume":
		return s.handleZGameConsume(ctx, app, config, platform.CallbackSecretCiphertext, req, requestHash)
	default:
		return zgameAdapterError(zgameCodeOK, "success", false, "")
	}
}

func zgameOperation(operation string) string {
	normalized := strings.Trim(strings.ToLower(strings.TrimSpace(operation)), "/")
	normalized = strings.TrimPrefix(normalized, "api/")
	normalized = strings.TrimPrefix(normalized, "server/")
	normalized = strings.TrimPrefix(normalized, "client/")
	return strings.Trim(normalized, "/")
}

type zgameLoginBody struct {
	OpenID      string `json:"open_id"`
	OpenIDV2    string `json:"openId"`
	JSCode      string `json:"js_code"`
	JSCodeV2    string `json:"jsCode"`
	JSCodeV3    string `json:"code"`
	CallbackURL string `json:"callback_url"`
}

func (body zgameLoginBody) openID() string {
	return firstNonEmpty(body.OpenID, body.OpenIDV2)
}

func (body zgameLoginBody) jsCode() string {
	return firstNonEmpty(body.JSCode, body.JSCodeV2, body.JSCodeV3)
}

func (s *Service) handleZGameLogin(ctx context.Context, app string, config zgameAdapterConfig, req *gamev1.CallbackRequest) ([]byte, string, string, bool, string, error) {
	var body zgameLoginBody
	if err := decodeYomiJSON(req.GetRawBody(), &body); err != nil {
		return zgameAdapterError(zgameCodeInvalidCode, "Invalid or Expired Code", false, "")
	}
	openID := body.openID()
	jsCode := body.jsCode()
	session, err := s.validZGameSession(ctx, app, gamedomain.PlatformCodeZGame, jsCode, "")
	if err != nil || !zgameSessionMatches(session, config, openID, "") {
		return zgameAdapterError(zgameCodeInvalidCode, "Invalid or Expired Code", true, "")
	}
	snapshot, err := s.yomiUserSnapshot(ctx, app, req, session.UserID)
	if err != nil {
		return zgameAdapterError(zgameCodeFromError(err), zgameMessageFromError(err), true, "")
	}
	raw, contentType := zgameJSON(zgameCodeOK, "success", zgameLoginData(session, config, openID, jsCode, snapshot, s.now()))
	return raw, contentType, strconv.Itoa(zgameCodeOK), true, "", nil
}

type zgameSignedSessionBody struct {
	OpenID       string `json:"open_id"`
	OpenIDV2     string `json:"openId"`
	Session      string `json:"session"`
	Signature    string `json:"signature"`
	RawGameID    any    `json:"game_id"`
	RawGameIDV2  any    `json:"gameId"`
	RawTimestamp any    `json:"timestamp"`
}

func (body zgameSignedSessionBody) openID() string {
	return firstNonEmpty(body.OpenID, body.OpenIDV2)
}

func (body zgameSignedSessionBody) gameIDText() string {
	return zgameAnyString(firstNonEmpty(zgameAnyString(body.RawGameID), zgameAnyString(body.RawGameIDV2)))
}

func (s *Service) handleZGameSessionRenew(ctx context.Context, app string, config zgameAdapterConfig, secret string, req *gamev1.CallbackRequest) ([]byte, string, string, bool, string, error) {
	body, signed, session, err := s.zgameSignedSession(ctx, app, config, secret, req)
	if !signed {
		return zgameAdapterError(zgameCodeInvalidSignature, "Invalid Signature", false, "")
	}
	if err != nil || !zgameSessionMatches(session, config, body.openID(), body.gameIDText()) {
		return zgameAdapterError(zgameCodeInvalidSession, "Invalid Session", true, "")
	}
	raw, contentType := zgameJSON(zgameCodeOK, "success", map[string]any{
		"session":         body.Session,
		"session_expired": zgameSessionTTLMS(session, s.now()),
	})
	return raw, contentType, strconv.Itoa(zgameCodeOK), true, "", nil
}

type zgameUserInfoBatchBody struct {
	OpenIDList   []string `json:"open_id_list"`
	OpenIDListV2 []string `json:"openIdList"`
	OpenID       string   `json:"open_id"`
	OpenIDV2     string   `json:"openId"`
	Session      string   `json:"session"`
	Signature    string   `json:"signature"`
}

func (body zgameUserInfoBatchBody) openID() string {
	return firstNonEmpty(body.OpenID, body.OpenIDV2)
}

func (body zgameUserInfoBatchBody) openIDList() []string {
	if len(body.OpenIDList) > 0 {
		return body.OpenIDList
	}
	return body.OpenIDListV2
}

func (s *Service) handleZGameUserInfoBatch(ctx context.Context, app string, config zgameAdapterConfig, secret string, req *gamev1.CallbackRequest) ([]byte, string, string, bool, string, error) {
	var body zgameUserInfoBatchBody
	if err := decodeYomiJSON(req.GetRawBody(), &body); err != nil {
		return zgameAdapterError(zgameCodeInvalidSession, "Invalid Session", false, "")
	}
	if !zgameSignatureValid(body.openID(), body.Session, body.Signature, secret) {
		return zgameAdapterError(zgameCodeInvalidSignature, "Invalid Signature", false, "")
	}
	session, err := s.validZGameSession(ctx, app, gamedomain.PlatformCodeZGame, body.Session, "")
	if err != nil || !zgameSessionMatches(session, config, body.openID(), "") {
		return zgameAdapterError(zgameCodeInvalidSession, "Invalid Session", true, "")
	}
	userInfos := make(map[string]any, len(body.openIDList()))
	for _, openID := range body.openIDList() {
		openID = strings.TrimSpace(openID)
		if openID == "" {
			continue
		}
		data, ok := s.zgameUserInfoForOpenID(ctx, app, config, req, session, openID)
		if ok {
			userInfos[openID] = data
		}
	}
	raw, contentType := zgameJSON(zgameCodeOK, "success", map[string]any{"user_infos": userInfos})
	return raw, contentType, strconv.Itoa(zgameCodeOK), true, "", nil
}

type zgameConsumeBody struct {
	OpenID            string      `json:"open_id"`
	OpenIDV2          string      `json:"openId"`
	Session           string      `json:"session"`
	Amount            json.Number `json:"amount"`
	OrderID           string      `json:"order_id"`
	OrderIDV2         string      `json:"orderId"`
	GameID            string      `json:"game_id"`
	GameIDV2          string      `json:"gameId"`
	Timestamp         int64       `json:"timestamp"`
	RoundID           string      `json:"round_id"`
	RoundIDV2         string      `json:"roundId"`
	Type              int32       `json:"type"`
	MerchantPayload   string      `json:"merchant_payload"`
	MerchantPayloadV2 string      `json:"merchantPayload"`
	Signature         string      `json:"signature"`
}

func (body zgameConsumeBody) openID() string {
	return firstNonEmpty(body.OpenID, body.OpenIDV2)
}

func (body zgameConsumeBody) orderID() string {
	return firstNonEmpty(body.OrderID, body.OrderIDV2)
}

func (body zgameConsumeBody) gameID() string {
	return firstNonEmpty(body.GameID, body.GameIDV2)
}

func (body zgameConsumeBody) roundID() string {
	return firstNonEmpty(body.RoundID, body.RoundIDV2)
}

func (body zgameConsumeBody) merchantPayload() string {
	return firstNonEmpty(body.MerchantPayload, body.MerchantPayloadV2)
}

func (s *Service) handleZGameConsume(ctx context.Context, app string, config zgameAdapterConfig, secret string, req *gamev1.CallbackRequest, requestHash string) ([]byte, string, string, bool, string, error) {
	var body zgameConsumeBody
	if err := decodeYomiJSON(req.GetRawBody(), &body); err != nil {
		return zgameAdapterError(zgameCodeUnauthorized, "Unauthorized", false, "")
	}
	if !zgameSignatureValid(body.openID(), body.Session, body.Signature, secret) {
		return zgameAdapterError(zgameCodeInvalidSignature, "Invalid Signature", false, body.orderID())
	}
	session, err := s.validZGameSession(ctx, app, gamedomain.PlatformCodeZGame, body.Session, body.gameID())
	if err != nil || !zgameSessionMatches(session, config, body.openID(), body.gameID()) {
		return zgameAdapterError(zgameCodeUnauthorized, "Unauthorized", true, body.orderID())
	}
	amount, amountOK := zgameAmount(body.Amount)
	opType, coinAmount := zgameOpType(body.Type, amount)
	if body.orderID() == "" || body.gameID() == "" || !amountOK || coinAmount < 0 || opType == "" {
		return zgameAdapterError(zgameCodeUnauthorized, "Unauthorized", true, body.orderID())
	}
	if session.GameID == "" {
		session.GameID = body.gameID()
	}
	if session.ProviderGameID == "" {
		session.ProviderGameID = body.gameID()
	}
	providerOrderID := zgameProviderOrderID(body.orderID(), opType)
	result, err := s.applyYomiCoinChange(ctx, app, req, session, providerOrderID, body.roundID(), opType, coinAmount, "", requestHash)
	if err != nil {
		code := zgameCodeFromError(err)
		balance := s.bestEffortCoinBalance(ctx, app, req.GetMeta().GetRequestId(), session.UserID)
		raw, contentType := zgameBalanceJSON(code, zgameMessageFromError(err), balance)
		return raw, contentType, strconv.Itoa(code), true, body.orderID(), nil
	}
	raw, contentType := zgameBalanceJSON(zgameCodeOK, "success", result.BalanceAfter)
	return raw, contentType, strconv.Itoa(zgameCodeOK), true, body.orderID(), nil
}

func (s *Service) zgameSignedSession(ctx context.Context, app string, config zgameAdapterConfig, secret string, req *gamev1.CallbackRequest) (zgameSignedSessionBody, bool, gamedomain.LaunchSession, error) {
	var body zgameSignedSessionBody
	if err := decodeYomiJSON(req.GetRawBody(), &body); err != nil {
		return zgameSignedSessionBody{}, false, gamedomain.LaunchSession{}, xerr.New(xerr.InvalidArgument, "invalid payload")
	}
	if !zgameSignatureValid(body.openID(), body.Session, body.Signature, secret) {
		return body, false, gamedomain.LaunchSession{}, xerr.New(xerr.Unauthorized, "signature invalid")
	}
	session, err := s.validZGameSession(ctx, app, gamedomain.PlatformCodeZGame, body.Session, body.gameIDText())
	if err != nil {
		return body, true, gamedomain.LaunchSession{}, err
	}
	if !zgameSessionMatches(session, config, body.openID(), body.gameIDText()) {
		return body, true, gamedomain.LaunchSession{}, xerr.New(xerr.Unauthorized, "session mismatch")
	}
	return body, true, session, nil
}

func (s *Service) validZGameSession(ctx context.Context, app string, platformCode string, token string, providerGameID string) (gamedomain.LaunchSession, error) {
	token = strings.TrimSpace(token)
	if token == "" {
		return gamedomain.LaunchSession{}, xerr.New(xerr.Unauthorized, "session invalid")
	}
	// 新版启动链路使用服务端短期 js_code；保留 JWT 兼容旧测试链接，避免已打开的 H5 立即失效。
	if strings.Count(token, ".") == 2 {
		if session, err := s.appSessionFromAccessToken(app, token); err == nil {
			return session, nil
		}
	}
	if session, err := s.validScopedYomiSession(ctx, app, platformCode, token, providerGameID); err == nil {
		return session, nil
	}
	if strings.Count(token, ".") == 2 {
		return s.appSessionFromAccessToken(app, token)
	}
	return gamedomain.LaunchSession{}, xerr.New(xerr.Unauthorized, "session invalid")
}

func zgameSessionMatches(session gamedomain.LaunchSession, config zgameAdapterConfig, openID string, gameID string) bool {
	if strings.TrimSpace(gameID) != "" && strings.TrimSpace(session.ProviderGameID) != "" && strings.TrimSpace(gameID) != strings.TrimSpace(session.ProviderGameID) {
		return false
	}
	openID = strings.TrimSpace(openID)
	return openID != "" && (openID == externalUserID(session, config.UIDMode) ||
		openID == strings.TrimSpace(session.DisplayUserID) ||
		openID == strconv.FormatInt(session.UserID, 10))
}

func zgameSignatureValid(openID string, session string, signature string, secret string) bool {
	openID = strings.TrimSpace(openID)
	session = strings.TrimSpace(session)
	secret = strings.TrimSpace(secret)
	signature = strings.TrimSpace(signature)
	if openID == "" || session == "" || secret == "" || signature == "" {
		return false
	}
	sum := sha256.Sum256([]byte(openID + session + secret))
	expected := hex.EncodeToString(sum[:])
	return subtle.ConstantTimeCompare([]byte(strings.ToLower(signature)), []byte(expected)) == 1
}

func zgameLoginData(session gamedomain.LaunchSession, config zgameAdapterConfig, requestedOpenID string, token string, snapshot yomiUserSnapshot, now time.Time) map[string]any {
	openID := strings.TrimSpace(requestedOpenID)
	if openID == "" {
		openID = externalUserID(session, config.UIDMode)
	}
	return map[string]any{
		"session":         token,
		"session_expired": zgameSessionTTLMS(session, now),
		"openId":          openID,
		"userName":        snapshot.Nickname,
		"nickname":        snapshot.Nickname,
		"avatar":          snapshot.Avatar,
		"balance":         snapshot.Balance,
		"level":           config.Level,
		"country":         "",
		"gender":          config.Gender,
		"sex":             config.Gender,
	}
}

func (s *Service) zgameUserInfoForOpenID(ctx context.Context, app string, config zgameAdapterConfig, req *gamev1.CallbackRequest, session gamedomain.LaunchSession, openID string) (map[string]any, bool) {
	userID := int64(0)
	if openID == externalUserID(session, config.UIDMode) || openID == strings.TrimSpace(session.DisplayUserID) {
		userID = session.UserID
	} else if !strings.EqualFold(config.UIDMode, "display_user_id") {
		// 批量查询没有 display_id -> user_id 解析依赖；默认 user_id 模式可直接按 open_id 查用户资料。
		parsed, err := strconv.ParseInt(openID, 10, 64)
		if err == nil && parsed > 0 {
			userID = parsed
		}
	}
	if userID <= 0 {
		return nil, false
	}
	snapshot, err := s.yomiUserSnapshot(ctx, app, req, userID)
	if err != nil {
		return nil, false
	}
	return zgameUserInfoData(config, snapshot), true
}

func zgameUserInfoData(config zgameAdapterConfig, snapshot yomiUserSnapshot) map[string]any {
	return map[string]any{
		"userName": snapshot.Nickname,
		"nickname": snapshot.Nickname,
		"gender":   config.Gender,
		"level":    config.Level,
		"avatar":   snapshot.Avatar,
		"balance":  snapshot.Balance,
	}
}

func zgameSessionTTLMS(session gamedomain.LaunchSession, now time.Time) int64 {
	if session.ExpiresAtMS <= 0 {
		return int64(zgameDefaultTokenTTL / time.Millisecond)
	}
	ttl := session.ExpiresAtMS - now.UnixMilli()
	if ttl < 0 {
		return 0
	}
	return ttl
}

func zgameAmount(value json.Number) (int64, bool) {
	raw := strings.TrimSpace(value.String())
	if raw == "" {
		return 0, false
	}
	amount, err := strconv.ParseInt(raw, 10, 64)
	if err != nil {
		return 0, false
	}
	return amount, true
}

func zgameOpType(op int32, amount int64) (string, int64) {
	if amount == -1<<63 {
		return "", -1
	}
	coinAmount := amount
	if coinAmount < 0 {
		coinAmount = -coinAmount
	}
	if amount < 0 || op == 1 {
		return "credit", coinAmount
	}
	if op == 0 {
		return "debit", coinAmount
	}
	return "", coinAmount
}

func zgameProviderOrderID(orderID string, opType string) string {
	orderID = strings.TrimSpace(orderID)
	opType = strings.TrimSpace(opType)
	if orderID == "" || opType == "" {
		return orderID
	}
	return orderID + ":" + opType
}

func zgameAnyString(value any) string {
	switch typed := value.(type) {
	case nil:
		return ""
	case string:
		return strings.TrimSpace(typed)
	case json.Number:
		return strings.TrimSpace(typed.String())
	case float64:
		if typed == math.Trunc(typed) {
			return strconv.FormatInt(int64(typed), 10)
		}
		return strconv.FormatFloat(typed, 'f', -1, 64)
	case float32:
		return strconv.FormatFloat(float64(typed), 'f', -1, 32)
	case int:
		return strconv.Itoa(typed)
	case int64:
		return strconv.FormatInt(typed, 10)
	case int32:
		return strconv.FormatInt(int64(typed), 10)
	case uint64:
		return strconv.FormatUint(typed, 10)
	default:
		return strings.TrimSpace(fmt.Sprint(value))
	}
}

func zgameAdapterError(code int, message string, signatureValid bool, providerRequestID string) ([]byte, string, string, bool, string, error) {
	raw, contentType := zgameJSON(code, message, nil)
	return raw, contentType, strconv.Itoa(code), signatureValid, strings.TrimSpace(providerRequestID), nil
}

func zgameJSON(code int, message string, data any) ([]byte, string) {
	if strings.TrimSpace(message) == "" && code == zgameCodeOK {
		message = "success"
	}
	return jsonResponse(map[string]any{
		"code":   code,
		"errmsg": strings.TrimSpace(message),
		"data":   data,
	})
}

func zgameBalanceJSON(code int, message string, balance int64) ([]byte, string) {
	if strings.TrimSpace(message) == "" && code == zgameCodeOK {
		message = "success"
	}
	return jsonResponse(map[string]any{
		"code":    code,
		"errmsg":  strings.TrimSpace(message),
		"balance": balance,
		"data": map[string]any{
			"balance": balance,
		},
	})
}

func zgameCodeFromError(err error) int {
	switch {
	case err == nil:
		return zgameCodeOK
	case xerr.IsCode(err, xerr.InsufficientBalance):
		return zgameCodeInsufficientBalance
	case xerr.IsCode(err, xerr.SessionExpired), xerr.IsCode(err, xerr.Unauthorized):
		return zgameCodeUnauthorized
	default:
		return zgameCodeInternalError
	}
}

func zgameMessageFromError(err error) string {
	switch zgameCodeFromError(err) {
	case zgameCodeInsufficientBalance:
		return "Insufficient Funds"
	case zgameCodeUnauthorized:
		return "Unauthorized"
	case zgameCodeOK:
		return "success"
	default:
		return "Internal Error"
	}
}