package main

import (
	"mongo.games.com/game/common"
	"mongo.games.com/game/protocol/tournament"
	"mongo.games.com/goserver/core/logger"
	"mongo.games.com/goserver/core/netlib"
	"sort"
)

func CSTMInfo(s *netlib.Session, packetid int, data interface{}, sid int64) error {
	logger.Logger.Trace("CSTMInfoHandler ", data)
	_, ok := data.(*tournament.CSTMInfo)
	if !ok {
		return nil
	}

	p := PlayerMgrSington.GetOnlinePlayer(sid)
	if p == nil {
		logger.Logger.Warnf("CSTMInfo p == nil.")
		return nil
	}

	pack := TournamentMgr.GetSCTMInfosPack(p.Platform, p.AppChannel)
	p.SendToClient(int(tournament.TOURNAMENTID_PACKET_TM_SCTMInfos), pack)
	logger.Logger.Trace("SCTMInfos ", pack)
	return nil
}

func CSSignRace(s *netlib.Session, packetid int, data interface{}, sid int64) error {
	logger.Logger.Trace("CSSignRaceHandler ", data)
	msg, ok := data.(*tournament.CSSignRace)
	if !ok {
		return nil
	}
	p := PlayerMgrSington.GetOnlinePlayer(sid)
	if p == nil {
		logger.Logger.Warnf("CSSignRace p == nil.")
		return nil
	}
	if p.scene != nil {
		logger.Logger.Warnf("CSSignRace p.scene != nil.")
		return nil
	}
	if p.IsRob {
		logger.Logger.Warnf("CSSignRace p.IsRob.")
		return nil
	}

	platform := p.Platform
	tmId := msg.TMId
	pack := &tournament.SCSignRace{}

	switch msg.GetOpCode() {
	case 0: // 报名
		ok, code := TournamentMgr.SignUp(tmId, p)
		if !ok {
			logger.Logger.Infof("player(%v) match(%v) SignUp is fail.", p.SnId, tmId)
			pack.RetCode = code //0成功 1重复报名 2比赛没有开启 3道具不足 4不在报名时间段 5金币不足 6钻石不足
		}

		logger.Logger.Infof("player(%v) match(%v) SignUp is ok.", p.SnId, tmId)

		if code == int32(tournament.SignRaceCode_OPRC_Close) ||
			code == int32(tournament.SignRaceCode_OPRC_Time) {
			TournamentMgr.CancelSignUpAll(platform, tmId)
		}

		waitStart := TournamentMgr.playerWaitStart[p.SnId]
		if pack.RetCode == 0 && waitStart != 0 {
			pack.WaitStartTime = waitStart
		}

		signSucc := p.SendToClient(int(tournament.TOURNAMENTID_PACKET_TM_SCSignRace), pack)
		logger.Logger.Trace("SCSignRace ", pack)

		// 检查是否可以开始比赛（关闭机器人时，比赛开赛）
		if code == 0 && signSucc && !TournamentMgr.IsUseRobot(platform, tmId, 0) {
			if TournamentMgr.CanStart(platform, tmId) {
				TournamentMgr.Start(platform, tmId)
			}
		}

	default: // 取消报名
		if TournamentMgr.IsGaming(p.SnId) {
			logger.Logger.Warnf("player(%v) IsGaming.", p.SnId)
		} else {
			//取消报名
			TournamentMgr.CancelSignUp(platform, tmId, p.SnId)
		}
		return nil
	}

	return nil
}

