package grpc

import (
	"context"
	"time"

	walletv1 "hyapp.local/api/proto/wallet/v1"
	"hyapp/pkg/appcode"
	"hyapp/pkg/xerr"
	"hyapp/services/wallet-service/internal/domain/ledger"
	walletservice "hyapp/services/wallet-service/internal/service/wallet"
)

// Server 把 wallet-service 用例层适配为 gRPC 接口。
type Server struct {
	walletv1.UnimplementedWalletServiceServer

	svc *walletservice.Service
}

// NewServer 创建 wallet gRPC server。
func NewServer(svc *walletservice.Service) *Server {
	return &Server{svc: svc}
}

// DebitGift 只负责 protobuf 转换和错误映射，扣费规则在 service/repository。
func (s *Server) DebitGift(ctx context.Context, req *walletv1.DebitGiftRequest) (*walletv1.DebitGiftResponse, error) {
	ctx = appcode.WithContext(ctx, req.GetAppCode())
	receipt, err := s.svc.DebitGift(ctx, ledger.DebitGiftCommand{
		AppCode:        req.GetAppCode(),
		CommandID:      req.GetCommandId(),
		RoomID:         req.GetRoomId(),
		SenderUserID:   req.GetSenderUserId(),
		TargetUserID:   req.GetTargetUserId(),
		GiftID:         req.GetGiftId(),
		GiftCount:      req.GetGiftCount(),
		PriceVersion:   req.GetPriceVersion(),
		RegionID:       req.GetRegionId(),
		SenderRegionID: req.GetSenderRegionId(),
		TargetIsHost:   req.GetTargetIsHost(),
		// 工资政策区域来自 user-service host profile，不能用房间 visible_region_id 兜底。
		TargetHostRegionID:      req.GetTargetHostRegionId(),
		TargetAgencyOwnerUserID: req.GetTargetAgencyOwnerUserId(),
	})
	if err != nil {
		return nil, xerr.ToGRPCError(err)
	}

	return debitGiftResponseFromReceipt(receipt), nil
}

// BatchDebitGift 只负责批量目标 protobuf 转换；同事务扣费和幂等由 wallet service/repository 保证。
func (s *Server) BatchDebitGift(ctx context.Context, req *walletv1.BatchDebitGiftRequest) (*walletv1.BatchDebitGiftResponse, error) {
	ctx = appcode.WithContext(ctx, req.GetAppCode())
	targets := make([]ledger.DebitGiftTargetCommand, 0, len(req.GetTargets()))
	for _, target := range req.GetTargets() {
		targets = append(targets, ledger.DebitGiftTargetCommand{
			CommandID:               target.GetCommandId(),
			TargetUserID:            target.GetTargetUserId(),
			TargetIsHost:            target.GetTargetIsHost(),
			TargetHostRegionID:      target.GetTargetHostRegionId(),
			TargetAgencyOwnerUserID: target.GetTargetAgencyOwnerUserId(),
		})
	}
	receipt, err := s.svc.BatchDebitGift(ctx, ledger.BatchDebitGiftCommand{
		AppCode:        req.GetAppCode(),
		CommandID:      req.GetCommandId(),
		RoomID:         req.GetRoomId(),
		SenderUserID:   req.GetSenderUserId(),
		GiftID:         req.GetGiftId(),
		GiftCount:      req.GetGiftCount(),
		PriceVersion:   req.GetPriceVersion(),
		RegionID:       req.GetRegionId(),
		SenderRegionID: req.GetSenderRegionId(),
		Targets:        targets,
	})
	if err != nil {
		return nil, xerr.ToGRPCError(err)
	}
	response := &walletv1.BatchDebitGiftResponse{
		Aggregate: debitGiftResponseFromReceipt(receipt.Aggregate),
		Receipts:  make([]*walletv1.BatchDebitGiftReceipt, 0, len(receipt.Targets)),
	}
	for _, target := range receipt.Targets {
		response.Receipts = append(response.Receipts, &walletv1.BatchDebitGiftReceipt{
			TargetUserId: target.TargetUserID,
			CommandId:    target.CommandID,
			Billing:      debitGiftResponseFromReceipt(target.Receipt),
		})
	}
	return response, nil
}

// DebitRobotGift 扣机器人专用金币；该入口只供内部机器人房间编排链路调用。
func (s *Server) DebitRobotGift(ctx context.Context, req *walletv1.DebitRobotGiftRequest) (*walletv1.DebitGiftResponse, error) {
	ctx = appcode.WithContext(ctx, req.GetAppCode())
	receipt, err := s.svc.DebitRobotGift(ctx, ledger.DebitGiftCommand{
		AppCode:        req.GetAppCode(),
		CommandID:      req.GetCommandId(),
		RoomID:         req.GetRoomId(),
		SenderUserID:   req.GetSenderUserId(),
		TargetUserID:   req.GetTargetUserId(),
		GiftID:         req.GetGiftId(),
		GiftCount:      req.GetGiftCount(),
		PriceVersion:   req.GetPriceVersion(),
		RegionID:       req.GetRegionId(),
		SenderRegionID: req.GetSenderRegionId(),
	})
	if err != nil {
		return nil, xerr.ToGRPCError(err)
	}
	return debitGiftResponseFromReceipt(receipt), nil
}

func debitGiftResponseFromReceipt(receipt ledger.Receipt) *walletv1.DebitGiftResponse {
	return &walletv1.DebitGiftResponse{
		BillingReceiptId:       receipt.BillingReceiptID,
		BalanceAfter:           receipt.BalanceAfter,
		TransactionId:          receipt.TransactionID,
		CoinSpent:              receipt.CoinSpent,
		ChargeAssetType:        receipt.ChargeAssetType,
		ChargeAmount:           receipt.ChargeAmount,
		GiftPointAdded:         receipt.GiftPointAdded,
		HeatValue:              receipt.HeatValue,
		GiftTypeCode:           receipt.GiftTypeCode,
		CpRelationType:         receipt.CPRelationType,
		GiftName:               receipt.GiftName,
		GiftIconUrl:            receipt.GiftIconURL,
		GiftAnimationUrl:       receipt.GiftAnimationURL,
		GiftEffectTypes:        receipt.GiftEffectTypes,
		PriceVersion:           receipt.PriceVersion,
		HostPeriodDiamondAdded: receipt.HostPeriodDiamondAdded,
		HostPeriodCycleKey:     receipt.HostPeriodCycleKey,
	}
}

// GetBalances 返回用户多资产余额投影。
func (s *Server) GetBalances(ctx context.Context, req *walletv1.GetBalancesRequest) (*walletv1.GetBalancesResponse, error) {
	ctx = appcode.WithContext(ctx, req.GetAppCode())
	balances, err := s.svc.GetBalances(ctx, req.GetUserId(), req.GetAssetTypes())
	if err != nil {
		return nil, xerr.ToGRPCError(err)
	}

	response := &walletv1.GetBalancesResponse{Balances: make([]*walletv1.AssetBalance, 0, len(balances))}
	for _, balance := range balances {
		response.Balances = append(response.Balances, &walletv1.AssetBalance{
			AppCode:         balance.AppCode,
			AssetType:       balance.AssetType,
			AvailableAmount: balance.AvailableAmount,
			FrozenAmount:    balance.FrozenAmount,
			Version:         balance.Version,
		})
	}

	return response, nil
}

// GetActiveHostSalaryPolicy 读取当前生效的主播工资政策，供 gateway 按当前主播区域展示平台规则。
func (s *Server) GetActiveHostSalaryPolicy(ctx context.Context, req *walletv1.GetActiveHostSalaryPolicyRequest) (*walletv1.GetActiveHostSalaryPolicyResponse, error) {
	ctx = appcode.WithContext(ctx, req.GetAppCode())
	policy, found, err := s.svc.GetActiveHostSalaryPolicy(ctx, req.GetAppCode(), req.GetRegionId(), req.GetSettlementMode(), req.GetSettlementTriggerMode(), req.GetNowMs())
	if err != nil {
		return nil, xerr.ToGRPCError(err)
	}
	response := &walletv1.GetActiveHostSalaryPolicyResponse{Found: found}
	if found {
		response.Policy = hostSalaryPolicyToProto(policy)
	}
	return response, nil
}

// GetHostSalaryProgress 读取主播当前工资周期钻石累计，gateway 用它计算工资政策等级进度。
func (s *Server) GetHostSalaryProgress(ctx context.Context, req *walletv1.GetHostSalaryProgressRequest) (*walletv1.GetHostSalaryProgressResponse, error) {
	ctx = appcode.WithContext(ctx, req.GetAppCode())
	progress, err := s.svc.GetHostSalaryProgress(ctx, req.GetAppCode(), req.GetHostUserId(), req.GetCycleKey(), req.GetNowMs())
	if err != nil {
		return nil, xerr.ToGRPCError(err)
	}
	return &walletv1.GetHostSalaryProgressResponse{Progress: hostSalaryProgressToProto(progress)}, nil
}

