package timer

import (
	"context"
	"fmt"
	"go_dreamfactory/comm"
	"go_dreamfactory/modules"
	"go_dreamfactory/pb"
	"go_dreamfactory/sys/configure"
	cfg "go_dreamfactory/sys/configure/structs"
	"go_dreamfactory/sys/db"
	"math"
	"strconv"

	"go_dreamfactory/lego/base"
	"go_dreamfactory/lego/core"
	"go_dreamfactory/lego/core/cbase"
	"go_dreamfactory/lego/sys/log"
	"go_dreamfactory/lego/sys/redis/pipe"

	"github.com/go-redis/redis/v8"
	"go.mongodb.org/mongo-driver/bson"
	"go.mongodb.org/mongo-driver/bson/primitive"
	"go.mongodb.org/mongo-driver/mongo/options"
)

var (
	game_seasonloop   = "game_seasonloop.json"
	game_seasonreward = "game_pagodaseasonreward.json"
)

type SeasonPagoda struct {
	cbase.ModuleCompBase
	modules.MCompConfigure
	modules.MCompModel
	service base.IRPCXService
	module  *Timer
	mail    comm.Imail
}

//组件初始化接口
func (this *SeasonPagoda) Init(service core.IService, module core.IModule, comp core.IModuleComp, options core.IModuleOptions) (err error) {
	this.MCompConfigure.Init(service, module, comp, options)
	this.TableName = comm.TableSeasonPagoda
	this.MCompModel.Init(service, module, comp, options)
	this.service = service.(base.IRPCXService)
	this.module = module.(*Timer)

	if module1, err := this.service.GetModule(comm.ModuleMail); err == nil {
		this.mail = module1.(comm.Imail)
	}

	return
}

func (this *SeasonPagoda) Start() (err error) {
	err = this.MCompModel.Start()
	err = this.MCompConfigure.Start()

	// configure.RegisterConfigure(game_seasonloop, cfg.NewGameSeasonLoop, nil)
	// configure.RegisterConfigure(game_seasonreward, cfg.NewGamePagodaSeasonReward, nil)
	// cron.AddFunc("0 0 23 L * ?", this.TimerSeasonOver) //每月最后一天23点执行一次
	// cron.AddFunc("0 0 5 /* * ?", this.TimerSeasonStar) //每月第一天5点执行一次
	// if db.IsCross() {
	// 	return
	// }
	// //time.Sleep(time.Second * 1)
	// //this.DbTest()
	// conn, err := db.Cross()
	// if err == nil {
	// 	//this.DbTest()
	// 	model := db.NewDBModel(comm.TableSeasonData, 0, conn)

	// 	_len, err1 := model.DB.CountDocuments(comm.TableSeasonData, bson.M{})
	// 	if err1 == nil && _len == 0 {
	// 		fmt.Printf("%v,%v", _len, err1)
	// 		server := &pb.DBServerData{
	// 			Id:             primitive.NewObjectID().Hex(),
	// 			ServerState:    1,
	// 			DisposableLoop: 1,
	// 			FixedLoop:      0,
	// 			SeasonType:     201,
	// 			OpenTime:       time.Now().Unix(),
	// 		}
	// 		conf := this.GetSeasonLoop(comm.SeasonType)
	// 		if len(conf.DisposableLoop) > 0 {
	// 			server.SeasonType = conf.DisposableLoop[0]
	// 		}

	// 		model.DB.InsertOne(comm.TableSeasonData, server)
	// 	}
	// }
	return
}

func (this *SeasonPagoda) GetSeasonReward() []int32 {
	sz := make([]int32, 0)
	if v, err := this.GetConfigure(game_seasonreward); err != nil {
		log.Errorf("get global conf err:%v", err)
		return sz
	} else {
		if configure, ok := v.(*cfg.GamePagodaSeasonReward); ok {
			for _, v := range configure.GetDataList() {
				sz = append(sz, v.Ranking[0])
			}
		}
		log.Errorf("%T no is *cfg.Game_global", v)
		return sz
	}
}

// // 赛季塔结束
// func (this *SeasonPagoda) TimerSeasonOver() {
// 	this.module.Debugf("TimerSeasonOver:%d", configure.Now().Unix())
// 	if db.IsCross() {
// 		if conn, err := db.Cross(); err == nil {
// 			if rst := conn.Mgo.FindOne(comm.TableSeasonData, bson.M{}); rst != nil {
// 				serverData := &pb.DBServerData{}
// 				rst.Decode(serverData)
// 				conf := this.GetSeasonLoop(comm.SeasonType) // 获取赛季塔重置配置
// 				if serverData.FixedLoop == 0 {
// 					if len(conf.DisposableLoop) >= int(serverData.DisposableLoop) && len(conf.FixedLoop) > 0 { // 开始执行循环逻辑
// 						serverData.FixedLoop = 1
// 						serverData.DisposableLoop = 0
// 						serverData.SeasonType = conf.FixedLoop[int(serverData.FixedLoop)-1]
// 					} else {
// 						serverData.DisposableLoop++
// 						serverData.SeasonType = conf.DisposableLoop[int(serverData.DisposableLoop)-1]
// 					}