func CSMatchList(s *netlib.Session, packetId int, data interface{}, sid int64) error {
	logger.Logger.Trace("CSMatchList ", data)
	msg, ok := data.(*tournament.CSMatchList)
	if !ok {
		return nil
	}
	p := PlayerMgrSington.GetOnlinePlayer(sid)
	if p == nil {
		logger.Logger.Warnf("CSMatchList p == nil.")
		return nil
	}
	pack := &tournament.SCTMMatchList{
		MatchId: msg.GetMatchId(),
		Tp:      msg.GetTp(),
	}

	audience := msg.GetTp() == 1
	list := TournamentMgr.GetTmMatch(p.Platform, int32(msg.GetMatchId()), p.LastChannel, audience, 0)

	// 开始时间排序
	sort.Slice(list, func(i, j int) bool {
		return list[i].StartTime.Compare(list[j].StartTime) == -1
	})

	for _, v := range list {
		round := TournamentMgr.GetRound(v.SortId)
		d := &tournament.MatchInfo{
			MatchId:    int64(v.TMId),
			InstanceId: v.SortId,
			Name:       v.gmd.GetMatchName(),
			Round:      round,
			TotalRound: v.GetTotalRound(),
			RemainNum:  TournamentMgr.GetRemainNum(v.SortId),
			Icon:       v.gmd.GetTitleURL(),
		}
		for _, v := range TournamentMgr.GetRemainPlayer(v.SortId) {
			var name, headUrl string
			p := PlayerMgrSington.GetPlayerBySnId(v.SnId)
			if p != nil {
				name = p.Name
				headUrl = p.HeadUrl
			}
			d.Players = append(d.Players, &tournament.MatchPlayer{
				SnId:      v.SnId,
				Name:      name,
				HeadUrl:   headUrl,
				UseRoleId: v.RoleId,
				UseSkinId: v.SkinId,
				Rank:      v.Rank,
				Score:     v.Grade,
			})
		}

		sort.Slice(d.Players, func(i, j int) bool {
			if d.Players[i].Score > d.Players[j].Score {
				return true
			}
			if d.Players[i].Score < d.Players[j].Score {
				return false
			}
			return d.Players[i].SnId < d.Players[j].SnId
		})

		pack.List = append(pack.List, d)
	}

	p.SendToClient(int(tournament.TOURNAMENTID_PACKET_TM_SCMatchList), pack)
	logger.Logger.Tracef("SCMatchList %v", pack)
	return nil
}

func CSRoomList(s *netlib.Session, packetId int, data interface{}, sid int64) error {
	logger.Logger.Trace("CSRoomList ", data)
	msg, ok := data.(*tournament.CSRoomList)
	if !ok {
		return nil
	}
	p := PlayerMgrSington.GetOnlinePlayer(sid)
	if p == nil {
		logger.Logger.Warnf("CSRoomList p == nil.")
		return nil
	}
	pack := &tournament.SCRoomList{
		Id: msg.GetId(),
		Tp: msg.GetTp(),
	}

	audience := msg.GetTp() == 1
	scenes := TournamentMgr.GetTmRoom(p.Platform, 0, p.LastChannel, audience, msg.GetId())
	for _, v := range scenes {
		tm := TournamentMgr.GetTm(v.MatchSortId)
		if tm == nil {
			continue
		}
		room := &tournament.MatchRoom{
			RoomId:     int64(v.sceneId),
			MatchId:    int64(tm.TMId),
			InstanceId: tm.SortId,
			Round:      TournamentMgr.GetRound(tm.SortId),
			TotalRound: tm.GetTotalRound(),
		}
		for _, v := range v.players {
			if v.matchCtx == nil {
				continue
			}

			p := PlayerMgrSington.GetPlayerBySnId(v.matchCtx.copySnid)

			d := &tournament.MatchPlayer{
				SnId:      v.matchCtx.copySnid,
				Name:      p.GetName(),
				UseRoleId: v.matchCtx.copyRoleId,
				UseSkinId: v.matchCtx.copySkinId,
				Rank:      TournamentMgr.GetRank(tm.SortId, v.matchCtx.copySnid),
				Score:     v.matchCtx.grade,
			}
			room.Players = append(room.Players, d)
		}
		sort.Slice(room.Players, func(i, j int) bool {
			if room.Players[i].Rank == room.Players[j].Rank {
				return room.Players[i].SnId < room.Players[j].SnId
			}
			return room.Players[i].Rank < room.Players[j].Rank
		})
		pack.List = append(pack.List, room)
	}
	p.SendToClient(int(tournament.TOURNAMENTID_PACKET_TM_SCRoomList), pack)
	logger.Logger.Tracef("SCRoomList %v", pack)
	return nil
}

func init() {
	// 比赛配置列表
	common.Register(int(tournament.TOURNAMENTID_PACKET_TM_CSTMInfo), tournament.CSTMInfo{}, CSTMInfo)
	// 比赛报名
	common.Register(int(tournament.TOURNAMENTID_PACKET_TM_CSSignRace), tournament.CSSignRace{}, CSSignRace)
	// 比赛中比赛列表
	common.Register(int(tournament.TOURNAMENTID_PACKET_TM_CSMatchList), tournament.CSMatchList{}, CSMatchList)
	// 比赛中房间列表
	common.Register(int(tournament.TOURNAMENTID_PACKET_TM_CSRoomList), tournament.CSRoomList{}, CSRoomList)
}