func hostSalaryProgressToProto(progress ledger.HostSalaryProgress) *walletv1.HostSalaryProgress {
	return &walletv1.HostSalaryProgress{
		HostUserId:        progress.HostUserID,
		CycleKey:          progress.CycleKey,
		RegionId:          progress.RegionID,
		AgencyOwnerUserId: progress.AgencyOwnerUserID,
		TotalDiamonds:     progress.TotalDiamonds,
		GiftDiamondTotal:  progress.GiftDiamondTotal,
		UpdatedAtMs:       progress.UpdatedAtMS,
	}
}

func hostSalaryPolicyToProto(policy ledger.HostSalaryPolicy) *walletv1.HostSalaryPolicy {
	levels := make([]*walletv1.HostSalaryPolicyLevel, 0, len(policy.Levels))
	for _, level := range policy.Levels {
		levels = append(levels, hostSalaryPolicyLevelToProto(level))
	}
	return &walletv1.HostSalaryPolicy{
		PolicyId:                 policy.PolicyID,
		Name:                     policy.Name,
		RegionId:                 policy.RegionID,
		Status:                   policy.Status,
		SettlementMode:           policy.SettlementMode,
		SettlementTriggerMode:    policy.SettlementTriggerMode,
		GiftCoinToDiamondRatio:   policy.GiftCoinToDiamondRatio,
		ResidualDiamondToUsdRate: policy.ResidualDiamondToUSDRate,
		EffectiveFromMs:          policy.EffectiveFromMs,
		EffectiveToMs:            policy.EffectiveToMs,
		Levels:                   levels,
	}
}

func hostSalaryPolicyLevelToProto(level ledger.HostSalaryPolicyLevel) *walletv1.HostSalaryPolicyLevel {
	return &walletv1.HostSalaryPolicyLevel{
		LevelNo:              int32(level.LevelNo),
		RequiredDiamonds:     level.RequiredDiamonds,
		HostSalaryUsdMinor:   level.HostSalaryUSDMinor,
		HostCoinReward:       level.HostCoinReward,
		AgencySalaryUsdMinor: level.AgencySalaryUSDMinor,
		Status:               level.Status,
		SortOrder:            int32(level.SortOrder),
	}
}

// GetWalletOverview 返回钱包首页摘要，供我的页和钱包二级页复用。
func (s *Server) GetWalletOverview(ctx context.Context, req *walletv1.GetWalletOverviewRequest) (*walletv1.GetWalletOverviewResponse, error) {
	ctx = appcode.WithContext(ctx, req.GetAppCode())
	overview, err := s.svc.GetWalletOverview(ctx, req.GetUserId())
	if err != nil {
		return nil, xerr.ToGRPCError(err)
	}
	return &walletv1.GetWalletOverviewResponse{
		Balances:     balancesToProto(overview.Balances),
		FeatureFlags: walletFeatureFlagsToProto(overview.FeatureFlags),
	}, nil
}

// GetWalletValueSummary 返回我的页钱包卡片最小金币余额。
func (s *Server) GetWalletValueSummary(ctx context.Context, req *walletv1.GetWalletValueSummaryRequest) (*walletv1.GetWalletValueSummaryResponse, error) {
	ctx = appcode.WithContext(ctx, req.GetAppCode())
	summary, err := s.svc.GetWalletValueSummary(ctx, req.GetUserId())
	if err != nil {
		return nil, xerr.ToGRPCError(err)
	}
	return &walletv1.GetWalletValueSummaryResponse{Summary: &walletv1.WalletValueSummary{
		CoinAmount:  summary.CoinAmount,
		UpdatedAtMs: summary.UpdatedAtMS,
	}}, nil
}

// GetUserGiftWall 返回当前用户收到礼物的聚合墙；调用方负责限定 user_id 为当前登录用户。
func (s *Server) GetUserGiftWall(ctx context.Context, req *walletv1.GetUserGiftWallRequest) (*walletv1.GetUserGiftWallResponse, error) {
	ctx = appcode.WithContext(ctx, req.GetAppCode())
	wall, err := s.svc.GetUserGiftWall(ctx, req.GetUserId())
	if err != nil {
		return nil, xerr.ToGRPCError(err)
	}
	resp := &walletv1.GetUserGiftWallResponse{
		Items:             make([]*walletv1.GiftWallItem, 0, len(wall.Items)),
		GiftKindCount:     wall.GiftKindCount,
		GiftTotalCount:    wall.GiftTotalCount,
		TotalValue:        wall.TotalValue,
		TotalCoinValue:    wall.TotalCoinValue,
		TotalDiamondValue: wall.TotalDiamondValue,
		TotalGiftPoint:    wall.TotalGiftPoint,
		TotalHeatValue:    wall.TotalHeatValue,
	}
	for _, item := range wall.Items {
		resp.Items = append(resp.Items, giftWallItemToProto(item))
	}
	return resp, nil
}

// ListRechargeProducts 返回当前用户区域可用的充值渠道和档位。
func (s *Server) ListRechargeProducts(ctx context.Context, req *walletv1.ListRechargeProductsRequest) (*walletv1.ListRechargeProductsResponse, error) {
	ctx = appcode.WithContext(ctx, req.GetAppCode())
	products, channels, err := s.svc.ListRechargeProducts(ctx, req.GetUserId(), req.GetRegionId(), req.GetPlatform(), req.GetAudienceType())
	if err != nil {
		return nil, xerr.ToGRPCError(err)
	}
	resp := &walletv1.ListRechargeProductsResponse{Channels: channels, Products: make([]*walletv1.RechargeProduct, 0, len(products))}
	for _, product := range products {
		resp.Products = append(resp.Products, rechargeProductToProto(product))
	}
	return resp, nil
}

// ConfirmGooglePayment 校验 Google Play purchase token 并完成钱包入账。
func (s *Server) ConfirmGooglePayment(ctx context.Context, req *walletv1.ConfirmGooglePaymentRequest) (*walletv1.ConfirmGooglePaymentResponse, error) {
	ctx = appcode.WithContext(ctx, req.GetAppCode())
	receipt, err := s.svc.ConfirmGooglePayment(ctx, ledger.GooglePaymentCommand{
		AppCode:        req.GetAppCode(),
		CommandID:      req.GetCommandId(),
		UserID:         req.GetUserId(),
		RegionID:       req.GetRegionId(),
		ProductID:      req.GetProductId(),
		ProductCode:    req.GetProductCode(),
		PackageName:    req.GetPackageName(),
		PurchaseToken:  req.GetPurchaseToken(),
		OrderID:        req.GetOrderId(),
		PurchaseTimeMS: req.GetPurchaseTimeMs(),
	})
	if err != nil {
		return nil, xerr.ToGRPCError(err)
	}
	return &walletv1.ConfirmGooglePaymentResponse{
		PaymentOrderId:   receipt.PaymentOrderID,
		TransactionId:    receipt.TransactionID,
		Status:           receipt.Status,
		ProductId:        receipt.ProductID,
		ProductCode:      receipt.ProductCode,
		CoinAmount:       receipt.CoinAmount,
		Balance:          balanceToProto(receipt.Balance),
		IdempotentReplay: receipt.IdempotentReplay,
		ConsumeState:     receipt.ConsumeState,
	}, nil
}

// ListAdminRechargeProducts 返回后台内购配置列表。
func (s *Server) ListAdminRechargeProducts(ctx context.Context, req *walletv1.ListAdminRechargeProductsRequest) (*walletv1.ListAdminRechargeProductsResponse, error) {
	ctx = appcode.WithContext(ctx, req.GetAppCode())
	products, total, err := s.svc.ListAdminRechargeProducts(ctx, ledger.ListRechargeProductsQuery{
		AppCode:      req.GetAppCode(),
		Status:       req.GetStatus(),
		Platform:     req.GetPlatform(),
		RegionID:     req.GetRegionId(),
		Keyword:      req.GetKeyword(),
		Page:         req.GetPage(),
		PageSize:     req.GetPageSize(),
		AudienceType: req.GetAudienceType(),
	})
	if err != nil {
		return nil, xerr.ToGRPCError(err)
	}
	resp := &walletv1.ListAdminRechargeProductsResponse{Products: make([]*walletv1.RechargeProduct, 0, len(products)), Total: total}
	for _, product := range products {
		resp.Products = append(resp.Products, rechargeProductToProto(product))
	}
	return resp, nil
}