// 				} else { // 循环
// 					if len(conf.FixedLoop) >= int(serverData.FixedLoop) {
// 						serverData.FixedLoop = 1
// 					} else {
// 						serverData.FixedLoop++
// 					}
// 					serverData.SeasonType = conf.FixedLoop[int(serverData.FixedLoop)-1]
// 				}
// 				this.DB.UpdateOne(comm.TableSeasonData, bson.M{}, serverData)
// 				fmt.Printf("%v", serverData)
// 			}
// 		}
// 	}

// if _, err := this.service.RpcGo(context.Background(),
// 	comm.Service_Worker,
// 	string(comm.Rpc_ModuleSeasonPagodaReward),
// 	pb.EmptyReq{},
// 	nil,
// ); err != nil {
// 	this.module.Errorln(err)
// }
//}

// 赛季塔开始
func (this *SeasonPagoda) TimerSeasonStar() {
	this.module.Debugf("TimerSeasonStar:%d", configure.Now().Unix())
	//star := configure.Now()
	if !db.IsCross() { // 删除本服的赛季塔数据
		conn, err := db.Cross() // 获取跨服的链接对象
		if err == nil {
			model := db.NewDBModel(comm.TableSeasonData, 0, conn)
			model.DB.DeleteMany(comm.TableSeasonPagoda, bson.M{}, options.Delete())
			model.DB.DeleteMany(comm.TablePagodaRecord, bson.M{}, options.Delete())
			for pos := 0; pos < comm.MaxRankNum; pos++ {
				key1 := fmt.Sprintf("pagodaList%d", pos)
				if err := model.Redis.Delete(key1); err != nil {
					log.Errorf("delete failed")
				}
			}

			if err := model.Redis.Delete("pagodaSeasonRank"); err != nil {
				log.Errorf("delete failed")
			}
		}

		this.DB.DeleteMany(comm.TablePagodaRecord, bson.M{}, options.Delete())

	}
	//this.module.Debugf("=====%d,", time.Since(star).Milliseconds())
}

func (this *SeasonPagoda) DbTest() {
	conn, _ := db.Cross()
	model1 := db.NewDBModel(comm.TableVikingRank, 0, conn)
	model1.Redis.Delete("vikingRank2")
	_d, err := model1.Redis.Keys("vikingrank:*")
	if err == nil {
		for _, v := range _d {
			model1.Redis.Delete(v)
		}
		fmt.Printf("%v", _d)
	}
	//star := configure.Now()
	for i := 1; i < 10; i++ {

		new := &pb.DBVikingRank{
			Id:         primitive.NewObjectID().Hex(),
			Uid:        "mmmxxx" + strconv.Itoa(i),
			Difficulty: int32(i) % 10,
			Bosstype:   2,
			Nickname:   "helo",
			Icon:       "",
			Lv:         120,
			Leadpos:    1,
			Line:       make([]*pb.LineUp, 5),
			CostTime:   12000 + int32(i),
		}
		model1.AddList(new.Uid, new.Id, new)
		//model1.Add(new.Uid, new)
		var (
			pipe      *pipe.RedisPipe = conn.Redis.RedisPipe(context.TODO())
			menbers   *redis.Z
			tableName string
			score     int64
		)
		score = int64(i)<<31 + int64(math.MaxInt32-new.CostTime)
		tableName = "vikingRank" + strconv.Itoa(int(new.Bosstype))
		strKey := "vikingrank:" + new.Uid + "-" + new.Id // 自定义key new.Uid //
		menbers = &redis.Z{Score: float64(score), Member: strKey}

		if cmd := pipe.ZAdd(tableName, menbers); cmd != nil {

			dock, err1 := cmd.Result()
			if err1 != nil {
				this.module.Errorln(dock, err1)
			}
		}
		if _, err := pipe.Exec(); err != nil {
			this.module.Errorln(err)
		}
	}
	//this.module.Debugf("=====%d,", time.Since(star).Milliseconds())
	if true {
		var (
			pipe   *pipe.RedisPipe = conn.Redis.RedisPipe(context.TODO())
			szRank []*pb.DBVikingRank
		)
		// 降序
		rd := pipe.ZRevRange("vikingRank"+strconv.Itoa(2), 0, -1)

		if _, err := pipe.Exec(); err != nil {
			this.module.Errorln(err)
			return
		}
		_dataList := rd.Val()
		for _, v := range _dataList {
			result := &pb.DBVikingRank{}

			if err := model1.Redis.HGetAll(v, result); err == nil {
				szRank = append(szRank, result)
			}
		}
		this.module.Debugf("%v", szRank)
	}
}