package serviceGame

import (
	"context"
	"fmt"
	"github.com/gogf/gf/v2/encoding/gcharset"
	"github.com/gogf/gf/v2/encoding/gjson"
	"github.com/gogf/gf/v2/frame/g"
	"log"
	"strings"
	"tyj_admin/api/v1/game"
	"tyj_admin/internal/consts"
	"tyj_admin/internal/dao"
	"tyj_admin/internal/model/entity"
	"tyj_admin/internal/serviceGame/internal"
	"tyj_admin/library/libUtils"
	"tyj_admin/library/liberr"
	"tyj_admin/utils"
)

type IGameLoginUrl interface {
	GetLoginUrl(ctx context.Context, req *game.GetLoginUrlReq) (res *game.GetLoginUrlRes, err error)
	GetServerConfigGeneral(ctx context.Context, req *game.GetServerConfigGeneralReq) (res *game.GetServerConfigGeneralRes, err error)
	AddServerConfigGeneral(ctx context.Context, req *game.AddServerConfigGeneralReq) (res *game.AddServerConfigGeneralRes, err error)
	GetAllLoginUrl(ctx context.Context, req *game.GetAllLoginUrlReq) (res *game.GetAllLoginUrlRes, err error)
	AddLoginUrl(ctx context.Context, req *game.AddLoginUrlReq) (res *game.AddLoginUrlRes, err error)
	DelLoginUrl(ctx context.Context, req *game.DelLoginUrlReq) (res *game.DelLoginUrlRes, err error)
	GetGameLoginUrl(ctx context.Context, req *game.GetGameLoginUrlReq) (res *game.GetGameLoginUrlRes, err error)
	ReConfigServer(ctx context.Context, req *game.ReConfigServerReq) (res *game.ReConfigServerRes, err error)
	GetAllChannel(ctx context.Context, req *game.GetAllChannelReq) (res *game.GetAllChannelRes, err error)
	GetAllCcdUrl(ctx context.Context, req *game.GetAllCcdUrlReq) (res *game.GetAllCcdUrlRes, err error)
	AddServerConfig(ctx context.Context, req *game.AddServerConfigReq) (res *game.AddServerConfigRes, err error)
	GetRouter(ctx context.Context, req *game.GetRouterReq) (res *game.GetRouterRes, err error)
	GetServerVersionList(ctx context.Context, req *game.GetServerVersionListReq) (res *game.GetServerVersionListRes, err error)
	UpdateRouter(ctx context.Context, req *game.AddRouterReq) (res *game.AddRouterRes, err error)
}

type gameLoginUrlImpl struct {
}

var gameLoginUrlService = gameLoginUrlImpl{}

func GameLoginUrl() IGameLoginUrl {
	return &gameLoginUrlService
}
func (c *gameLoginUrlImpl) GetLoginUrl(ctx context.Context, req *game.GetLoginUrlReq) (res *game.GetLoginUrlRes, err error) {
	g.Try(ctx, func(ctx context.Context) {
		res = new(game.GetLoginUrlRes)
		model := dao.GameLoginUrl.Ctx(ctx)
		res.Total, err = model.Count()
		liberr.ErrIsNil(ctx, err, "mysql err")
		model = model.Page(req.PageNum, req.PageSize)
		err = model.Scan(&res.LoginUrlList)

		//service.Email().SendEmail(ctx, &system.SendEmailReq{})
	})
	return
}
func (c *gameLoginUrlImpl) GetServerConfigGeneral(ctx context.Context, req *game.GetServerConfigGeneralReq) (res *game.GetServerConfigGeneralRes, err error) {
	g.Try(ctx, func(ctx context.Context) {
		res = new(game.GetServerConfigGeneralRes)
		err = dao.GameServerJsonGeneral.Ctx(ctx).Scan(&res.List)
		liberr.ErrIsNil(ctx, err, "mysql err")
	})
	return
}