// CreateRechargeProduct 创建后台内购商品配置。
func (s *Server) CreateRechargeProduct(ctx context.Context, req *walletv1.CreateRechargeProductRequest) (*walletv1.RechargeProductResponse, error) {
	ctx = appcode.WithContext(ctx, req.GetAppCode())
	product, err := s.svc.CreateRechargeProduct(ctx, ledger.RechargeProductCommand{
		AppCode:        req.GetAppCode(),
		AmountMicro:    req.GetAmountMicro(),
		CoinAmount:     req.GetCoinAmount(),
		ProductName:    req.GetProductName(),
		Description:    req.GetDescription(),
		Platform:       req.GetPlatform(),
		RegionIDs:      req.GetRegionIds(),
		Enabled:        req.GetEnabled(),
		OperatorUserID: req.GetOperatorUserId(),
		AudienceType:   req.GetAudienceType(),
	})
	if err != nil {
		return nil, xerr.ToGRPCError(err)
	}
	return &walletv1.RechargeProductResponse{Product: rechargeProductToProto(product)}, nil
}

// UpdateRechargeProduct 修改后台内购商品配置。
func (s *Server) UpdateRechargeProduct(ctx context.Context, req *walletv1.UpdateRechargeProductRequest) (*walletv1.RechargeProductResponse, error) {
	ctx = appcode.WithContext(ctx, req.GetAppCode())
	product, err := s.svc.UpdateRechargeProduct(ctx, ledger.RechargeProductCommand{
		AppCode:        req.GetAppCode(),
		ProductID:      req.GetProductId(),
		AmountMicro:    req.GetAmountMicro(),
		CoinAmount:     req.GetCoinAmount(),
		ProductName:    req.GetProductName(),
		Description:    req.GetDescription(),
		Platform:       req.GetPlatform(),
		RegionIDs:      req.GetRegionIds(),
		Enabled:        req.GetEnabled(),
		OperatorUserID: req.GetOperatorUserId(),
		AudienceType:   req.GetAudienceType(),
	})
	if err != nil {
		return nil, xerr.ToGRPCError(err)
	}
	return &walletv1.RechargeProductResponse{Product: rechargeProductToProto(product)}, nil
}

// DeleteRechargeProduct 删除后台内购商品配置。
func (s *Server) DeleteRechargeProduct(ctx context.Context, req *walletv1.DeleteRechargeProductRequest) (*walletv1.DeleteRechargeProductResponse, error) {
	ctx = appcode.WithContext(ctx, req.GetAppCode())
	if err := s.svc.DeleteRechargeProduct(ctx, req.GetAppCode(), req.GetProductId()); err != nil {
		return nil, xerr.ToGRPCError(err)
	}
	return &walletv1.DeleteRechargeProductResponse{Deleted: true}, nil
}

// ListThirdPartyPaymentChannels 返回三方支付渠道、国家和方式树，后台用它直接渲染二级展开列表。
func (s *Server) ListThirdPartyPaymentChannels(ctx context.Context, req *walletv1.ListThirdPartyPaymentChannelsRequest) (*walletv1.ListThirdPartyPaymentChannelsResponse, error) {
	ctx = appcode.WithContext(ctx, req.GetAppCode())
	channels, err := s.svc.ListThirdPartyPaymentChannels(ctx, ledger.ListThirdPartyPaymentChannelsQuery{
		AppCode:                req.GetAppCode(),
		ProviderCode:           req.GetProviderCode(),
		Status:                 req.GetStatus(),
		IncludeDisabledMethods: req.GetIncludeDisabledMethods(),
	})
	if err != nil {
		return nil, xerr.ToGRPCError(err)
	}
	resp := &walletv1.ListThirdPartyPaymentChannelsResponse{Channels: make([]*walletv1.ThirdPartyPaymentChannel, 0, len(channels))}
	for _, channel := range channels {
		resp.Channels = append(resp.Channels, thirdPartyPaymentChannelToProto(channel))
	}
	return resp, nil
}

// SetThirdPartyPaymentMethodStatus 开关某个国家下的具体支付方式；渠道本身不被连带关闭。
func (s *Server) SetThirdPartyPaymentMethodStatus(ctx context.Context, req *walletv1.SetThirdPartyPaymentMethodStatusRequest) (*walletv1.ThirdPartyPaymentMethodResponse, error) {
	ctx = appcode.WithContext(ctx, req.GetAppCode())
	method, err := s.svc.SetThirdPartyPaymentMethodStatus(ctx, ledger.ThirdPartyPaymentMethodStatusCommand{
		AppCode:        req.GetAppCode(),
		MethodID:       req.GetMethodId(),
		Enabled:        req.GetEnabled(),
		OperatorUserID: req.GetOperatorUserId(),
	})
	if err != nil {
		return nil, xerr.ToGRPCError(err)
	}
	return &walletv1.ThirdPartyPaymentMethodResponse{Method: thirdPartyPaymentMethodToProto(method)}, nil
}

// UpdateThirdPartyPaymentRate 保存 USD 到国家本币汇率；H5 只展示已配置正汇率的国家方式。
func (s *Server) UpdateThirdPartyPaymentRate(ctx context.Context, req *walletv1.UpdateThirdPartyPaymentRateRequest) (*walletv1.ThirdPartyPaymentMethodResponse, error) {
	ctx = appcode.WithContext(ctx, req.GetAppCode())
	method, err := s.svc.UpdateThirdPartyPaymentRate(ctx, ledger.ThirdPartyPaymentRateCommand{
		AppCode:           req.GetAppCode(),
		MethodID:          req.GetMethodId(),
		USDToCurrencyRate: req.GetUsdToCurrencyRate(),
		OperatorUserID:    req.GetOperatorUserId(),
	})
	if err != nil {
		return nil, xerr.ToGRPCError(err)
	}
	return &walletv1.ThirdPartyPaymentMethodResponse{Method: thirdPartyPaymentMethodToProto(method)}, nil
}

// ListH5RechargeOptions 返回 H5 当前账号的商品和支付方式，普通用户和币商由 audience_type 分流。
func (s *Server) ListH5RechargeOptions(ctx context.Context, req *walletv1.H5RechargeOptionsRequest) (*walletv1.H5RechargeOptionsResponse, error) {
	ctx = appcode.WithContext(ctx, req.GetAppCode())
	options, err := s.svc.ListH5RechargeOptions(ctx, ledger.H5RechargeOptionsQuery{
		AppCode:           req.GetAppCode(),
		TargetUserID:      req.GetTargetUserId(),
		TargetRegionID:    req.GetTargetRegionId(),
		TargetCountryCode: req.GetTargetCountryCode(),
		AudienceType:      req.GetAudienceType(),
	})
	if err != nil {
		return nil, xerr.ToGRPCError(err)
	}
	resp := &walletv1.H5RechargeOptionsResponse{
		Products:         make([]*walletv1.RechargeProduct, 0, len(options.Products)),
		PaymentMethods:   make([]*walletv1.ThirdPartyPaymentMethod, 0, len(options.PaymentMethods)),
		UsdtTrc20Enabled: options.USDTTRC20Enabled,
		UsdtTrc20Address: options.USDTTRC20Address,
	}
	for _, product := range options.Products {
		resp.Products = append(resp.Products, rechargeProductToProto(product))
	}
	for _, method := range options.PaymentMethods {
		resp.PaymentMethods = append(resp.PaymentMethods, thirdPartyPaymentMethodToProto(method))
	}
	return resp, nil
}

// CreateH5RechargeOrder 创建外部充值订单；MiFaPay 只返回 pay_url，USDT 只返回共享收款地址。
func (s *Server) CreateH5RechargeOrder(ctx context.Context, req *walletv1.CreateH5RechargeOrderRequest) (*walletv1.H5RechargeOrderResponse, error) {
	ctx = appcode.WithContext(ctx, req.GetAppCode())
	order, err := s.svc.CreateH5RechargeOrder(ctx, ledger.CreateExternalRechargeOrderCommand{
		AppCode:           req.GetAppCode(),
		CommandID:         req.GetCommandId(),
		TargetUserID:      req.GetTargetUserId(),
		TargetRegionID:    req.GetTargetRegionId(),
		TargetCountryCode: req.GetTargetCountryCode(),
		AudienceType:      req.GetAudienceType(),
		ProductID:         req.GetProductId(),
		ProviderCode:      req.GetProviderCode(),
		PaymentMethodID:   req.GetPaymentMethodId(),
		ReturnURL:         req.GetReturnUrl(),
		NotifyURL:         req.GetNotifyUrl(),
		ClientIP:          req.GetClientIp(),
		Language:          req.GetLanguage(),
		PayerName:         req.GetPayerName(),
		PayerAccount:      req.GetPayerAccount(),
		PayerEmail:        req.GetPayerEmail(),
	})
	if err != nil {
		return nil, xerr.ToGRPCError(err)
	}
	return &walletv1.H5RechargeOrderResponse{Order: externalRechargeOrderToProto(order)}, nil
}

