package handler

import (
	"ecs/proto"
	"ecs/proto/old"
	"github.com/oylshe1314/framework/client"
	"github.com/oylshe1314/framework/client/rpc"
	"github.com/oylshe1314/framework/errors"
	"github.com/oylshe1314/framework/http"
	"github.com/oylshe1314/framework/message"
	"github.com/oylshe1314/framework/server"
	"github.com/oylshe1314/framework/util"
	"net/url"
)

type InnerHandler struct {
	*Handler

	httpRpcClient *rpc.HttpRpcClient
}

func NewInnerHandler(srv server.Server, httpRpcClient *rpc.HttpRpcClient) *InnerHandler {
	return &InnerHandler{Handler: newHandler(srv), httpRpcClient: httpRpcClient}
}

func (this *InnerHandler) ServerDetect(msg *http.Message) {
	var req = new(old.MsgServerDetectReq)
	var err = msg.Read(req)
	if err != nil {
		this.logger.Error("Read message error, ", err)
		_ = msg.Reply(proto.RawErrMessageError)
		return
	}

	if this.logger.IsDebugEnabled() {
		this.logger.Debugf("[%s] <- ServerDetect, req: %s", msg.R.RemoteAddr, util.ToJsonString(req))
	}

	var list []*old.ServerDetectData
	for _, serverDetect := range req.List {
		var detectAck = new(message.MsgServerDetectAck)
		reply, err := this.httpRpcClient.AppIdGet(serverDetect.Name, serverDetect.AppId, "/server/detect", nil, detectAck)
		if err != nil {
			this.logger.Warnf("[%s:%d] -> Server detect error, %v", serverDetect.Name, serverDetect.AppId, err)
			continue
		}

		if reply.Status != errors.StatusSuccessful {
			this.logger.Warnf("[%s:%d] -> Server detect failed, %v", serverDetect.Name, serverDetect.AppId, reply.Message)
			continue
		}

		var detectData = &old.ServerDetectData{
			ServerDetect: old.ServerDetect{
				Name:  serverDetect.Name,
				AppId: serverDetect.AppId,
			},
			ProgramHash: detectAck.ProgramHash,
			DataHash:    detectAck.DataHash,
			ConfigHash:  detectAck.ConfigHash,
			Pid:         detectAck.Pid,
			CPU:         detectAck.CPU,
			Memory:      detectAck.Memory,
			Coroutine:   uint32(detectAck.Coroutine),
			Info:        detectAck.Info,
		}

		if serverDetect.Name == "game_1" {
			var onlineAck = new(old.MsgServerOnlineAck)
			reply, err = this.httpRpcClient.AppIdGet(serverDetect.Name, serverDetect.AppId, "/server/online", nil, onlineAck)
			if err != nil {
				this.logger.Warnf("[%s:%d:/server/online] -> Get server online error, %v", serverDetect.Name, serverDetect.AppId, err)
			} else {
				if reply.Status != errors.StatusSuccessful {
					this.logger.Warnf("[%s:%d] -> Get server online failed, %v", serverDetect.Name, serverDetect.AppId, reply.Message)
				} else {
					detectData.Online = onlineAck.Online
				}
			}
		}

		list = append(list, detectData)
	}

	var ack = &old.MsgServerDetectAck{List: list}

	if this.logger.IsDebugEnabled() {
		this.logger.Debugf("[%s] -> ServerDetect, ack: %s", msg.R.RemoteAddr, util.ToJsonString(ack))
	}

	_ = msg.Reply(ack)
}

func (this *InnerHandler) GateSettingGet(msg *http.Message) {
	if this.logger.IsDebugEnabled() {
		this.logger.Debugf("[%s] <- GateSettingGet, req: %s", msg.R.RemoteAddr, util.ToJsonString(nil))
	}

	var ack = new(old.MsgGateSettingGetAck)
	reply, err := this.httpRpcClient.RandGet("gate", "/setting/get", nil, ack)
	if err != nil {
		this.logger.Error("[gate:0] -> Get setting error, ", err)
		_ = msg.Reply(proto.RawErrInternalError)
		return
	}

	if reply.Status != errors.StatusSuccessful {
		this.logger.Error("[gate:0] -> Get setting error, ", reply.Message)
		_ = msg.Reply(proto.RawErrInternalError)
		return
	}

	if this.logger.IsDebugEnabled() {
		this.logger.Debugf("[%s] -> GateSettingGet, ack: %s", msg.R.RemoteAddr, util.ToJsonString(ack))
	}

	_ = msg.Reply(ack)
}

