package main

import (
	"encoding/json"
	"time"

	"mongo.games.com/goserver/core/basic"
	"mongo.games.com/goserver/core/i18n"
	"mongo.games.com/goserver/core/logger"
	"mongo.games.com/goserver/core/task"

	"mongo.games.com/game/common"
	"mongo.games.com/game/model"
)

var PermitMgrInst = new(PermitMgr)

type PermitMgr struct {
	BaseClockSinker
}

func (r *PermitMgr) InterestClockEvent() int {
	return 1 << CLOCK_EVENT_DAY
}

func (r *PermitMgr) OnDayTimer() {
	logger.Logger.Info("(this *PermitMgr) OnDayTimer")
	now := time.Now()
	for _, v := range PlatformMgrSingleton.GetPlatforms() {
		pl := PlatformMgrSingleton.GetConfig(v.IdStr).ActPermitConfig
		if pl == nil {
			continue
		}
		b := model.GetStrKVGameData(common.PermitStartTsKey + v.IdStr)
		if b == "" {
			logger.Logger.Errorf("(this *PermitMgr) OnDayTimer GetStrKVGameData not found")
			continue
		}
		se := new(model.PermitStartTs)
		if err := json.Unmarshal([]byte(b), se); err != nil {
			logger.Logger.Errorf("(this *PermitMgr) OnDayTimer json.Unmarshal err:%v", err)
			continue
		}
		if se.StartTs <= now.Unix() && now.Unix() < se.EndTs {
			// 在活动内
			continue
		}
		if now.Unix() < se.StartTs {
			// 活动未开始
			continue
		}
		if now.Unix() >= se.EndTs {
			// 活动结束，发送排行榜奖励
			startTs := se.StartTs
			var err error
			var list *model.FindPlayerPermitListReply
			var players []*model.PlayerBaseInfo
			task.New(nil, task.CallableWrapper(func(o *basic.Object) interface{} {
				list, err = model.FindPlayerPermitList(&model.FindPlayerPermitListArgs{
					Platform: v.IdStr,
					StartTs:  startTs,
				})
				for _, vv := range list.List {
					player := PlayerMgrSington.GetPlayerBySnId(vv.SnId)
					if player != nil {
						players = append(players, &model.PlayerBaseInfo{
							SnId:        0,
							LastChannel: player.LastChannel,
						})
					} else {
						baseInfo := model.GetPlayerBaseInfo(v.IdStr, vv.SnId)
						players = append(players, baseInfo)
					}
				}
				return nil
			}), task.CompleteNotifyWrapper(func(i interface{}, t task.Task) {
				if err != nil {
					logger.Logger.Errorf("PermitMgr OnDayTimer FindPlayerPermitList err:%v", err)
					return
				}
				for k, player := range players {
					if player == nil {
						logger.Logger.Errorf("PermitMgr OnDayTimer FindPlayerPermitList player is nil %v", list.List[k].SnId)
						continue
					}
					// 发送奖励
					cfg := PlatformMgrSingleton.GetPermitConfig(v.IdStr, player.LastChannel).GetRankConfig()
					rank := k + 1
					for _, rankInfo := range cfg {
						var has bool
						var items []int32
						for r := rankInfo.GetStart(); r <= rankInfo.GetEnd(); r++ {
							if rank == int(r) {
								has = true
								for _, item := range rankInfo.GetItemId() {
									items = append(items, item.GetItemId())
									items = append(items, int32(item.GetItemNum()))
								}
								if len(items) == 0 {
									break
								}
								// 发邮件
								var newMsg *model.Message
								task.New(nil, task.CallableWrapper(func(o *basic.Object) interface{} {
									title := i18n.Tr("languages", "PermitAwardTitle")
									content := i18n.Tr("languages", "PermitAward", []int{rank, rank, rank, rank})
									newMsg = model.NewMessage("", 0, "", player.SnId, model.MSGTYPE_RANK_REWARD,
										title, content, 0, 0, model.MSGSTATE_UNREAD, time.Now().Unix(), 0, "", items, v.IdStr, model.HallTienlen, nil)
									err := model.InsertMessage(v.IdStr, newMsg)
									if err != nil {
										logger.Logger.Errorf("发送邮件失败 snid:%v err:%v", player.SnId, err)
										return err
									}
									return nil
								}), task.CompleteNotifyWrapper(func(i interface{}, t task.Task) {
									p := PlayerMgrSington.GetPlayerBySnId(player.SnId)
									if p != nil {
										p.AddMessage(newMsg)
									}
								})).Start()
								break
							}
						}
						if has {
							break
						}
					}
				}
			})).StartByExecutor("permit_rank_award")

			// 活动已结束, 新开始
			se.StartTs = se.EndTs
			se.EndTs = se.EndTs + int64(pl.Days*24*3600)
			if now.Unix() < se.StartTs || now.Unix() >= se.EndTs {
				se.StartTs = common.GetDayStartTs(now.Unix())
				se.EndTs = se.StartTs + int64(pl.Days*24*3600)
			}
			PlatformMgrSingleton.GetConfig(v.IdStr).PermitStartTs = se.StartTs
			PlatformMgrSingleton.GetConfig(v.IdStr).PermitEndTs = se.EndTs
			b, err := json.Marshal(se)
			if err != nil {
				logger.Logger.Errorf("(this *PermitMgr) OnDayTimer json.Marshal err:%v", err)
				continue
			}
			task.New(nil, task.CallableWrapper(func(o *basic.Object) interface{} {
				model.UptStrKVGameData(common.PermitStartTsKey+v.IdStr, string(b))
				return nil
			}), nil).StartByExecutor("permit_start_ts")
		}
	}
}

func init() {
	ClockMgrSington.RegisteSinker(PermitMgrInst)
}