// SubmitH5RechargeTx 接收 USDT tx_hash；链上校验和幂等入账仍在 wallet-service 事务里完成。
func (s *Server) SubmitH5RechargeTx(ctx context.Context, req *walletv1.SubmitH5RechargeTxRequest) (*walletv1.H5RechargeOrderResponse, error) {
	ctx = appcode.WithContext(ctx, req.GetAppCode())
	order, err := s.svc.SubmitH5RechargeTx(ctx, ledger.SubmitExternalRechargeTxCommand{
		AppCode:      req.GetAppCode(),
		OrderID:      req.GetOrderId(),
		TargetUserID: req.GetTargetUserId(),
		TxHash:       req.GetTxHash(),
	})
	if err != nil {
		return nil, xerr.ToGRPCError(err)
	}
	return &walletv1.H5RechargeOrderResponse{Order: externalRechargeOrderToProto(order)}, nil
}

// GetH5RechargeOrder 给 H5 轮询订单状态；target_user_id 用于避免无 token 场景越权看单。
func (s *Server) GetH5RechargeOrder(ctx context.Context, req *walletv1.GetH5RechargeOrderRequest) (*walletv1.H5RechargeOrderResponse, error) {
	ctx = appcode.WithContext(ctx, req.GetAppCode())
	order, err := s.svc.GetH5RechargeOrder(ctx, req.GetAppCode(), req.GetOrderId(), req.GetTargetUserId())
	if err != nil {
		return nil, xerr.ToGRPCError(err)
	}
	return &walletv1.H5RechargeOrderResponse{Order: externalRechargeOrderToProto(order)}, nil
}

// HandleMifapayNotify 验签并处理 MiFaPay 回调；成功或重复成功由 HTTP 层按 response_text 返回大写 SUCCESS。
func (s *Server) HandleMifapayNotify(ctx context.Context, req *walletv1.HandleMifapayNotifyRequest) (*walletv1.HandleMifapayNotifyResponse, error) {
	ctx = appcode.WithContext(ctx, req.GetAppCode())
	order, accepted, err := s.svc.HandleMifapayNotify(ctx, req.GetAppCode(), ledger.MifaPayNotification{
		MerAccount: req.GetMerAccount(),
		Data:       req.GetData(),
		Sign:       req.GetSign(),
	})
	if err != nil {
		return nil, xerr.ToGRPCError(err)
	}
	responseText := "FAIL"
	if accepted {
		responseText = "SUCCESS"
	}
	return &walletv1.HandleMifapayNotifyResponse{Accepted: accepted, ResponseText: responseText, OrderId: order.OrderID}, nil
}

// GetDiamondExchangeConfig 返回钻石兑换配置。
func (s *Server) GetDiamondExchangeConfig(ctx context.Context, req *walletv1.GetDiamondExchangeConfigRequest) (*walletv1.GetDiamondExchangeConfigResponse, error) {
	ctx = appcode.WithContext(ctx, req.GetAppCode())
	rules, err := s.svc.GetDiamondExchangeConfig(ctx, req.GetUserId())
	if err != nil {
		return nil, xerr.ToGRPCError(err)
	}
	resp := &walletv1.GetDiamondExchangeConfigResponse{Rules: make([]*walletv1.DiamondExchangeRule, 0, len(rules))}
	for _, rule := range rules {
		resp.Rules = append(resp.Rules, &walletv1.DiamondExchangeRule{
			ExchangeType:  rule.ExchangeType,
			FromAssetType: rule.FromAssetType,
			ToAssetType:   rule.ToAssetType,
			FromAmount:    rule.FromAmount,
			ToAmount:      rule.ToAmount,
			Enabled:       rule.Enabled,
		})
	}
	return resp, nil
}

func rechargeProductToProto(product ledger.RechargeProduct) *walletv1.RechargeProduct {
	return &walletv1.RechargeProduct{
		AppCode:           product.AppCode,
		AudienceType:      product.AudienceType,
		ProductId:         product.ProductID,
		ProductCode:       product.ProductCode,
		ProductName:       product.ProductName,
		Description:       product.Description,
		Platform:          product.Platform,
		Channel:           product.Channel,
		CurrencyCode:      product.CurrencyCode,
		AmountMicro:       product.AmountMicro,
		AmountMinor:       product.AmountMinor,
		CoinAmount:        product.CoinAmount,
		PolicyVersion:     product.PolicyVersion,
		Status:            product.Status,
		Enabled:           product.Enabled,
		SortOrder:         product.SortOrder,
		RegionIds:         product.RegionIDs,
		ResourceAssetType: product.ResourceAssetType,
		CreatedByUserId:   product.CreatedByUserID,
		UpdatedByUserId:   product.UpdatedByUserID,
		CreatedAtMs:       product.CreatedAtMS,
		UpdatedAtMs:       product.UpdatedAtMS,
	}
}

func thirdPartyPaymentChannelToProto(channel ledger.ThirdPartyPaymentChannel) *walletv1.ThirdPartyPaymentChannel {
	resp := &walletv1.ThirdPartyPaymentChannel{
		AppCode:      channel.AppCode,
		ProviderCode: channel.ProviderCode,
		ProviderName: channel.ProviderName,
		Status:       channel.Status,
		SortOrder:    channel.SortOrder,
		Methods:      make([]*walletv1.ThirdPartyPaymentMethod, 0, len(channel.Methods)),
	}
	for _, method := range channel.Methods {
		resp.Methods = append(resp.Methods, thirdPartyPaymentMethodToProto(method))
	}
	return resp
}

func thirdPartyPaymentMethodToProto(method ledger.ThirdPartyPaymentMethod) *walletv1.ThirdPartyPaymentMethod {
	return &walletv1.ThirdPartyPaymentMethod{
		MethodId:          method.MethodID,
		AppCode:           method.AppCode,
		ProviderCode:      method.ProviderCode,
		ProviderName:      method.ProviderName,
		CountryCode:       method.CountryCode,
		CountryName:       method.CountryName,
		CurrencyCode:      method.CurrencyCode,
		PayWay:            method.PayWay,
		PayType:           method.PayType,
		MethodName:        method.MethodName,
		LogoUrl:           method.LogoURL,
		Status:            method.Status,
		UsdToCurrencyRate: method.USDToCurrencyRate,
		SortOrder:         method.SortOrder,
		CreatedAtMs:       method.CreatedAtMS,
		UpdatedAtMs:       method.UpdatedAtMS,
	}
}

func externalRechargeOrderToProto(order ledger.ExternalRechargeOrder) *walletv1.ExternalRechargeOrder {
	return &walletv1.ExternalRechargeOrder{
		OrderId:             order.OrderID,
		AppCode:             order.AppCode,
		TargetUserId:        order.TargetUserID,
		TargetRegionId:      order.TargetRegionID,
		TargetCountryCode:   order.TargetCountryCode,
		AudienceType:        order.AudienceType,
		ProductId:           order.ProductID,
		ProductName:         order.ProductName,
		CoinAmount:          order.CoinAmount,
		UsdMinorAmount:      order.USDMinorAmount,
		ProviderCode:        order.ProviderCode,
		PaymentMethodId:     order.PaymentMethodID,
		CountryCode:         order.CountryCode,
		CurrencyCode:        order.CurrencyCode,
		ProviderAmountMinor: order.ProviderAmountMinor,
		PayWay:              order.PayWay,
		PayType:             order.PayType,
		PayUrl:              order.PayURL,
		ProviderOrderId:     order.ProviderOrderID,
		TxHash:              order.TxHash,
		ReceiveAddress:      order.ReceiveAddress,
		Status:              order.Status,
		FailureReason:       order.FailureReason,
		TransactionId:       order.TransactionID,
		CreatedAtMs:         order.CreatedAtMS,
		UpdatedAtMs:         order.UpdatedAtMS,
		IdempotentReplay:    order.IdempotentReplay,
	}
}