func (this *InnerHandler) GateSettingSave(msg *http.Message) {
	var req = new(old.MsgGateSettingSaveReq)
	var err = msg.Read(req)
	if err != nil {
		this.logger.Error("Read message error, ", err)
		_ = msg.Reply(proto.RawErrMessageError)
		return
	}

	if this.logger.IsDebugEnabled() {
		this.logger.Debugf("[%s] <- GateSettingGet, req: %s", msg.R.RemoteAddr, util.ToJsonString(req))
	}

	reply, err := this.httpRpcClient.RandPost("gate", "/setting/save", nil, req, nil)
	if err != nil {
		this.logger.Error("[gate:0] -> Save setting error, ", err)
		_ = msg.Reply(proto.RawErrInternalError)
		return
	}

	if reply.Status != errors.StatusSuccessful {
		this.logger.Error("[gate:0] -> Save setting error, ", reply.Message)
		_ = msg.Reply(proto.RawErrInternalError)
		return
	}

	if this.logger.IsDebugEnabled() {
		this.logger.Debugf("[%s] -> GateSettingGet, ack: %s", msg.R.RemoteAddr, util.ToJsonString(nil))
	}

	_ = msg.Reply(nil)
}

func (this *InnerHandler) GateUserQuery(msg *http.Message) {
	var req = new(old.MsgUserQueryReq)
	var err = msg.Read(req)
	if err != nil {
		this.logger.Error("Read message error, ", err)
		_ = msg.Reply(proto.RawErrMessageError)
		return
	}

	if this.logger.IsDebugEnabled() {
		this.logger.Debugf("[%s] <- GateUserQuery, req: %s", msg.R.RemoteAddr, util.ToJsonString(req))
	}

	var query = url.Values{}
	query.Add("pageNo", util.IntegerToString(req.PageNo))
	query.Add("pageSize", util.IntegerToString(req.PageSize))
	if req.Channel != 0 {
		query.Add("channel", util.IntegerToString(req.Channel))
	}
	if req.UserId > 0 {
		query.Add("userId", util.IntegerToString(req.UserId))
	}

	reply, err := this.httpRpcClient.RandGet("gate", "/user/query", query, new(old.MsgUserQueryAck))
	if err != nil {
		this.logger.Error("Gate get cdkey error, ", err)
		_ = msg.Reply(proto.RawErrInternalError)
		return
	}

	if this.logger.IsDebugEnabled() {
		this.logger.Debugf("[%s] -> GateUserQuery, reply: %s", msg.R.RemoteAddr, util.ToJsonString(reply))
	}

	_ = msg.Reply(reply)
}

func (this *InnerHandler) GateUserOperate(msg *http.Message) {
	var req = new(old.MsgUserOperateReq)
	var err = msg.Read(req)
	if err != nil {
		this.logger.Error("Read message error, ", err)
		_ = msg.Reply(proto.RawErrMessageError)
		return
	}

	if this.logger.IsDebugEnabled() {
		this.logger.Debugf("[%s] <- GateUserOperate, req: %s", msg.R.RemoteAddr, util.ToJsonString(req))
	}

	reply, err := this.httpRpcClient.RandPost("gate", "/user/operate", nil, req, new(old.MsgUserQueryAck))
	if err != nil {
		this.logger.Error("Gate get cdkey error, ", err)
		_ = msg.Reply(proto.RawErrInternalError)
		return
	}

	if this.logger.IsDebugEnabled() {
		this.logger.Debugf("[%s] -> GateUserOperate, reply: %s", msg.R.RemoteAddr, util.ToJsonString(reply))
	}

	_ = msg.Reply(reply)
}

func (this *InnerHandler) GateCdkeyGet(msg *http.Message) {
	var req = new(old.MsgCdkeyGetReq)
	var err = msg.Read(req)
	if err != nil {
		this.logger.Error("Read message error, ", err)
		_ = msg.Reply(proto.RawErrMessageError)
		return
	}

	if this.logger.IsDebugEnabled() {
		this.logger.Debugf("[%s] <- GateCdkeyGet, req: %s", msg.R.RemoteAddr, util.ToJsonString(req))
	}

	var query = url.Values{}
	query.Add("key", req.Key)

	var ack = new(old.MsgCdkeyGetAck)
	reply, err := this.httpRpcClient.RandGet("gate", "/cdkey/get", query, ack)
	if err != nil {
		this.logger.Error("Gate get cdkey error, ", err)
		_ = msg.Reply(proto.RawErrInternalError)
		return
	}

	if this.logger.IsDebugEnabled() {
		this.logger.Debugf("[%s] -> GateCdkeyGet, reply: %s", msg.R.RemoteAddr, util.ToJsonString(reply))
	}

	_ = msg.Reply(reply)
}