func (c *gameLoginUrlImpl) AddServerConfigGeneral(ctx context.Context, req *game.AddServerConfigGeneralReq) (res *game.AddServerConfigGeneralRes, err error) {
	g.Try(ctx, func(ctx context.Context) {
		res = new(game.AddServerConfigGeneralRes)
		_, err = dao.GameServerJsonGeneral.Ctx(ctx).Where("id=?", req.Id).Update(g.Map{
			dao.GameServerJsonGeneral.Columns().BackstageRechargeUrl: req.BackstageRechargeUrl,
			dao.GameServerJsonGeneral.Columns().IdentityCheckAddress: req.IdentityCheckAddress,
			dao.GameServerJsonGeneral.Columns().UniqueAddress:        req.UniqueAddress,
			dao.GameServerJsonGeneral.Columns().RechargeWhiteListIps: req.RechargeWhiteListIps,
			dao.GameServerJsonGeneral.Columns().GmWhiteListUrl:       req.GmWhiteListUrl,
			dao.GameServerJsonGeneral.Columns().SdkAddress:           req.SdkAddress,
		})
		liberr.ErrIsNil(ctx, err, "mysql err")
	})
	return
}

func (c *gameLoginUrlImpl) GetAllLoginUrl(ctx context.Context, req *game.GetAllLoginUrlReq) (res *game.GetAllLoginUrlRes, err error) {
	g.Try(ctx, func(ctx context.Context) {
		res = new(game.GetAllLoginUrlRes)
		res.LoginUrlList = internal.ServerList
	})
	return
}

func (c *gameLoginUrlImpl) AddLoginUrl(ctx context.Context, req *game.AddLoginUrlReq) (res *game.AddLoginUrlRes, err error) {
	res = new(game.AddLoginUrlRes)
	err = g.Try(ctx, func(ctx context.Context) {
		server := []entity.GameLoginUrl{}
		model := dao.GameLoginUrl.Ctx(ctx)
		model.WherePri(req.Id).Scan(&server)
		if len(server) > 0 {
			data := g.Map{
				dao.GameLoginUrl.Columns().Id: req.Id,
			}
			if req.IsNew != "" {
				data[dao.GameLoginUrl.Columns().IsNew] = req.IsNew
			}
			if req.Recommend != "" {
				data[dao.GameLoginUrl.Columns().Recommend] = req.Recommend
			}
			if req.State != "" {
				data[dao.GameLoginUrl.Columns().State] = req.State
			}
			if req.Host != "" {
				data[dao.GameLoginUrl.Columns().Host] = req.Host
			}
			if req.Port != 0 {
				data[dao.GameLoginUrl.Columns().Port] = req.Port
			}
			_, err = model.WherePri(req.Id).Update(data)
		}
	})
	return
}

func (c *gameLoginUrlImpl) DelLoginUrl(ctx context.Context, req *game.DelLoginUrlReq) (res *game.DelLoginUrlRes, err error) {
	err = g.Try(ctx, func(ctx context.Context) {
		if req.Id == 0 {
			liberr.ErrIsNil(ctx, err, "错误的id")
			return
		}
		_, e := dao.GameLoginUrl.Ctx(ctx).Where("id=", req.Id).Delete()
		if e != nil {
			liberr.ErrIsNil(ctx, e, "删除通知失败")
			return
		}
	})

	return
}