// ListWalletTransactions 返回当前用户钱包流水。
func (s *Server) ListWalletTransactions(ctx context.Context, req *walletv1.ListWalletTransactionsRequest) (*walletv1.ListWalletTransactionsResponse, error) {
	ctx = appcode.WithContext(ctx, req.GetAppCode())
	items, total, err := s.svc.ListWalletTransactions(ctx, ledger.ListWalletTransactionsQuery{
		AppCode:   req.GetAppCode(),
		UserID:    req.GetUserId(),
		AssetType: req.GetAssetType(),
		Page:      req.GetPage(),
		PageSize:  req.GetPageSize(),
	})
	if err != nil {
		return nil, xerr.ToGRPCError(err)
	}
	resp := &walletv1.ListWalletTransactionsResponse{Transactions: make([]*walletv1.WalletTransaction, 0, len(items)), Total: total}
	for _, item := range items {
		resp.Transactions = append(resp.Transactions, &walletv1.WalletTransaction{
			EntryId:            item.EntryID,
			TransactionId:      item.TransactionID,
			BizType:            item.BizType,
			AssetType:          item.AssetType,
			AvailableDelta:     item.AvailableDelta,
			FrozenDelta:        item.FrozenDelta,
			AvailableAfter:     item.AvailableAfter,
			FrozenAfter:        item.FrozenAfter,
			CounterpartyUserId: item.CounterpartyUserID,
			RoomId:             item.RoomID,
			CreatedAtMs:        item.CreatedAtMS,
		})
	}
	return resp, nil
}

// ListVipPackages 返回当前 VIP 和可购买包列表。
func (s *Server) ListVipPackages(ctx context.Context, req *walletv1.ListVipPackagesRequest) (*walletv1.ListVipPackagesResponse, error) {
	ctx = appcode.WithContext(ctx, req.GetAppCode())
	current, levels, err := s.svc.ListVipPackages(ctx, req.GetUserId())
	if err != nil {
		return nil, xerr.ToGRPCError(err)
	}
	resp := &walletv1.ListVipPackagesResponse{CurrentVip: vipToProto(current), Packages: make([]*walletv1.VipLevel, 0, len(levels))}
	for _, level := range levels {
		resp.Packages = append(resp.Packages, vipLevelToProto(level))
	}
	return resp, nil
}

// GetMyVip 返回当前登录用户 VIP 状态。
func (s *Server) GetMyVip(ctx context.Context, req *walletv1.GetMyVipRequest) (*walletv1.GetMyVipResponse, error) {
	ctx = appcode.WithContext(ctx, req.GetAppCode())
	vip, err := s.svc.GetMyVip(ctx, req.GetUserId())
	if err != nil {
		return nil, xerr.ToGRPCError(err)
	}
	return &walletv1.GetMyVipResponse{Vip: vipToProto(vip)}, nil
}

// PurchaseVip 购买、续期或升级 VIP。
func (s *Server) PurchaseVip(ctx context.Context, req *walletv1.PurchaseVipRequest) (*walletv1.PurchaseVipResponse, error) {
	ctx = appcode.WithContext(ctx, req.GetAppCode())
	receipt, err := s.svc.PurchaseVip(ctx, ledger.PurchaseVipCommand{
		AppCode:   req.GetAppCode(),
		CommandID: req.GetCommandId(),
		UserID:    req.GetUserId(),
		Level:     req.GetLevel(),
	})
	if err != nil {
		return nil, xerr.ToGRPCError(err)
	}
	return &walletv1.PurchaseVipResponse{
		OrderId:          receipt.OrderID,
		TransactionId:    receipt.TransactionID,
		Vip:              vipToProto(receipt.Vip),
		CoinSpent:        receipt.CoinSpent,
		CoinBalanceAfter: receipt.CoinBalanceAfter,
		RewardItems:      vipRewardItemsToProto(receipt.RewardItems),
	}, nil
}

// DebitCPBreakupFee 扣除解除 CP/兄弟/姐妹关系费用；关系状态确认由 user-service 负责。
func (s *Server) DebitCPBreakupFee(ctx context.Context, req *walletv1.DebitCPBreakupFeeRequest) (*walletv1.DebitCPBreakupFeeResponse, error) {
	ctx = appcode.WithContext(ctx, req.GetAppCode())
	receipt, err := s.svc.DebitCPBreakupFee(ctx, ledger.CPBreakupFeeCommand{
		AppCode:        req.GetAppCode(),
		CommandID:      req.GetCommandId(),
		UserID:         req.GetUserId(),
		RelationshipID: req.GetRelationshipId(),
		RelationType:   req.GetRelationType(),
		Amount:         req.GetAmount(),
	})
	if err != nil {
		return nil, xerr.ToGRPCError(err)
	}
	return &walletv1.DebitCPBreakupFeeResponse{
		TransactionId:    receipt.TransactionID,
		CoinSpent:        receipt.CoinSpent,
		CoinBalanceAfter: receipt.CoinBalanceAfter,
		Balance:          balanceToProto(receipt.Balance),
	}, nil
}

// DebitWheelDraw 扣除转盘抽奖金币；中奖结果不在 wallet 内生成，避免钱包反向拥有活动规则。
func (s *Server) DebitWheelDraw(ctx context.Context, req *walletv1.DebitWheelDrawRequest) (*walletv1.DebitWheelDrawResponse, error) {
	ctx = appcode.WithContext(ctx, req.GetAppCode())
	receipt, err := s.svc.DebitWheelDraw(ctx, ledger.WheelDrawDebitCommand{
		AppCode:   req.GetAppCode(),
		CommandID: req.GetCommandId(),
		UserID:    req.GetUserId(),
		WheelID:   req.GetWheelId(),
		DrawCount: req.GetDrawCount(),
		Amount:    req.GetAmount(),
	})
	if err != nil {
		return nil, xerr.ToGRPCError(err)
	}
	return &walletv1.DebitWheelDrawResponse{
		TransactionId:    receipt.TransactionID,
		CoinSpent:        receipt.CoinSpent,
		CoinBalanceAfter: receipt.CoinBalanceAfter,
		Balance:          balanceToProto(receipt.Balance),
	}, nil
}

// GrantVip 统一处理活动和后台赠送 VIP。
func (s *Server) GrantVip(ctx context.Context, req *walletv1.GrantVipRequest) (*walletv1.GrantVipResponse, error) {
	ctx = appcode.WithContext(ctx, req.GetAppCode())
	receipt, err := s.svc.GrantVip(ctx, ledger.GrantVipCommand{
		AppCode:        req.GetAppCode(),
		CommandID:      req.GetCommandId(),
		TargetUserID:   req.GetTargetUserId(),
		Level:          req.GetLevel(),
		GrantSource:    req.GetGrantSource(),
		OperatorUserID: req.GetOperatorUserId(),
		Reason:         req.GetReason(),
	})
	if err != nil {
		return nil, xerr.ToGRPCError(err)
	}
	return &walletv1.GrantVipResponse{
		TransactionId: receipt.TransactionID,
		Vip:           vipToProto(receipt.Vip),
		RewardItems:   vipRewardItemsToProto(receipt.RewardItems),
		ServerTimeMs:  time.Now().UnixMilli(),
	}, nil
}

// ListAdminVipLevels 返回后台 VIP 配置。
func (s *Server) ListAdminVipLevels(ctx context.Context, req *walletv1.ListAdminVipLevelsRequest) (*walletv1.ListAdminVipLevelsResponse, error) {
	ctx = appcode.WithContext(ctx, req.GetAppCode())
	levels, err := s.svc.ListAdminVipLevels(ctx)
	if err != nil {
		return nil, xerr.ToGRPCError(err)
	}
	resp := &walletv1.ListAdminVipLevelsResponse{Levels: make([]*walletv1.VipLevel, 0, len(levels)), ServerTimeMs: time.Now().UnixMilli()}
	for _, level := range levels {
		resp.Levels = append(resp.Levels, vipLevelToProto(level))
	}
	return resp, nil
}

// UpdateAdminVipLevels 保存后台 VIP 配置。
func (s *Server) UpdateAdminVipLevels(ctx context.Context, req *walletv1.UpdateAdminVipLevelsRequest) (*walletv1.UpdateAdminVipLevelsResponse, error) {
	ctx = appcode.WithContext(ctx, req.GetAppCode())
	commands := make([]ledger.AdminVipLevelCommand, 0, len(req.GetLevels()))
	for _, item := range req.GetLevels() {
		if item == nil {
			continue
		}
		commands = append(commands, ledger.AdminVipLevelCommand{
			Level:                      item.GetLevel(),
			Name:                       item.GetName(),
			Status:                     item.GetStatus(),
			PriceCoin:                  item.GetPriceCoin(),
			DurationMS:                 item.GetDurationMs(),
			RewardResourceGroupID:      item.GetRewardResourceGroupId(),
			RequiredRechargeCoinAmount: item.GetRequiredRechargeCoinAmount(),
			SortOrder:                  item.GetSortOrder(),
		})
	}
	levels, err := s.svc.UpdateAdminVipLevels(ctx, commands, req.GetOperatorUserId())
	if err != nil {
		return nil, xerr.ToGRPCError(err)
	}
	resp := &walletv1.UpdateAdminVipLevelsResponse{Levels: make([]*walletv1.VipLevel, 0, len(levels)), ServerTimeMs: time.Now().UnixMilli()}
	for _, level := range levels {
		resp.Levels = append(resp.Levels, vipLevelToProto(level))
	}
	return resp, nil
}