func (this *InnerHandler) GateCdkeyList(msg *http.Message) {
	var req = new(old.MsgCdkeyListReq)
	var err = msg.Read(req)
	if err != nil {
		this.logger.Error("Read message error, ", err)
		_ = msg.Reply(proto.RawErrMessageError)
		return
	}

	if this.logger.IsDebugEnabled() {
		this.logger.Debugf("[%s] <- GateCdkeyList, req: %s", msg.R.RemoteAddr, util.ToJsonString(req))
	}

	var query = url.Values{}
	query.Add("pageNo", util.IntegerToString(req.PageNo))
	query.Add("pageSize", util.IntegerToString(req.PageSize))
	if req.Channel != 0 {
		query.Add("channel", util.IntegerToString(req.Channel))
	}

	reply, err := this.httpRpcClient.RandGet("gate", "/cdkey/list", query, new(old.MsgCdkeyListAck))
	if err != nil {
		this.logger.Error("Gate get cdkey error, ", err)
		_ = msg.Reply(proto.RawErrInternalError)
		return
	}

	if this.logger.IsDebugEnabled() {
		this.logger.Debugf("[%s] -> GateCdkeyList, reply: %s", msg.R.RemoteAddr, util.ToJsonString(reply))
	}

	_ = msg.Reply(reply)
}

func (this *InnerHandler) GateCdkeyAdd(msg *http.Message) {
	var req = new(old.MsgCdkeyAddReq)
	var err = msg.Read(req)
	if err != nil {
		this.logger.Error("Read message error, ", err)
		_ = msg.Reply(proto.RawErrMessageError)
		return
	}

	if this.logger.IsDebugEnabled() {
		this.logger.Debugf("[%s] <- GateCdkeyAdd, req: %s", msg.R.RemoteAddr, util.ToJsonString(req))
	}

	reply, err := this.httpRpcClient.RandPost("gate", "/cdkey/add", nil, req, new(old.MsgCdkeyAddAck))
	if err != nil {
		this.logger.Error("Gate get cdkey error, ", err)
		_ = msg.Reply(proto.RawErrInternalError)
		return
	}

	if this.logger.IsDebugEnabled() {
		this.logger.Debugf("[%s] -> GateCdkeyAdd, reply: %s", msg.R.RemoteAddr, util.ToJsonString(reply))
	}

	_ = msg.Reply(reply)
}

func (this *InnerHandler) GateCdkeyGenerate(msg *http.Message) {
	var req = new(old.MsgCdkeyGenerateReq)
	var err = msg.Read(req)
	if err != nil {
		this.logger.Error("Read message error, ", err)
		_ = msg.Reply(proto.RawErrMessageError)
		return
	}

	if this.logger.IsDebugEnabled() {
		this.logger.Debugf("[%s] <- GateCdkeyAdd, req: %s", msg.R.RemoteAddr, util.ToJsonString(req))
	}

	reply, err := this.httpRpcClient.RandPost("gate", "/cdkey/generate", nil, req, new(old.MsgCdkeyGenerateAck))
	if err != nil {
		this.logger.Error("Gate get cdkey error, ", err)
		_ = msg.Reply(proto.RawErrInternalError)
		return
	}

	if this.logger.IsDebugEnabled() {
		this.logger.Debugf("[%s] -> GateCdkeyAdd, reply: %s", msg.R.RemoteAddr, util.ToJsonString(reply))
	}

	_ = msg.Reply(reply)
}

func (this *InnerHandler) GateCdkeyDelete(msg *http.Message) {
	var req = new(old.MsgCdkeyDeleteReq)
	var err = msg.Read(req)
	if err != nil {
		this.logger.Error("Read message error, ", err)
		_ = msg.Reply(proto.RawErrMessageError)
		return
	}

	if this.logger.IsDebugEnabled() {
		this.logger.Debugf("[%s] <- GateCdkeyAdd, req: %s", msg.R.RemoteAddr, util.ToJsonString(req))
	}

	reply, err := this.httpRpcClient.RandPost("gate", "/cdkey/delete", nil, req, nil)
	if err != nil {
		this.logger.Error("Gate get cdkey error, ", err)
		_ = msg.Reply(proto.RawErrInternalError)
		return
	}

	if this.logger.IsDebugEnabled() {
		this.logger.Debugf("[%s] -> GateCdkeyDelete, reply: %s", msg.R.RemoteAddr, util.ToJsonString(reply))
	}

	_ = msg.Reply(reply)
}

