package model

import (
	"rocommon/rpc"
	"rocommon/util"
	"roserver/baseserver/model"
	"roserver/serverproto"
)

/////////////////////////////////////////////发送数据
func (this *WorldBossManager) SendMapRouter(msg interface{}, uid uint64) bool {
	data, meta, err := rpc.EncodeMessage(msg)
	if err != nil {
		util.InfoF("[SendMapRouter] EncodeMessage err:%v %v", err, msg)
		return false
	}

	if this.mapRouterNode == "" {
		this.mapRouterNode = model.SelectServiceNode(model.SERVICE_NODE_TYPE_MAP_ROUTER_STR, 0)
	}
	if this.mapRouterNode == "" {
		util.InfoF("[SendMapRouter] map router node not exist msg:%v", msg)
		return false
	}

	mapRouterSess := model.GetServiceNode(this.mapRouterNode)
	if mapRouterSess == nil {
		util.InfoF("[SendMapRouter] aoiRouter session not exist:%v", this.mapRouterNode)
	} else {
		//如果玩家信息存在，ClientId中存放的是玩家ID，否则存放的是玩家的gate sessionId
		mapRouterSess.Send(&serverproto.ServiceTransmitAck{
			MsgId:   uint32(meta.ID),
			MsgData: data,
			//todo...
			// 对应的玩家 gate channelId channelRoleList[key]
			// 后续和gate直接通信时使用，如果断线重连需要重新绑定
			ClientId: uid, //对应的玩家 gate uuid uuidRoleList[key]
		})
	}
	return true
}

func (this *WorldBossManager) SendSocial(msg interface{}) bool {
	data, meta, err := rpc.EncodeMessage(msg)
	if err != nil {
		util.ErrorF("[SendSocial] EncodeMessage err:%v %v", err, msg)
		return false
	}

	if this.socialNode == "" {
		this.socialNode = model.SelectServiceNode(model.SERVICE_NODE_TYPE_SOCIAL_STR, 0)
	}
	if this.socialNode == "" {
		util.ErrorF("[SendSocial] social node not exist msg:%v", msg)
		return false
	}

	socialSess := model.GetServiceNode(this.socialNode)
	if socialSess == nil {
		util.ErrorF("[SendSocial] social session not exist:%v", this.mapRouterNode)
	} else {
		//如果玩家信息存在，ClientId中存放的是玩家ID，否则存放的是玩家的gate sessionId
		socialSess.Send(&serverproto.ServiceTransmitAck{
			MsgId:   uint32(meta.ID),
			MsgData: data,
		})
	}
	return true
}

func SendDB(msg interface{}) bool {
	data, meta, err := rpc.EncodeMessage(msg)
	if err != nil {
		util.InfoF("[SendDB] EncodeMessage err:%v %v", err, msg)
		return false
	}

	dbNode := model.SelectServiceNode(model.SERVICE_NODE_TYPE_DB_STR, 0)
	if dbNode == "" {
		util.InfoF("[SendDB] db node not exist msg:%v", msg)
		return false
	}

	dbSess := model.GetServiceNode(dbNode)
	if dbSess == nil {
		util.ErrorF("[SendDB] db session not exist:%v", dbSess)
		return false
	} else {
		//如果玩家信息存在，ClientId中存放的是玩家ID，否则存放的是玩家的gate sessionId
		dbSess.Send(&serverproto.ServiceTransmitAck{
			MsgId:   uint32(meta.ID),
			MsgData: data,
		})
	}
	return true
}

func (this *WorldBossManager) SendGame(msg interface{}, gameNode string, uid uint64) bool {
	return this.SendServiceByNode(msg, gameNode, uid)
}

func (this *WorldBossManager) SendServiceByNode(msg interface{}, serviceNode string, uid uint64) bool {
	data, meta, err := rpc.EncodeMessage(msg)
	if err != nil {
		util.InfoF("[SendServiceByNode] EncodeMessage err:%v %v", err, msg)
		return false
	}

	nodeSess := model.GetServiceNode(serviceNode)
	if nodeSess == nil {
		util.InfoF("[SendServiceByNode] service session not exist:%v", serviceNode)
	} else {
		//如果玩家信息存在，ClientId中存放的是玩家ID，否则存放的是玩家的gate sessionId
		ackMsg := &serverproto.ServiceTransmitAck{
			MsgId:   uint32(meta.ID),
			MsgData: data,
		}
		if uid != 0 {
			ackMsg.ClientId = uid
		}
		nodeSess.Send(ackMsg)
	}
	return true
}

func SendToAllGame(msg interface{}) {
	data, info, err := rpc.EncodeMessage(msg)
	if err != nil {
		util.InfoF("[SendGame]EncodeMessage err:%v %v", err, msg)
		return
	}
	sendMsg := &serverproto.ServiceTransmitAck{
		MsgId:   uint32(info.ID),
		MsgData: data,
	}

	serviceList := model.GetAllServiceNodeByName(model.SERVICE_NODE_TYPE_GAME_STR)
	if len(serviceList) > 0 {
		for _, node := range serviceList {
			gameSess := model.GetServiceNode(node)
			if gameSess != nil {
				gameSess.Send(sendMsg)
			}
		}
	}
}