package entertainment_test

import (
	"context"
	"fmt"
	"go_dreamfactory/comm"
	"go_dreamfactory/lego"
	"go_dreamfactory/lego/base/rpcx"
	"go_dreamfactory/lego/core"
	"go_dreamfactory/lego/sys/log"
	"go_dreamfactory/modules/entertainment"
	"go_dreamfactory/pb"
	"go_dreamfactory/services"
	"go_dreamfactory/sys/configure"
	"go_dreamfactory/sys/db"
	"math"
	"reflect"
	"strings"
	"testing"
	"time"

	flag "github.com/spf13/pflag"
)

var service core.IService
var s_gateComp comm.ISC_GateRouteComp = services.NewGateRouteComp()

type TestService struct {
	rpcx.RPCXService
}

func newService(ops ...rpcx.Option) core.IService {
	s := new(TestService)
	s.Configure(ops...)
	return s
}

//初始化相关系统
func (this *TestService) InitSys() {
	this.RPCXService.InitSys()
	// if err := log.OnInit(); err != nil {
	// 	panic(fmt.Sprintf("Sys log Init err:%v", err))
	// } else {
	// 	log.Infof("Sys log Init success !")
	// }
	if err := db.OnInit(this.GetSettings().Sys["db"]); err != nil {
		panic(fmt.Sprintf("init sys.db err: %s", err.Error()))
	} else {
		log.Infof("init sys.db success!")
	}
	if err := configure.OnInit(this.GetSettings().Sys["configure"], configure.SetConfigPath("F:/work/go/go_dreamfactory/bin/json")); err != nil {
		panic(fmt.Sprintf("init sys.configure err: %s", err.Error()))
	} else {
		log.Infof("init sys.configure success!")
	}
}

var (
	conf = flag.String("conf", "../../bin/conf/worker_1.yaml", "获取需要启动的服务配置文件") //启动服务的Id
)

type Service struct {
	services.ServiceBase
}

func NewService(ops ...rpcx.Option) core.IService {
	s := new(Service)
	s.Configure(ops...)
	return s
}
func t() {
	ch := make(chan struct{})
	//ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
	ctx, cancel := context.WithCancel(context.Background())

	go func(ctx context.Context) {
		for {
			select {
			case <-ctx.Done():
				ch <- struct{}{}
				return
			default:
				fmt.Println("x...")
			}

			time.Sleep(500 * time.Millisecond)
		}
	}(ctx)

	go func() {
		time.Sleep(3 * time.Second)
		cancel()
	}()

	<-ch
	fmt.Println("结束")
}
func Test_Main(t *testing.T) {
	flag.Parse()

	s := NewService(
		rpcx.SetConfPath(*conf),
		rpcx.SetVersion("1.0.0.0"),
	)
	s.OnInstallComp( //装备组件
		services.NewGateRouteComp(), //此服务需要接受用户的消息 需要装备网关组件
	)
	//go func() {
	lego.Run(s, //运行模块
		entertainment.NewModule(),
	)
	//}()

	print(math.Pow(2, 238))
	// sz := utils.RandomNumbers(0, 2, 2)
	// fmt.Printf("xxxx%v", sz)
	m := new(entertainment.MapData)
	m.InitMap(nil, 1)
	m.SetMap()
	m.Debugf()

	fmt.Printf("xxxx %v\n", m.SkillManYan(24, 0))
	//m.SkillUp(24, 1, 3, 7, true)

	b := m.GetFireBoom(1, 7)
	fmt.Printf("xxxx %d\n", b)
	var vids int
	for index := 7 - 1; index >= 0; index-- {
		for j := 0; j < 7; j++ {
			vids = index + j*7
			fmt.Printf("%d  ", vids)

		}
		fmt.Printf("\n")
	}
	for i := 0; i < 4; i++ {
		b := m.GetFireBoom(30, int32(i)+5)
		fmt.Printf("xxxx %d\n", b)
	}
	var mids map[int]struct{}
	mids = make(map[int]struct{}, 0)
	m.SkillManYan(35, 0)
	for i := 0; i < 4; i++ {

		dd := m.SkillManYan(24, int32(i))
		for k := range dd {
			for s := range m.SkillManYan(int32(k), int32(i)) {
				mids[s] = struct{}{}
			}
		}
	}
	for b := range mids {
		fmt.Printf("xxxx %d\n", b)
	}

	fmt.Printf("xxxx %v\n", m.GetBoomElem(46))
	m.Debugf()
	// b := m.CheckAndRefreshPlat()
	// fmt.Printf("xxxx%v", b)
	//m.RedsetPlatData()
	m.SwapGirde(15, 22)
	m.Debugf()
	m.CheckMap(1, false)
	m.Debugf()
	// for i := 0; i < 100; i++ {
	// 	m := new(entertainment.MapData)
	// 	m.InitMap(nil)
	// 	//m.SetMap()
	// 	m.SetIndelibilityPlat()
	// 	d, _ := m.CheckMap(0, true)
	// 	if len(d) > 0 {
	// 		fmt.Println("===========有消除")
	// 		m.Debugf()
	// 	}

	// 	if m.CheckAndRefreshPlat() {
	// 		m.Debugf()
	// 		fmt.Println("xxxx")
	// 	}
	// }

	//var szMap []*pb.MapData
	// if bSwap, m := m.AiSwapGirde(); bSwap {
	// 	szMap = append(szMap, m...)
	// }
	m.SkillUp(0, 1, 2, 7, true)
	m.SwapGirde(1, 8)
	//m.CheckMap(1)

	m.DropGirde()

	// if m, _ := m.CheckMap(1, true); score > 0 {

	// 	szMap = append(szMap, m...)
	// }
	m.SwapGirde(1, 11)

	m.DropGirde()
	//m.CheckMap(1)

	time.Sleep(time.Second * 2000)

	//equipment.CloneEquipment()
}

func GetMap() map[int32]int32 {
	return nil
}

func copyPoint(m *pb.DBHero) *pb.DBHero {
	vt := reflect.TypeOf(m).Elem()
	fmt.Println(vt)
	newoby := reflect.New(vt)
	newoby.Elem().Set(reflect.ValueOf(m).Elem())
	newoby.Interface().(*pb.DBHero).Lv = 1111
	return newoby.Interface().(*pb.DBHero)
}

func wordSepNormalizeFunc(f *flag.FlagSet, name string) flag.NormalizedName {
	from := []string{"-", "_"}
	to := "."
	for _, sep := range from {
		name = strings.Replace(name, sep, to, -1)
	}
	return flag.NormalizedName(name)
}

// 初始化worker需要的一些系统工具
func (this *Service) InitSys() {
	this.ServiceBase.InitSys()
	//初始化配置中心系统 每个服务都会用到的就在这个初始化就好

	//存储系统
	if err := db.OnInit(this.GetSettings().Sys["db"], db.SetServiceId(this.GetTag())); err != nil {
		panic(fmt.Sprintf("init sys.db err: %s", err.Error()))
	} else {
		log.Infof("init sys.db success!")
	}
}