package player

import (
	actorRemote "f1-game/internal/actor_remote"
	cherryApp "f1-game/internal/cherry_app"
	"f1-game/internal/code"
	"f1-game/internal/component/sdk"
	sdkFacade "f1-game/internal/component/sdk/define/facade"
	sdkKey "f1-game/internal/component/sdk/define/key"
	"f1-game/internal/constant"
	"f1-game/internal/data"
	"f1-game/internal/enum"
	nameLocal "f1-game/internal/name/local"
	nameRemote "f1-game/internal/name/remote"
	"f1-game/internal/pb"
	"f1-game/internal/sessions"
	"f1-game/nodes/game/internal/db"
	gameFacade "f1-game/nodes/game/internal/facade"
	ao "f1-game/nodes/game/player/asset/origin"
	"f1-game/nodes/game/player/charge"

	cstring "github.com/cherry-game/cherry/extend/string"
	ctime "github.com/cherry-game/cherry/extend/time"
	cproto "github.com/cherry-game/cherry/net/proto"
)

func (p *actorPlayer) initCharge() {
	p.Local().Register(nameLocal.Player_ChargeCreate, p.chargeCreate)
	p.Local().Register(nameLocal.Player_ChargeCardReward, p.chargeCardReward)

	p.Remote().Register(nameRemote.Player_ChargeDeliver, p.chargeDeliver)
}

// chargeCreate 充值项订单创建
func (p *actorPlayer) chargeCreate(session *cproto.Session, req *pb.ChargeCreate) {
	chargeRow, found := data.Charge.GetByID(req.ChargeID)
	if !found || chargeRow.Amount < 1 {
		p.ResponseCode(session, code.PayChargeIDError)
		return
	}

	pid := sessions.GetPID(session)
	sdkRow := data.SDK.Get(pid)
	if sdkRow == nil {
		p.ResponseCode(session, code.PIDError)
		return
	}

	sdkInvoke, err := sdk.GetInvoke(sdkRow.SdkID)
	if err != nil {
		p.ResponseCode(session, code.PIDError)
		return
	}

	// 根据chargeID,检查充值项
	errCode := charge.Service().OnCheck(p.playerID, req.ChargeID, chargeRow.ChargeType, req.ChargeParams)
	if code.IsFail(errCode) {
		p.ResponseCode(session, errCode)
		return
	}

	// 通过order actor 创建订单,返回订单id
	orderID, errCode := p.createPayOrder(session, req, chargeRow)
	if code.IsFail(errCode) {
		p.ResponseCode(session, errCode)
		return
	}

	// 构建订单签名
	input := sdkFacade.ParamsMap{}
	input.Put(sdkKey.GameNodeID, cherryApp.NodeID())
	input.Put(sdkKey.PID, sessions.GetPID(session))
	input.Put(sdkKey.OpenID, sessions.GetOpenID(session))
	input.Put(sdkKey.UID, session.Uid)
	input.Put(sdkKey.PlayerID, sessions.GetPlayerID(session))
	input.Put(sdkKey.OrderID, orderID)

	params, errCode := sdkInvoke.OrderSign(sdkRow, chargeRow, input)
	if code.IsFail(errCode) {
		p.ResponseCode(session, errCode)
		return
	}

	rsp := &pb.ChargeCreateResponse{
		ChargeID: req.ChargeID,
		OrderID:  orderID,
		Params:   params,
	}

	p.Response(session, rsp)
}

func (p *actorPlayer) createPayOrder(session *cproto.Session, req *pb.ChargeCreate, chargeRow *data.ChargeRow) (int64, int32) {
	playerTable := p.PlayerTable()
	createOrder := &pb.CreateOrder{
		PID:        playerTable.PID,
		UID:        playerTable.UID,
		GameNodeID: playerTable.NodeID,
		PlayerID:   playerTable.PlayerID,
		ChargeID:   chargeRow.ID,
		Amount:     chargeRow.Amount,
		ClientOS:   0, // 需要在玩家登录的时候带入到session里，然后直接读取
		Ip:         session.Ip,
		Extra: map[string]string{
			constant.ChargeKeyType:       cstring.ToString(chargeRow.ChargeType),
			constant.ChargeKeyParams:     cstring.ToString(req.ChargeParams),
			constant.ChargeKeyGameNodeID: cstring.ToString(playerTable.NodeID),
		},
	}

	// 调用order actor 创建订单ID信息，下发给客户端
	return actorRemote.GameOrder.Create(createOrder)
}

// 每日周月卡奖励领取
func (p *actorPlayer) chargeCardReward(session *cproto.Session, req *pb.I32) {
	cardID := req.Value
	if cardID < 1 {
		p.ResponseCode(session, code.IllegalArgument)
		return
	}

	row, ok := data.ShopCard.GetByID(cardID)
	if !ok {
		p.ResponseCode(session, code.ConfigNotFound_ShopCard)
		return
	}

	chargeTable := db.GetChargeTable(p.playerID)

	card, ok := chargeTable.Cards.Get(cardID)
	if !ok {
		p.ResponseCode(session, code.IllegalArgument)
		return
	}

	if card.ExpireTime < ctime.Now().ToMillisecond() {
		p.ResponseCode(session, code.VipCardExpired)
		return
	}

	if card.IsReceive {
		p.ResponseCode(session, code.VipCardAlreadyReceived)
		return
	}

	// 先保存，再发放奖励
	card.IsReceive = true
	chargeTable.Save2Queue()

	gameFacade.Asset.Adds(p.playerID, row.DayRewards, ao.None, true)

	p.ResponseCode(session, code.OK)

	p.Debug("[chargeCardReward] receive success. playerID = %d, cardID = %d", p.playerID, cardID)
}

// chargeDeliver 充值项订单发货 {server-id}.player.orderDeliver
func (p *actorPlayer) chargeDeliver(req *pb.OrderDeliver) int32 {
	chargeRow, found := data.Charge.GetByID(req.ChargeID)
	if !found {
		return code.PayChargeIDError
	}

	if req.Extra == nil {
		return code.PayChargeParamsError
	}

	chargeType, ok := req.GetExtraI32(constant.ChargeKeyType)
	if !ok || chargeRow.ChargeType != chargeType {
		return code.PayChargeTypeError
	}

	chargeParams, ok := req.GetExtraI32(constant.ChargeKeyParams)
	if !ok {
		return code.PayChargeParamsError
	}

	errCode := charge.Service().OnDeliver(p.playerID, req.ChargeID, chargeType, chargeParams)
	if code.IsFail(errCode) {
		p.Warn("[chargeDeliver] OnDeliver fail. req = %v, errCode = %d", req, errCode)
	}

	// 统一逻辑，加充值积分
	if chargeRow.ChargePoints > 0 {
		gameFacade.Asset.Add(p.playerID, enum.ItemIDChargePoint, int64(chargeRow.ChargePoints), ao.None, true)
	}

	return code.OK
}