package battle_test

import (
	"fmt"
	"go_dreamfactory/comm"
	"go_dreamfactory/lego"
	"go_dreamfactory/lego/base/rpcx"
	"go_dreamfactory/lego/core"
	"go_dreamfactory/lego/sys/log"
	"go_dreamfactory/modules/equipment"
	"go_dreamfactory/modules/gm"
	"go_dreamfactory/modules/hero"
	"go_dreamfactory/modules/items"
	"go_dreamfactory/modules/user"
	"go_dreamfactory/pb"
	"go_dreamfactory/services"
	"go_dreamfactory/sys/configure"
	"go_dreamfactory/sys/db"
	"os"
	"os/signal"
	"syscall"
	"testing"
	"time"

	"github.com/gorilla/websocket"
	"google.golang.org/protobuf/proto"
	"google.golang.org/protobuf/types/known/anypb"
)

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

//梦工厂基础服务对象
type TestService struct {
	rpcx.RPCXService
}

//初始化相关系统
func (this *TestService) InitSys() {
	this.RPCXService.InitSys()
	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"]); err != nil {
		panic(fmt.Sprintf("init sys.configure err: %s", err.Error()))
	} else {
		log.Infof("init sys.configure success!")
	}
}

var service core.IService
var s_gateComp comm.ISC_GateRouteComp = services.NewGateRouteComp()
var module = new(gm.GM)

//测试环境下初始化db和cache 系统
func _TestMain(m *testing.M) {
	service = newService(
		rpcx.SetConfPath("../../bin/conf/worker_1.yaml"),
		rpcx.SetVersion("1.0.0.0"),
	)
	service.OnInstallComp( //装备组件
		s_gateComp, //此服务需要接受用户的消息 需要装备网关组件
	)
	go func() {
		lego.Run(service, //运行模块
			module,
			hero.NewModule(),
			user.NewModule(),
			items.NewModule(),
			equipment.NewModule(),
		)
	}()
	time.Sleep(time.Second * 3)
	defer os.Exit(m.Run())
}

func Test_Module(t *testing.T) {
	data := []int{}
	testdefer(&data)
	data = append(data, 2)
	fmt.Println(data)
}

func testdefer(data *[]int) {
	defer func() {
		*data = append(*data, 1)
	}()
	*data = append(*data, 0)
}

func Test_Comment(t *testing.T) {
	dialer := websocket.Dialer{}
	if connect, _, err := dialer.Dial("ws://127.0.0.1:9897", nil); err != nil {
		fmt.Println(err)
		return
	} else {

		go func() {
			var (
				data []byte
				msg  *pb.BattleRpcMessage = &pb.BattleRpcMessage{}
				err  error
			)
		locp:
			for {
				if _, data, err = connect.ReadMessage(); err != nil {
					fmt.Println(err)
					break locp
				}
				if err = proto.Unmarshal(data, msg); err != nil {
					fmt.Println(err)
					break locp
				}
				fmt.Println(msg)
			}
		}()

		msg := &pb.BattleRpcMessage{
			Rid:    1,
			Method: "Check",
		}
		msg.Data, _ = anypb.New(&pb.BattleReport{})
		data, _ := proto.Marshal(msg)
		connect.WriteMessage(websocket.BinaryMessage, data)
		//监听外部关闭服务信号
		c := make(chan os.Signal, 1)
		//添加进程结束信号
		signal.Notify(c,
			os.Interrupt,    //退出信号 ctrl+c退出
			syscall.SIGHUP,  //终端控制进程结束(终端连接断开)
			syscall.SIGINT,  //用户发送INTR字符(Ctrl+C)触发
			syscall.SIGTERM, //结束程序(可以被捕获、阻塞或忽略)
			syscall.SIGQUIT) //用户发送QUIT字符(Ctrl+/)触发
		select {
		case sig := <-c:
			fmt.Printf("signal = %v\n", sig)
		}
	}
}