func (c *gameLoginUrlImpl) GetGameLoginUrl(ctx context.Context, req *game.GetGameLoginUrlReq) (res *game.GetGameLoginUrlRes, err error) {
	res = new(game.GetGameLoginUrlRes)
	ip := libUtils.GetClientIp(ctx)
	list, _ := internal.GetWhiteList(ctx)
	blackList, _ := internal.GetBlackList(ctx)
	account := req.Account
	if req.Channel == consts.Channel_Editor {
		if !strings.Contains(account, req.Channel) {
			account = req.Channel + account
		}
	}

	g.Log().Debugf(ctx, "GetWhiteList -> ", req.Account, gjson.MustEncodeString(list), ip)
	err = g.Try(ctx, func(ctx context.Context) {
		var LoginUrlList []*entity.GameLoginUrl
		err = dao.GameLoginUrl.Ctx(ctx).Where("isShow=?", 1).Scan(&LoginUrlList)
		var unitData []*entity.GameUnit
		if req.Account != "" {
			err = dao.GameUnit.Ctx(ctx).Where("channel=?", req.Channel).Where("account=?", req.Account).Scan(&unitData)
		}

		if err != nil || len(LoginUrlList) == 0 {
			liberr.ErrIsNil(ctx, err, "获取服务器失败")
			return
		}

		if req.Channel == "000005000000" && req.Version == "1.0.1" && req.VersionName != "" {
			req.Version = "1.0.2"
		}

		logTime := int64(0)
		last := 0
		channel := ";"
		if internal.LoginUrlChannelList(ctx, req.Channel+req.Version) == 1 {
			channel += req.Channel + req.Version
		} else if internal.LoginUrlChannelList(ctx, req.Channel) == 1 {
			channel += req.Channel
		} else if internal.LoginUrlChannelList(ctx, req.Version) == 1 {
			channel += req.Version
		}
		channel += ";"
		for _, v := range LoginUrlList {
			if v.IsShow != 1 {
				continue
			}
			if !strings.Contains(v.Channel, channel) {
				continue
			}

			var data = game.LoginUrlData{Id: v.Id, Host: v.Host, Port: v.Port, Difficulty: v.Difficulty, IsNew: v.IsNew,
				Recommend: v.Recommend, Name: v.Name, State: v.State, Area: v.Area, CreateTime: v.CDate.Unix()}
			if data.State == consts.Login_URL_STATE_WHITE {
				if utils.ContainsWhiteList(list, ip) || utils.ContainsWhiteList(list, req.Channel) {
					data.State = consts.Login_URL_STATE_NORMAL
				} else {
					data.State = consts.Login_URL_STATE_Maintenance
					data.Host = consts.DEFAULT_HOST
				}
			}
			if data.State == consts.Login_URL_STATE_BLACK {
				if !utils.ContainsBlackList(blackList, req.Channel) || utils.ContainsWhiteList(list, ip) {
					data.State = consts.Login_URL_STATE_NORMAL
				} else {
					data.State = consts.Login_URL_STATE_Maintenance
					data.Host = consts.DEFAULT_HOST
				}
			}
			for _, v1 := range unitData {
				if v1.Server == data.Id {
					data.AccountName = v1.Name
					data.Scale = v1.Scale
					if logTime < v1.LogTime {
						logTime = v1.LogTime
						last = v1.Server
					}
				}
			}
			res.UrlStr = append(res.UrlStr, data)
		}
		for i := 0; i < len(res.UrlStr); i++ {
			if res.UrlStr[i].Id == last {
				res.UrlStr[i].Last = 1
				break
			}
		}

		g.Log().Debugf(ctx, "GetGameLoginUrl -> ", req.Account, gjson.MustEncodeString(res), last)
		return
	})

	return
}

func (c *gameLoginUrlImpl) ReConfigServer(ctx context.Context, req *game.ReConfigServerReq) (res *game.ReConfigServerRes, err error) {
	internal.InitServer(ctx)
	internal.InitRechargeServer(ctx)
	internal.InitChannel(ctx)
	internal.InitRouterServer(ctx)
	internal.MongoInit(ctx)
	return
}

func (c *gameLoginUrlImpl) GetAllChannel(ctx context.Context, req *game.GetAllChannelReq) (res *game.GetAllChannelRes, err error) {
	g.Try(ctx, func(ctx context.Context) {
		res = new(game.GetAllChannelRes)
		res.List = internal.ChannelList
	})
	return
}

func (c *gameLoginUrlImpl) GetAllCcdUrl(ctx context.Context, req *game.GetAllCcdUrlReq) (res *game.GetAllCcdUrlRes, err error) {
	res = new(game.GetAllCcdUrlRes)
	g.Try(ctx, func(ctx context.Context) {
		err = dao.GameCcdVersion.Ctx(ctx).Scan(&res.List)
		log.Printf("ccdBox: %v", res.List)
	})
	return
}

func (c *gameLoginUrlImpl) GetRouter(ctx context.Context, req *game.GetRouterReq) (res *game.GetRouterRes, err error) {
	g.Try(ctx, func(ctx context.Context) {
		res = new(game.GetRouterRes)
		model := dao.GameRouter.Ctx(ctx)
		res.Total, err = model.Count()
		liberr.ErrIsNil(ctx, err, "mysql err")
		model = model.Page(req.PageNum, req.PageSize)
		err = model.Scan(&res.List)
		liberr.ErrIsNil(ctx, err, "mysql err")
	})
	return
}

