package handler

import (
	"encoding/json"
	"fmt"
	"samba/pkg/log"
	"samba/proto"
	"samba/stub"
	"samba/util/model"
	"time"
)

var GameServerMgr = newGameServerMgr()

type gameServer struct {
	*proto.NtfNewService
	Time  time.Time
	IsNew bool // 是不是最新服务
}

type gameServerMgr struct {
	gameServers []*gameServer
}

func newGameServerMgr() *gameServerMgr {
	return &gameServerMgr{gameServers: make([]*gameServer, 0)}
}

func (g *gameServerMgr) Init() {
	gs := model.GetCurrentService()
	if gs != "" {
		err := json.Unmarshal([]byte(gs), &g.gameServers)
		if err != nil {
			log.Error(err.Error())
		}
	}
}

func (g *gameServerMgr) Update(ntf *proto.NtfNewService) {
	for _, s := range g.gameServers {
		if s.Type == ntf.Type && ntf.IsClub == s.IsClub {
			s.IsNew = false
			break
		}
	}
	exist := false
	for _, s := range g.gameServers {
		if s.Type == ntf.Type && s.RouterKey == ntf.RouterKey {
			s.NtfNewService = ntf
			s.IsNew = true
			s.Time = time.Now()
			exist = true
			break
		}
	}
	if !exist {
		g.gameServers = append(g.gameServers, &gameServer{NtfNewService: ntf, Time: time.Now(), IsNew: true})
	}
	if bgs, err := json.Marshal(g.gameServers); err == nil {
		model.SetCurrentService(string(bgs))
	} else {
		log.Error(err.Error())
	}
}

func (g *gameServerMgr) roomTypeToServiceType(roomType int, isClub bool) string {
	rm, _ := stub.Rooms[roomType]
	if rm == nil {
		log.Error(fmt.Sprintf("room type:%v not exist", roomType))
		return ""
	}
	for _, gs := range g.gameServers {
		if !gs.IsNew || gs.IsClub != isClub {
			continue
		}
		for _, tp := range gs.PlayType {
			if rm.PlayType == tp {
				return gs.Type
			}
		}
	}
	log.Error(fmt.Sprintf("room type:%v not exist", roomType))
	return ""
}

func (g *gameServerMgr) FindByRoomType(roomType int, isClub bool) *proto.NtfNewService {
	sType := g.roomTypeToServiceType(roomType, isClub)
	for _, s := range g.gameServers {
		if s.Type == sType && s.IsNew && isClub == s.IsClub {
			return s.NtfNewService
		}
	}
	log.Error(fmt.Sprintf("can not find service type:%v", sType))
	return nil
}

func (g *gameServerMgr) playTypeToServiceType(playType int, isClub bool) string {
	for _, gs := range g.gameServers {
		for _, tp := range gs.PlayType {
			if playType == tp && gs.IsClub == isClub {
				return gs.Type
			}
		}
	}
	log.Error(fmt.Sprintf("play type:%v not exist", playType))
	return ""
}

func (g *gameServerMgr) FindByPlayType(playType int, isClub bool) *proto.NtfNewService {
	sType := g.playTypeToServiceType(playType, isClub)
	for _, s := range g.gameServers {
		if s.Type == sType && s.IsNew && s.IsClub == isClub {
			return s.NtfNewService
		}
	}
	log.Error(fmt.Sprintf("can not find service type:%v", sType))
	return nil
}

func (g *gameServerMgr) FindByType(sType string, isClub bool) *proto.NtfNewService {
	for _, s := range g.gameServers {
		if s.Type == sType && s.IsNew && isClub == s.IsClub {
			return s.NtfNewService
		}
	}
	log.Error(fmt.Sprintf("can not find service type:%v", sType))
	return nil
}

func (g *gameServerMgr) FindByRoomId(roomId int) *proto.NtfNewService {
	for _, s := range g.gameServers {
		if roomId >= s.RoomMinId && roomId < s.RoomMaxId {
			return s.NtfNewService
		}
	}
	log.Error(fmt.Sprintf("can not find service.roomId:%v", roomId))
	return nil
}

func (g *gameServerMgr) AllServer() []*gameServer {
	return g.gameServers
}