func (this *InnerHandler) GameDataReload(msg *http.Message) {
	var serverReplies []*old.ServerReply
	ar, err := this.httpRpcClient.AllPost("game_1", "/server/data/reload", nil, nil, nil)
	if err != nil {
		this.logger.Errorf("Http get error, error: %v", err)
		_ = msg.Reply(proto.RawErrInternalError)
		return
	}

	for appId, result := range ar {
		if result.Err != nil {
			this.logger.Errorf("Http post error, appId: %d, error: %v", appId, result.Err)
			serverReplies = append(serverReplies, &old.ServerReply{AppId: appId, Status: -1, Message: result.Err.Error()})
		} else {
			if result.Res.Status != errors.StatusSuccessful {
				this.logger.Errorf("Http post failed, appId: %d, message: %s", appId, result.Res.Message)
			}
			serverReplies = append(serverReplies, &old.ServerReply{AppId: appId, Status: 0, Message: result.Res.Message})
		}
	}

	var ack = &old.MsgGameDataReloadAck{ServerReplies: serverReplies}

	if this.logger.IsDebugEnabled() {
		this.logger.Debugf("[%s] -> GameDataReload, ack: %s", msg.R.RemoteAddr, util.ToJsonString(ack))
	}

	_ = msg.Reply(ack)
}

func (this *InnerHandler) GameMailList(msg *http.Message) {
	var req = new(old.MsgGameMailListReq)
	var err = msg.Read(req)
	if err != nil {
		this.logger.Error("Read message error, ", err)
		_ = msg.Reply(proto.RawErrMessageError)
		return
	}

	if this.logger.IsDebugEnabled() {
		this.logger.Debugf("[%s] <- GameMailList, req: %s", msg.R.RemoteAddr, util.ToJsonString(req))
	}

	var serverReplies []*old.ServerMailList
	if req.AppId == 0 {
		ar, err := this.httpRpcClient.AllGet("game_1", "/server/mail/list", nil, new(old.MsgRegionMailListAck))
		if err != nil {
			this.logger.Errorf("Http get error, error: %v", err)
			_ = msg.Reply(proto.RawErrInternalError)
			return
		}

		for appId, result := range ar {
			if result.Err != nil {
				this.logger.Errorf("Http get error, appId: %d, error: %v", appId, err)
				serverReplies = append(serverReplies, &old.ServerMailList{ServerReply: old.ServerReply{AppId: appId, Status: -1, Message: result.Err.Error()}})
				continue
			}

			if result.Res.Status != errors.StatusSuccessful {
				this.logger.Errorf("Http get failed, appId: %d, message: %s", appId, result.Res.Message)
				serverReplies = append(serverReplies, &old.ServerMailList{ServerReply: old.ServerReply{AppId: appId, Status: result.Res.Status, Message: result.Res.Message}})
				continue
			}

			serverReplies = append(serverReplies, &old.ServerMailList{
				ServerReply: old.ServerReply{AppId: appId, Status: 0, Message: result.Res.Message},
				MailList:    result.Res.Data.(*old.MsgRegionMailListAck).List,
			})
		}
	} else {
		reply, err := this.httpRpcClient.AppIdGet("game_1", req.AppId, "/server/mail/list", nil, new(old.MsgRegionMailListAck))
		if err != nil {
			this.logger.Errorf("Http get error, appId: %d, error: %v", req.AppId, err)
			_ = msg.Reply(proto.RawErrInternalError)
			return
		} else {
			if reply.Status != errors.StatusSuccessful {
				this.logger.Errorf("Http get failed, appId: %d, message: %s", req.AppId, reply.Message)
				serverReplies = append(serverReplies, &old.ServerMailList{ServerReply: old.ServerReply{AppId: req.AppId, Status: reply.Status, Message: reply.Message}})
			} else {
				serverReplies = append(serverReplies, &old.ServerMailList{
					ServerReply: old.ServerReply{AppId: req.AppId, Status: 0, Message: reply.Message},
					MailList:    reply.Data.(*old.MsgRegionMailListAck).List,
				})
			}
		}
	}

	var ack = &old.MsgGameMailListAck{ServerReplies: serverReplies}

	if this.logger.IsDebugEnabled() {
		this.logger.Debugf("[%s] -> GameMailList, ack: %s", msg.R.RemoteAddr, util.ToJsonString(ack))
	}

	_ = msg.Reply(ack)
}