func (c *gameLoginUrlImpl) AddServerConfig(ctx context.Context, req *game.AddServerConfigReq) (res *game.AddServerConfigRes, err error) {
	res = new(game.AddServerConfigRes)
	err = g.Try(ctx, func(ctx context.Context) {
		server := []entity.GameLoginUrl{}
		model := dao.GameLoginUrl.Ctx(ctx)
		model.WherePri(req.Id).Scan(&server)
		if len(server) > 0 {
			_, err = model.WherePri(req.Id).Update(g.Map{
				dao.GameLoginUrl.Columns().Id:         req.Id,
				dao.GameLoginUrl.Columns().GameDbUrl:  req.GameDbUrl,
				dao.GameLoginUrl.Columns().GameDbName: req.GameDbName,
				dao.GameLoginUrl.Columns().Platform:   req.Platform,
				dao.GameLoginUrl.Columns().InnerIp:    req.InnerIp,
				dao.GameLoginUrl.Columns().CreateTime: req.CreateTime,
				dao.GameLoginUrl.Columns().Difficulty: req.Difficulty,
				dao.GameLoginUrl.Columns().Channel:    req.Channel,
			})
		}
	})
	return
}

func (c *gameLoginUrlImpl) UpdateRouter(ctx context.Context, req *game.AddRouterReq) (res *game.AddRouterRes, err error) {
	res = new(game.AddRouterRes)
	err = g.Try(ctx, func(ctx context.Context) {
		server := []entity.GameRouter{}
		model := dao.GameRouter.Ctx(ctx)
		model.WherePri(req.Id).Scan(&server)
		if len(server) > 0 {
			_, err = model.WherePri(req.Id).Update(g.Map{
				dao.GameRouter.Columns().Id:         req.Id,
				dao.GameRouter.Columns().RealmIp:    req.RealmIp,
				dao.GameRouter.Columns().RealmPort:  req.RealmPort,
				dao.GameRouter.Columns().RealmNum:   req.RealmNum,
				dao.GameRouter.Columns().RealmStep:  req.RealmStep,
				dao.GameRouter.Columns().RouterIp:   req.RouterIp,
				dao.GameRouter.Columns().RouterPort: req.RouterPort,
				dao.GameRouter.Columns().RouterNum:  req.RouterNum,
				dao.GameRouter.Columns().RouterStep: req.RouterStep,
			})
		} else {
			_, err = model.Insert(g.Map{
				dao.GameRouter.Columns().Id:         req.Id,
				dao.GameRouter.Columns().RealmIp:    req.RealmIp,
				dao.GameRouter.Columns().RealmPort:  req.RealmPort,
				dao.GameRouter.Columns().RealmNum:   req.RealmNum,
				dao.GameRouter.Columns().RealmStep:  req.RealmStep,
				dao.GameRouter.Columns().RouterIp:   req.RouterIp,
				dao.GameRouter.Columns().RouterPort: req.RouterPort,
				dao.GameRouter.Columns().RouterNum:  req.RouterNum,
				dao.GameRouter.Columns().RouterStep: req.RouterStep,
			})
		}
	})
	return
}

func (c *gameLoginUrlImpl) GetServerVersionList(ctx context.Context, req *game.GetServerVersionListReq) (res *game.GetServerVersionListRes, err error) {
	res = new(game.GetServerVersionListRes)
	ip := internal.ServerConfig[fmt.Sprint(req.Server)]
	url := "http://" + ip + "/get_version"
	bytes := g.Client().GetBytes(ctx, url)
	//fmt.Println("GetOnlineList: ", url, bytes)
	src := string(bytes)
	if g.IsEmpty(src) {
		res.Version = "获取失败"
		return
	}

	srcCharset := "UTF-8"
	tmp, _ := gcharset.ToUTF8(srcCharset, src)
	json, err := gjson.DecodeToJson(tmp)
	if err != nil {
		res.Version = "获取失败"
		return
	}
	//fmt.Println("GetOnlineList - json: ", tmp, gjson.MustEncodeString(json.Get("Accounts").Array()))
	if json.Get("Error").Int() == 200 {
		res.Version = json.Get("Message").String()
	} else {
		res.Version = "获取失败"
	}
	return
}