// AdminCreditAsset 处理后台手动调账，公网权限和审计入口由 gateway/admin 层控制。
func (s *Server) AdminCreditAsset(ctx context.Context, req *walletv1.AdminCreditAssetRequest) (*walletv1.AdminCreditAssetResponse, error) {
	ctx = appcode.WithContext(ctx, req.GetAppCode())
	balance, transactionID, err := s.svc.AdminCreditAsset(ctx, ledger.AdminCreditAssetCommand{
		AppCode:        req.GetAppCode(),
		CommandID:      req.GetCommandId(),
		TargetUserID:   req.GetTargetUserId(),
		AssetType:      req.GetAssetType(),
		Amount:         req.GetAmount(),
		OperatorUserID: req.GetOperatorUserId(),
		Reason:         req.GetReason(),
		EvidenceRef:    req.GetEvidenceRef(),
	})
	if err != nil {
		return nil, xerr.ToGRPCError(err)
	}

	return &walletv1.AdminCreditAssetResponse{
		TransactionId: transactionID,
		Balance: &walletv1.AssetBalance{
			AppCode:         balance.AppCode,
			AssetType:       balance.AssetType,
			AvailableAmount: balance.AvailableAmount,
			FrozenAmount:    balance.FrozenAmount,
			Version:         balance.Version,
		},
	}, nil
}

func balancesToProto(balances []ledger.AssetBalance) []*walletv1.AssetBalance {
	items := make([]*walletv1.AssetBalance, 0, len(balances))
	for _, balance := range balances {
		items = append(items, balanceToProto(balance))
	}
	return items
}

func balanceToProto(balance ledger.AssetBalance) *walletv1.AssetBalance {
	return &walletv1.AssetBalance{
		AppCode:         balance.AppCode,
		AssetType:       balance.AssetType,
		AvailableAmount: balance.AvailableAmount,
		FrozenAmount:    balance.FrozenAmount,
		Version:         balance.Version,
	}
}

func giftWallItemToProto(item ledger.GiftWallItem) *walletv1.GiftWallItem {
	return &walletv1.GiftWallItem{
		GiftId:               item.GiftID,
		GiftName:             item.GiftName,
		ResourceId:           item.ResourceID,
		Resource:             giftWallResourceToProto(item.Resource),
		ResourceSnapshotJson: item.ResourceSnapshotJSON,
		GiftTypeCode:         item.GiftTypeCode,
		PresentationJson:     item.PresentationJSON,
		GiftCount:            item.GiftCount,
		TotalValue:           item.TotalValue,
		TotalCoinValue:       item.TotalCoinValue,
		TotalDiamondValue:    item.TotalDiamondValue,
		TotalGiftPoint:       item.TotalGiftPoint,
		TotalHeatValue:       item.TotalHeatValue,
		ChargeAssetType:      item.ChargeAssetType,
		LastPriceVersion:     item.LastPriceVersion,
		FirstReceivedAtMs:    item.FirstReceivedAtMS,
		LastReceivedAtMs:     item.LastReceivedAtMS,
		SortOrder:            item.SortOrder,
	}
}

func giftWallResourceToProto(resource ledger.GiftWallResource) *walletv1.Resource {
	if resource.ResourceID == 0 {
		return nil
	}
	return &walletv1.Resource{
		AppCode:           resource.AppCode,
		ResourceId:        resource.ResourceID,
		ResourceCode:      resource.ResourceCode,
		ResourceType:      resource.ResourceType,
		Name:              resource.Name,
		Status:            resource.Status,
		Grantable:         resource.Grantable,
		GrantStrategy:     resource.GrantStrategy,
		WalletAssetType:   resource.WalletAssetType,
		WalletAssetAmount: resource.WalletAssetAmount,
		UsageScopes:       resource.UsageScopes,
		AssetUrl:          resource.AssetURL,
		PreviewUrl:        resource.PreviewURL,
		AnimationUrl:      resource.AnimationURL,
		MetadataJson:      resource.MetadataJSON,
		SortOrder:         resource.SortOrder,
		CreatedAtMs:       resource.CreatedAtMS,
		UpdatedAtMs:       resource.UpdatedAtMS,
	}
}

func walletFeatureFlagsToProto(flags ledger.WalletFeatureFlags) *walletv1.WalletFeatureFlags {
	return &walletv1.WalletFeatureFlags{
		RechargeEnabled:        flags.RechargeEnabled,
		DiamondExchangeEnabled: flags.DiamondExchangeEnabled,
	}
}

func vipToProto(vip ledger.UserVip) *walletv1.UserVip {
	return &walletv1.UserVip{
		UserId:      vip.UserID,
		Level:       vip.Level,
		Name:        vip.Name,
		Active:      vip.Active,
		StartedAtMs: vip.StartedAtMS,
		ExpiresAtMs: vip.ExpiresAtMS,
		UpdatedAtMs: vip.UpdatedAtMS,
	}
}

func vipLevelToProto(level ledger.VipLevel) *walletv1.VipLevel {
	return &walletv1.VipLevel{
		Level:                      level.Level,
		Name:                       level.Name,
		Status:                     level.Status,
		PriceCoin:                  level.PriceCoin,
		DurationMs:                 level.DurationMS,
		RewardResourceGroupId:      level.RewardResourceGroupID,
		RewardItems:                vipRewardItemsToProto(level.RewardItems),
		CanPurchase:                level.CanPurchase,
		SortOrder:                  level.SortOrder,
		RechargeGateRequired:       level.RechargeGateRequired,
		RequiredRechargeCoinAmount: level.RequiredRechargeCoinAmount,
		UserRechargeCoinAmount:     level.UserRechargeCoinAmount,
		PurchaseLockedReason:       level.PurchaseLockedReason,
		CreatedAtMs:                level.CreatedAtMS,
		UpdatedAtMs:                level.UpdatedAtMS,
	}
}

func vipRewardItemsToProto(items []ledger.VipRewardItem) []*walletv1.VipRewardItem {
	resp := make([]*walletv1.VipRewardItem, 0, len(items))
	for _, item := range items {
		resp = append(resp, &walletv1.VipRewardItem{
			ResourceId:   item.ResourceID,
			ResourceCode: item.ResourceCode,
			ResourceType: item.ResourceType,
			Name:         item.Name,
			Quantity:     item.Quantity,
			ExpiresAtMs:  item.ExpiresAtMS,
			AssetUrl:     item.AssetURL,
			PreviewUrl:   item.PreviewURL,
			AnimationUrl: item.AnimationURL,
		})
	}
	return resp
}

// CreditTaskReward 处理 activity-service 任务奖励金币入账。
func (s *Server) CreditTaskReward(ctx context.Context, req *walletv1.CreditTaskRewardRequest) (*walletv1.CreditTaskRewardResponse, error) {
	ctx = appcode.WithContext(ctx, req.GetAppCode())
	receipt, err := s.svc.CreditTaskReward(ctx, ledger.TaskRewardCommand{
		AppCode:      req.GetAppCode(),
		CommandID:    req.GetCommandId(),
		TargetUserID: req.GetTargetUserId(),
		Amount:       req.GetAmount(),
		TaskType:     req.GetTaskType(),
		TaskID:       req.GetTaskId(),
		CycleKey:     req.GetCycleKey(),
		Reason:       req.GetReason(),
	})
	if err != nil {
		return nil, xerr.ToGRPCError(err)
	}

	return &walletv1.CreditTaskRewardResponse{
		TransactionId: receipt.TransactionID,
		Amount:        receipt.Amount,
		GrantedAtMs:   receipt.GrantedAtMS,
		Balance: &walletv1.AssetBalance{
			AppCode:         receipt.Balance.AppCode,
			AssetType:       receipt.Balance.AssetType,
			AvailableAmount: receipt.Balance.AvailableAmount,
			FrozenAmount:    receipt.Balance.FrozenAmount,
			Version:         receipt.Balance.Version,
		},
	}, nil
}

