package controller

import (
	actorRemote "f1-game/internal/actor_remote"
	capp "f1-game/internal/cherry_app"
	"f1-game/internal/code"
	"f1-game/internal/data"
	nameActor "f1-game/internal/name/actor"
	nameKey "f1-game/internal/name/key"
	nameRemote "f1-game/internal/name/remote"
	"f1-game/internal/pb"
	"f1-game/internal/types"
	assetOrigin "f1-game/nodes/game/player/asset/origin"
	"fmt"
	"net/http"

	cstring "github.com/cherry-game/cherry/extend/string"
	cfacade "github.com/cherry-game/cherry/facade"
	clog "github.com/cherry-game/cherry/logger"
	cprofile "github.com/cherry-game/cherry/profile"
	cgin "github.com/cherry-game/components/gin"
	"github.com/gin-gonic/gin"
)

type gameController struct {
	cgin.BaseController
}

func (p *gameController) Init() {
	p.GET("/game/online/:gameNodeID", p.online)
	p.POST("/game/sendMail/:gameNodeID", p.sendMail)
	p.POST("/game/addAssets/:gameNodeID", p.addAssets)
	p.POST("/game/timeOffset/:gameNodeID", p.timeOffset)
	p.POST("/game/playerInfo/:gameNodeID", p.playerInfo)
	p.POST("/game/sendMarquee/:gameNodeID", p.sendMarquee)
	p.POST("/game/delMarquee/:gameNodeID", p.delMarquee)
	p.POST("/game/setBattleValidation/:gameNodeID", p.setBattleValidation)

	// 发送gm执行命令
	p.POST("/game/gm/:gameNodeID", p.sendGM)
}

func (p *gameController) online(c *cgin.Context) {
	gameNodeID := c.GetString(nameKey.GameNodeID, "")
	num, statusCode := actorRemote.GameOps.Online(gameNodeID)
	code.JSONResult(c, statusCode, num)
}

func (p *gameController) sendMail(c *cgin.Context) {
	var (
		gameNodeID = c.GetString(nameKey.GameNodeID, "")
		req        pb.SendMail
	)
	if len(gameNodeID) <= 0 {
		c.JSON(http.StatusBadRequest, gin.H{"error": "gameNodeID is required"})
		return
	}

	if err := c.ShouldBind(&req); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		return
	}

	if req.TemplateID <= 0 {
		c.JSON(http.StatusBadRequest, gin.H{"error:": "templateID is required"})
		return
	}

	statusCode := actorRemote.GameMail.Send(gameNodeID, &req)
	code.JSONResult(c, statusCode)
}

// addAssets 发送道具
func (p *gameController) addAssets(c *cgin.Context) {
	var req pb.AddAssets
	if err := c.ShouldBind(&req); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		return
	}

	var assets types.Assets
	for _, asset := range req.Assets {
		assets.Add(asset.Id, asset.Num)
	}

	gameNodeID := c.GetString(nameKey.GameNodeID, "")
	_, errCode := actorRemote.GamePlayer.AssetAdd(gameNodeID, req.PlayerID, assets, assetOrigin.GM)

	code.JSONResult(c, errCode)
}

func (p *gameController) timeOffset(c *cgin.Context) {
	var req pb.I64I64
	if err := c.ShouldBind(&req); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		return
	}

	gameNodeID := c.GetString(nameKey.GameNodeID, "")
	errCode := actorRemote.GamePlayer.Call(gameNodeID, req.Key, nameRemote.Player_GMTimeOffset, &pb.I64{Value: req.Value})

	code.JSONResult(c, errCode)
}

func (p *gameController) playerInfo(c *cgin.Context) {
	var req pb.I64
	if err := c.ShouldBind(&req); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		return
	}

	playerID := req.Value

	if playerID < 1 {
		c.JSON(http.StatusBadRequest, gin.H{"error:": "playerID is required"})
		return
	}

	gameNodeID := c.GetString(nameKey.GameNodeID, "")
	errCode, info := actorRemote.GamePlayer.GetPlayerInfo(gameNodeID, playerID)
	if code.IsFail(errCode) {
		code.JSONError(c, fmt.Sprintf("player data fail. errCode:%d", errCode))
		return
	}

	// 获取邮件信息
	errCode, resp := actorRemote.GameMail.GetMailList(gameNodeID, playerID)
	if code.IsFail(errCode) {
		clog.Warnf("get player info mail fail, errCode:%d", errCode)
	} else {
		info.Mails = resp.List
	}

	code.JSONResult(c, code.OK, info)
}

// 设置战斗验证开关
func (p *gameController) setBattleValidation(c *cgin.Context) {
	if !cprofile.Debug() {
		c.JSON(http.StatusBadRequest, gin.H{"error:": "function not open"})
		return
	}
	var req pb.Bool
	if err := c.ShouldBind(&req); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		return
	}

	gameNodeID := c.GetString(nameKey.GameNodeID, "")
	errCode := actorRemote.GameOps.SetBattleValidation(gameNodeID, &req)

	code.JSONResult(c, errCode)
}
func (p *gameController) sendGM(c *cgin.Context) {
	if !cprofile.Debug() || !data.NodeState.GmEnable {
		c.JSON(http.StatusBadRequest, gin.H{"error:": "function not open"})
		return
	}

	var req pb.StrStr
	if err := c.ShouldBind(&req); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		return
	}

	// TODO 如果需要后台或者客户端都能调用，是否需要添加密钥验证

	playerID := cstring.ToInt64D(req.Key)

	gameNodeID := c.GetString(nameKey.GameNodeID, "")
	errCode := actorRemote.GamePlayer.SendGM(gameNodeID, playerID, req.Value)

	code.JSONResult(c, errCode)
}

func (p *gameController) sendMarquee(c *cgin.Context) {
	var (
		gameNodeID = c.GetString(nameKey.GameNodeID, "")
		req        pb.Marquee
	)
	if len(gameNodeID) <= 0 {
		c.JSON(http.StatusBadRequest, gin.H{"error": "gameNodeID is required"})
		return
	}

	if err := c.ShouldBind(&req); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		return
	}

	if req.UID <= 0 {
		c.JSON(http.StatusBadRequest, gin.H{"error:": "UID is required"})
		return
	}

	targetPath := cfacade.NewPath(gameNodeID, nameActor.Marquee)
	statusCode := capp.Call(targetPath, nameRemote.Marquee_Send, &req)

	code.JSONResult(c, statusCode)
}

func (p *gameController) delMarquee(c *cgin.Context) {
	var (
		gameNodeID = c.GetString(nameKey.GameNodeID, "")
		req        pb.I32List
	)
	if len(gameNodeID) <= 0 {
		c.JSON(http.StatusBadRequest, gin.H{"error": "gameNodeID is required"})
		return
	}

	if err := c.ShouldBind(&req); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		return
	}

	if len(req.List) < 1 {
		c.JSON(http.StatusBadRequest, gin.H{"error:": "list empty"})
		return
	}

	targetPath := cfacade.NewPath(gameNodeID, nameActor.Marquee)
	statusCode := capp.Call(targetPath, nameRemote.Marquee_Del, &req)

	code.JSONResult(c, statusCode)
}