func (this *InnerHandler) GameMailSend(msg *http.Message) {
	var req = new(old.MsgGameMailSendReq)
	var err = msg.Read(req)
	if err != nil {
		this.logger.Error("Read message error, ", err)
		_ = msg.Reply(err)
		return
	}

	if this.logger.IsDebugEnabled() {
		this.logger.Debugf("[%s] <- GameMailSend, req: %s", msg.R.RemoteAddr, util.ToJsonString(req))
	}

	var serverReplies []*old.ServerReply
	if len(req.PlayerIds) == 0 { //没有玩家ID发全服邮件
		if len(req.AppIds) == 0 {
			ar, err := this.httpRpcClient.AllPost("game_1", "/server/mail/send", nil, &old.MsgRegionMailSendReq{BackMail: req.BackMail}, new(old.MsgRegionMailSendAck))
			if err != nil {
				this.logger.Errorf("Http get error, error: %v", err)
				_ = msg.Reply(proto.RawErrInternalError)
				return
			}

			for appId, result := range ar {
				if result.Err != nil {
					this.logger.Errorf("Http post error, appId: %d, error: %v", appId, result.Err)
					serverReplies = append(serverReplies, &old.ServerReply{AppId: appId, Status: -1, Message: result.Err.Error()})
				} else {
					if result.Res.Status != errors.StatusSuccessful {
						this.logger.Errorf("Http post failed, appId: %d, message: %s", appId, result.Res.Message)
					}
					serverReplies = append(serverReplies, &old.ServerReply{AppId: appId, Status: 0, Message: result.Res.Message})
				}
			}
		} else {
			for _, appId := range req.AppIds {
				reply, err := this.httpRpcClient.AppIdPost("game_1", appId, "/server/mail/send", nil, &old.MsgRegionMailSendReq{BackMail: req.BackMail}, nil)
				if err != nil {
					this.logger.Errorf("Http post error, appId: %d, error: %v", appId, err)
					serverReplies = append(serverReplies, &old.ServerReply{AppId: appId, Status: -1, Message: err.Error()})
					return
				} else {
					if reply.Status != errors.StatusSuccessful {
						this.logger.Errorf("Http post failed, appId: %d, message: %s", appId, reply.Message)
					}

					serverReplies = append(serverReplies, &old.ServerReply{AppId: appId, Status: 0, Message: reply.Message})
				}
			}
		}
	} else { //发送玩家邮件
		if len(req.AppIds) == 0 {
			this.logger.Error("Parameter error, len(req.AppIds) == 0")
			_ = msg.Reply(proto.RawErrParameterError)
			return
		}

		var header = client.HttpHeader{}
		for _, playerId := range req.PlayerIds {
			header.Add("PlayerId", util.IntegerToString(playerId))
		}

		for _, appId := range req.AppIds {
			reply, err := this.httpRpcClient.AppIdPost("game_1", appId, "/player/mail/send", nil, &old.MsgRegionMailSendReq{BackMail: req.BackMail}, nil, header)
			if err != nil {
				this.logger.Errorf("Http post error, appId: %d, error: %v", appId, err)
				serverReplies = append(serverReplies, &old.ServerReply{AppId: appId, Status: -1, Message: err.Error()})
				return
			} else {
				if reply.Status != errors.StatusSuccessful {
					this.logger.Errorf("Http post failed, appId: %d, message: %s", appId, reply.Message)
				}

				serverReplies = append(serverReplies, &old.ServerReply{AppId: appId, Status: reply.Status, Message: reply.Message})
			}
		}
	}

	var ack = &old.MsgGameMailSendAck{ServerReplies: serverReplies}

	if this.logger.IsDebugEnabled() {
		this.logger.Debugf("[%s] -> GameMailSend, ack: %s", msg.R.RemoteAddr, util.ToJsonString(ack))
	}

	_ = msg.Reply(ack)
}