// CreditLuckyGiftReward 处理 activity-service 幸运礼物抽奖 outbox 的中奖金币入账。
func (s *Server) CreditLuckyGiftReward(ctx context.Context, req *walletv1.CreditLuckyGiftRewardRequest) (*walletv1.CreditLuckyGiftRewardResponse, error) {
	ctx = appcode.WithContext(ctx, req.GetAppCode())
	receipt, err := s.svc.CreditLuckyGiftReward(ctx, ledger.LuckyGiftRewardCommand{
		AppCode:         req.GetAppCode(),
		CommandID:       req.GetCommandId(),
		TargetUserID:    req.GetTargetUserId(),
		Amount:          req.GetAmount(),
		DrawID:          req.GetDrawId(),
		RoomID:          req.GetRoomId(),
		VisibleRegionID: req.GetVisibleRegionId(),
		GiftID:          req.GetGiftId(),
		PoolID:          req.GetPoolId(),
		Reason:          req.GetReason(),
	})
	if err != nil {
		return nil, xerr.ToGRPCError(err)
	}

	return &walletv1.CreditLuckyGiftRewardResponse{
		TransactionId: receipt.TransactionID,
		Amount:        receipt.Amount,
		GrantedAtMs:   receipt.GrantedAtMS,
		Balance: &walletv1.AssetBalance{
			AppCode:         receipt.Balance.AppCode,
			AssetType:       receipt.Balance.AssetType,
			AvailableAmount: receipt.Balance.AvailableAmount,
			FrozenAmount:    receipt.Balance.FrozenAmount,
			Version:         receipt.Balance.Version,
		},
	}, nil
}

// CreditWheelReward 处理 activity-service 转盘金币奖品 outbox 的入账。
func (s *Server) CreditWheelReward(ctx context.Context, req *walletv1.CreditWheelRewardRequest) (*walletv1.CreditWheelRewardResponse, error) {
	ctx = appcode.WithContext(ctx, req.GetAppCode())
	receipt, err := s.svc.CreditWheelReward(ctx, ledger.WheelRewardCommand{
		AppCode:         req.GetAppCode(),
		CommandID:       req.GetCommandId(),
		TargetUserID:    req.GetTargetUserId(),
		Amount:          req.GetAmount(),
		DrawID:          req.GetDrawId(),
		WheelID:         req.GetWheelId(),
		SelectedTierID:  req.GetSelectedTierId(),
		VisibleRegionID: req.GetVisibleRegionId(),
		Reason:          req.GetReason(),
	})
	if err != nil {
		return nil, xerr.ToGRPCError(err)
	}

	return &walletv1.CreditWheelRewardResponse{
		TransactionId: receipt.TransactionID,
		Amount:        receipt.Amount,
		GrantedAtMs:   receipt.GrantedAtMS,
		Balance: &walletv1.AssetBalance{
			AppCode:         receipt.Balance.AppCode,
			AssetType:       receipt.Balance.AssetType,
			AvailableAmount: receipt.Balance.AvailableAmount,
			FrozenAmount:    receipt.Balance.FrozenAmount,
			Version:         receipt.Balance.Version,
		},
	}, nil
}

// CreditRoomTurnoverReward 处理 activity-service 每周房间流水奖励金币入账。
func (s *Server) CreditRoomTurnoverReward(ctx context.Context, req *walletv1.CreditRoomTurnoverRewardRequest) (*walletv1.CreditRoomTurnoverRewardResponse, error) {
	// gRPC 层不解释活动规则，只把 activity-service 的结算命令转换为钱包领域命令。
	ctx = appcode.WithContext(ctx, req.GetAppCode())
	receipt, err := s.svc.CreditRoomTurnoverReward(ctx, ledger.RoomTurnoverRewardCommand{
		AppCode:       req.GetAppCode(),
		CommandID:     req.GetCommandId(),
		TargetUserID:  req.GetTargetUserId(),
		Amount:        req.GetAmount(),
		SettlementID:  req.GetSettlementId(),
		RoomID:        req.GetRoomId(),
		PeriodStartMS: req.GetPeriodStartMs(),
		PeriodEndMS:   req.GetPeriodEndMs(),
		CoinSpent:     req.GetCoinSpent(),
		TierID:        req.GetTierId(),
		TierCode:      req.GetTierCode(),
		Reason:        req.GetReason(),
	})
	if err != nil {
		return nil, xerr.ToGRPCError(err)
	}

	return &walletv1.CreditRoomTurnoverRewardResponse{
		TransactionId: receipt.TransactionID,
		Amount:        receipt.Amount,
		GrantedAtMs:   receipt.GrantedAtMS,
		Balance: &walletv1.AssetBalance{
			AppCode:         receipt.Balance.AppCode,
			AssetType:       receipt.Balance.AssetType,
			AvailableAmount: receipt.Balance.AvailableAmount,
			FrozenAmount:    receipt.Balance.FrozenAmount,
			Version:         receipt.Balance.Version,
		},
	}, nil
}

// CreditInviteActivityReward 处理 activity-service 邀请活动奖励金币入账。
func (s *Server) CreditInviteActivityReward(ctx context.Context, req *walletv1.CreditInviteActivityRewardRequest) (*walletv1.CreditInviteActivityRewardResponse, error) {
	ctx = appcode.WithContext(ctx, req.GetAppCode())
	receipt, err := s.svc.CreditInviteActivityReward(ctx, ledger.InviteActivityRewardCommand{
		AppCode:      req.GetAppCode(),
		CommandID:    req.GetCommandId(),
		TargetUserID: req.GetTargetUserId(),
		Amount:       req.GetAmount(),
		ClaimID:      req.GetClaimId(),
		RewardType:   req.GetRewardType(),
		TierID:       req.GetTierId(),
		TierCode:     req.GetTierCode(),
		CycleKey:     req.GetCycleKey(),
		ReachedValue: req.GetReachedValue(),
		Reason:       req.GetReason(),
	})
	if err != nil {
		return nil, xerr.ToGRPCError(err)
	}

	return &walletv1.CreditInviteActivityRewardResponse{
		TransactionId: receipt.TransactionID,
		Amount:        receipt.Amount,
		GrantedAtMs:   receipt.GrantedAtMS,
		Balance: &walletv1.AssetBalance{
			AppCode:         receipt.Balance.AppCode,
			AssetType:       receipt.Balance.AssetType,
			AvailableAmount: receipt.Balance.AvailableAmount,
			FrozenAmount:    receipt.Balance.FrozenAmount,
			Version:         receipt.Balance.Version,
		},
	}, nil
}

// CreditAgencyOpeningReward 处理 activity-service 代理开业流水档位奖励金币入账。
func (s *Server) CreditAgencyOpeningReward(ctx context.Context, req *walletv1.CreditAgencyOpeningRewardRequest) (*walletv1.CreditAgencyOpeningRewardResponse, error) {
	ctx = appcode.WithContext(ctx, req.GetAppCode())
	receipt, err := s.svc.CreditAgencyOpeningReward(ctx, ledger.AgencyOpeningRewardCommand{
		AppCode:       req.GetAppCode(),
		CommandID:     req.GetCommandId(),
		TargetUserID:  req.GetTargetUserId(),
		Amount:        req.GetAmount(),
		ApplicationID: req.GetApplicationId(),
		CycleID:       req.GetCycleId(),
		AgencyID:      req.GetAgencyId(),
		RankNo:        req.GetRankNo(),
		ScoreCoins:    req.GetScoreCoins(),
		Reason:        req.GetReason(),
	})
	if err != nil {
		return nil, xerr.ToGRPCError(err)
	}

	return &walletv1.CreditAgencyOpeningRewardResponse{
		TransactionId: receipt.TransactionID,
		Amount:        receipt.Amount,
		GrantedAtMs:   receipt.GrantedAtMS,
		Balance: &walletv1.AssetBalance{
			AppCode:         receipt.Balance.AppCode,
			AssetType:       receipt.Balance.AssetType,
			AvailableAmount: receipt.Balance.AvailableAmount,
			FrozenAmount:    receipt.Balance.FrozenAmount,
			Version:         receipt.Balance.Version,
		},
	}, nil
}

// ApplyGameCoinChange 处理 game-service 发起的游戏专用金币改账。
func (s *Server) ApplyGameCoinChange(ctx context.Context, req *walletv1.ApplyGameCoinChangeRequest) (*walletv1.ApplyGameCoinChangeResponse, error) {
	ctx = appcode.WithContext(ctx, req.GetAppCode())
	receipt, err := s.svc.ApplyGameCoinChange(ctx, ledger.GameCoinChangeCommand{
		AppCode:         req.GetAppCode(),
		CommandID:       req.GetCommandId(),
		UserID:          req.GetUserId(),
		PlatformCode:    req.GetPlatformCode(),
		GameID:          req.GetGameId(),
		ProviderOrderID: req.GetProviderOrderId(),
		ProviderRoundID: req.GetProviderRoundId(),
		OpType:          req.GetOpType(),
		CoinAmount:      req.GetCoinAmount(),
		RoomID:          req.GetRoomId(),
		RequestHash:     req.GetRequestHash(),
	})
	if err != nil {
		return nil, xerr.ToGRPCError(err)
	}
	return &walletv1.ApplyGameCoinChangeResponse{
		WalletTransactionId: receipt.TransactionID,
		BalanceAfter:        receipt.BalanceAfter,
		IdempotentReplay:    receipt.IdempotentReplay,
	}, nil
}

// AdminCreditCoinSellerStock 处理后台币商进货或金币补偿，币商身份由 admin-server 先行校验。
func (s *Server) AdminCreditCoinSellerStock(ctx context.Context, req *walletv1.AdminCreditCoinSellerStockRequest) (*walletv1.AdminCreditCoinSellerStockResponse, error) {
	ctx = appcode.WithContext(ctx, req.GetAppCode())
	receipt, err := s.svc.AdminCreditCoinSellerStock(ctx, ledger.CoinSellerStockCreditCommand{
		AppCode:          req.GetAppCode(),
		CommandID:        req.GetCommandId(),
		SellerUserID:     req.GetSellerUserId(),
		SellerCountryID:  req.GetSellerCountryId(),
		SellerRegionID:   req.GetSellerRegionId(),
		StockType:        req.GetStockType(),
		CoinAmount:       req.GetCoinAmount(),
		PaidCurrencyCode: req.GetPaidCurrencyCode(),
		PaidAmountMicro:  req.GetPaidAmountMicro(),
		PaymentRef:       req.GetPaymentRef(),
		EvidenceRef:      req.GetEvidenceRef(),
		OperatorUserID:   req.GetOperatorUserId(),
		Reason:           req.GetReason(),
	})
	if err != nil {
		return nil, xerr.ToGRPCError(err)
	}

	return &walletv1.AdminCreditCoinSellerStockResponse{
		TransactionId:          receipt.TransactionID,
		SellerUserId:           receipt.SellerUserID,
		StockType:              receipt.StockType,
		CoinAmount:             receipt.CoinAmount,
		PaidCurrencyCode:       receipt.PaidCurrencyCode,
		PaidAmountMicro:        receipt.PaidAmountMicro,
		CountsAsSellerRecharge: receipt.CountsAsSellerRecharge,
		BalanceAfter:           receipt.BalanceAfter,
		CreatedAtMs:            receipt.CreatedAtMS,
	}, nil
}

// TransferCoinFromSeller 处理币商转玩家金币，调用方必须先完成币商身份校验。
func (s *Server) TransferCoinFromSeller(ctx context.Context, req *walletv1.TransferCoinFromSellerRequest) (*walletv1.TransferCoinFromSellerResponse, error) {
	ctx = appcode.WithContext(ctx, req.GetAppCode())
	receipt, err := s.svc.TransferCoinFromSeller(ctx, ledger.CoinSellerTransferCommand{
		AppCode:         req.GetAppCode(),
		CommandID:       req.GetCommandId(),
		SellerUserID:    req.GetSellerUserId(),
		TargetUserID:    req.GetTargetUserId(),
		TargetCountryID: req.GetTargetCountryId(),
		SellerRegionID:  req.GetSellerRegionId(),
		TargetRegionID:  req.GetTargetRegionId(),
		Amount:          req.GetAmount(),
		Reason:          req.GetReason(),
	})
	if err != nil {
		return nil, xerr.ToGRPCError(err)
	}

	return &walletv1.TransferCoinFromSellerResponse{
		TransactionId:                receipt.TransactionID,
		SellerBalanceAfter:           receipt.SellerBalanceAfter,
		TargetBalanceAfter:           receipt.TargetBalanceAfter,
		Amount:                       receipt.Amount,
		RechargeUsdMinor:             receipt.RechargeUSDMinor,
		RechargeCurrencyCode:         receipt.RechargeCurrencyCode,
		RechargePolicyId:             receipt.RechargePolicyID,
		RechargePolicyVersion:        receipt.RechargePolicyVersion,
		RechargePolicyCoinAmount:     receipt.RechargePolicyCoinAmount,
		RechargePolicyUsdMinorAmount: receipt.RechargePolicyUSDMinorUnit,
	}, nil
}

// ListCoinSellerSalaryExchangeRateTiers 返回工资转币商使用的区域比例区间，调用方用它做预计到账展示。
func (s *Server) ListCoinSellerSalaryExchangeRateTiers(ctx context.Context, req *walletv1.ListCoinSellerSalaryExchangeRateTiersRequest) (*walletv1.ListCoinSellerSalaryExchangeRateTiersResponse, error) {
	ctx = appcode.WithContext(ctx, req.GetAppCode())
	tiers, err := s.svc.ListCoinSellerSalaryExchangeRateTiers(ctx, req.GetAppCode(), req.GetRegionId(), req.GetIncludeDisabled())
	if err != nil {
		return nil, xerr.ToGRPCError(err)
	}
	response := &walletv1.ListCoinSellerSalaryExchangeRateTiersResponse{Tiers: make([]*walletv1.CoinSellerSalaryExchangeRateTier, 0, len(tiers))}
	for _, tier := range tiers {
		response.Tiers = append(response.Tiers, &walletv1.CoinSellerSalaryExchangeRateTier{
			RegionId:    tier.RegionID,
			MinUsdMinor: tier.MinUSDMinor,
			MaxUsdMinor: tier.MaxUSDMinor,
			CoinPerUsd:  tier.CoinPerUSD,
			Status:      tier.Status,
			SortOrder:   int32(tier.SortOrder),
			UpdatedAtMs: tier.UpdatedAtMS,
		})
	}
	return response, nil
}

// ExchangeSalaryToCoin 处理用户工资兑换普通金币，身份资产已经由 gateway 校验并注入。
func (s *Server) ExchangeSalaryToCoin(ctx context.Context, req *walletv1.ExchangeSalaryToCoinRequest) (*walletv1.ExchangeSalaryToCoinResponse, error) {
	ctx = appcode.WithContext(ctx, req.GetAppCode())
	receipt, err := s.svc.ExchangeSalaryToCoin(ctx, ledger.SalaryExchangeCommand{
		AppCode:         req.GetAppCode(),
		CommandID:       req.GetCommandId(),
		UserID:          req.GetUserId(),
		SalaryAssetType: req.GetSalaryAssetType(),
		SalaryUSDMinor:  req.GetSalaryUsdMinor(),
		Reason:          req.GetReason(),
	})
	if err != nil {
		return nil, xerr.ToGRPCError(err)
	}
	return &walletv1.ExchangeSalaryToCoinResponse{
		TransactionId:      receipt.TransactionID,
		SalaryBalanceAfter: receipt.SalaryBalanceAfter,
		CoinBalanceAfter:   receipt.CoinBalanceAfter,
		SalaryUsdMinor:     receipt.SalaryUSDMinor,
		CoinAmount:         receipt.CoinAmount,
		CoinPerUsd:         receipt.CoinPerUSD,
	}, nil
}

// TransferSalaryToCoinSeller 处理用户工资转同区域币商专用金币库存。
func (s *Server) TransferSalaryToCoinSeller(ctx context.Context, req *walletv1.TransferSalaryToCoinSellerRequest) (*walletv1.TransferSalaryToCoinSellerResponse, error) {
	ctx = appcode.WithContext(ctx, req.GetAppCode())
	receipt, err := s.svc.TransferSalaryToCoinSeller(ctx, ledger.SalaryTransferToCoinSellerCommand{
		AppCode:         req.GetAppCode(),
		CommandID:       req.GetCommandId(),
		SourceUserID:    req.GetSourceUserId(),
		SellerUserID:    req.GetSellerUserId(),
		SalaryAssetType: req.GetSalaryAssetType(),
		SalaryUSDMinor:  req.GetSalaryUsdMinor(),
		RegionID:        req.GetRegionId(),
		Reason:          req.GetReason(),
	})
	if err != nil {
		return nil, xerr.ToGRPCError(err)
	}
	return &walletv1.TransferSalaryToCoinSellerResponse{
		TransactionId:            receipt.TransactionID,
		SourceSalaryBalanceAfter: receipt.SourceSalaryBalanceAfter,
		SellerBalanceAfter:       receipt.SellerBalanceAfter,
		SalaryUsdMinor:           receipt.SalaryUSDMinor,
		CoinAmount:               receipt.CoinAmount,
		CoinPerUsd:               receipt.CoinPerUSD,
		RateMinUsdMinor:          receipt.RateMinUSDMinor,
		RateMaxUsdMinor:          receipt.RateMaxUSDMinor,
	}, nil
}