func (this *InnerHandler) GameMailDelete(msg *http.Message) {
	var req = new(old.MsgGameMailDeleteReq)
	var err = msg.Read(req)
	if err != nil {
		this.logger.Error("Read message error, ", err)
		_ = msg.Reply(err)
		return
	}

	if this.logger.IsDebugEnabled() {
		this.logger.Debugf("[%s] <- GameMailDelete, req: %s", msg.R.RemoteAddr, util.ToJsonString(req))
	}

	var serverReplies []*old.ServerReply
	for _, selectedIds := range req.SelectedLists {
		reply, err := this.httpRpcClient.AppIdPost("game_1", selectedIds.AppId, "/server/mail/delete", nil, &old.MsgRegionMailDeleteReq{Ids: selectedIds.Ids}, nil)
		if err != nil {
			this.logger.Errorf("Http post error, appId: %d, error: %v", selectedIds.AppId, err)
			serverReplies = append(serverReplies, &old.ServerReply{AppId: selectedIds.AppId, Status: -1, Message: err.Error()})
			return
		} else {
			if reply.Status != errors.StatusSuccessful {
				this.logger.Errorf("Http post failed, appId: %d, message: %s", selectedIds.AppId, reply.Message)
			}

			serverReplies = append(serverReplies, &old.ServerReply{AppId: selectedIds.AppId, Status: reply.Status, Message: reply.Message})
		}
	}

	var ack = &old.MsgGameMailDeleteAck{ServerReplies: serverReplies}

	if this.logger.IsDebugEnabled() {
		this.logger.Debugf("[%s] -> GameMailDelete, ack: %s", msg.R.RemoteAddr, util.ToJsonString(ack))
	}

	_ = msg.Reply(ack)
}

func (this *InnerHandler) GamePlayerQuery(msg *http.Message) {
	var req = new(old.MsgGamePlayerQueryReq)
	var err = msg.Read(req)
	if err != nil {
		this.logger.Error("Read message error, ", err)
		_ = msg.Reply(proto.RawErrMessageError)
		return
	}

	if this.logger.IsDebugEnabled() {
		this.logger.Debug("[%s] <- ServerPlayerQuery, req: ", msg.R.RemoteAddr, util.ToJsonString(req))
	}

	if req.AppId == 0 || req.PlayerId == 0 {
		this.logger.Error("Parameter error, req.AppId == 0 || req.PlayerId == 0")
		_ = msg.Reply(proto.RawErrParameterError)
		return
	}

	var query = url.Values{}
	query.Add("playerId", util.IntegerToString(req.PlayerId))

	reply, err := this.httpRpcClient.AppIdGet("game_1", req.AppId, "/server/player/query", query, new(old.MsgPlayerQueryAck))
	if err != nil {
		this.logger.Error("Game player query error, ", err)
		_ = msg.Reply(proto.RawErrInternalError)
		return
	}

	if this.logger.IsDebugEnabled() {
		this.logger.Debugf("[%s] -> ServerPlayerQuery, reply: %s", msg.R.RemoteAddr, util.ToJsonString(reply))
	}

	_ = msg.Reply(reply)
}

func (this *InnerHandler) GamePlayerOperate(msg *http.Message) {
	var req = new(old.MsgGamePlayerOperateReq)
	var err = msg.Read(req)
	if err != nil {
		this.logger.Error("Read message error, ", err)
		_ = msg.Reply(proto.RawErrMessageError)
		return
	}

	if this.logger.IsDebugEnabled() {
		this.logger.Debug("[%s] <- GamePlayerOperate, req: ", msg.R.RemoteAddr, util.ToJsonString(req))
	}

	if req.AppId == 0 || req.PlayerId == 0 || (req.OperateType != 1 && req.OperateType != 2 && req.OperateType != 3) {
		this.logger.Error("Parameter error, req.AppId == 0 || req.PlayerId == 0")
		_ = msg.Reply(proto.RawErrParameterError)
		return
	}

	reply, err := this.httpRpcClient.AppIdPost("game_1", req.AppId, "/server/player/operate", nil, &old.MsgPlayerOperateReq{PlayerId: req.PlayerId, OperateType: req.OperateType, OperateArg: req.OperateArg}, new(old.MsgPlayerOperateAck))
	if err != nil {
		this.logger.Error("Game player operate error, ", err)
		_ = msg.Reply(proto.RawErrInternalError)
		return
	}

	if this.logger.IsDebugEnabled() {
		this.logger.Debugf("[%s] -> GamePlayerOperate, reply: %s", msg.R.RemoteAddr, util.ToJsonString(reply))
	}

	_ = msg.Reply(reply)
}