package main

import (
	"encoding/json"
	"git.wanbits.io/joe/franklin/comp"
	pb "git.wanbits.io/joe/franklin/protos"
	"git.wanbits.io/joe/kettle/htp"
	"git.wanbits.io/joe/kettle/log"
	"git.wanbits.io/joe/kettle/utl"
	"git.wanbits.io/joe/nnet/cpn"
	"github.com/coreos/etcd/clientv3"
	"github.com/gin-gonic/gin"
	"go.uber.org/zap"
	"net/http"
	"syscall"
	"time"
)

func main() {
	var err error
	comp.InitEnv("agent.toml", "agent.toml")
	// load conf
	g_conf, err = comp.LoadConf(comp.GConfile)
	utl.ErrPanic(err)
	// connect etcd
	// connect redis
	// connect mq
	// connect evbus
	comp.InitAll(g_conf)

	// connect to login
	loginconf, err := comp.GEtcdc.Get(comp.PathLogin(g_conf))
	utl.ErrPanic(err)
	if len(loginconf.Kvs) <= 0 {
		utl.ErrPanic(utl.ErrContainerEmpty)
	}

	var loginConf pb.LoginConfConf
	err = json.Unmarshal(loginconf.Kvs[0].Value, &loginConf)
	utl.ErrPanic(err)

	g_rabbitProto = NewRabbitCProtocol()
	g_rabbit = cpn.NewWsClient(&hubConfC, g_rabbitProto, g_rabbitProto, cpn.WithReconn(3*time.Second))
	err = g_rabbit.NewConnection(loginConf.Addrs[0], g_conf.Id)
	utl.UnUsed(err)

	// connect to lobbies
	lobJs, err := comp.GEtcdc.Get(comp.PathLobbies(g_conf), clientv3.WithPrefix())
	utl.ErrPanic(err)

	lobProto := ALProtocol{}
	g_taj = cpn.NewTcpClient(&hubConfC, &lobProto, &lobProto, cpn.WithReconn(3*time.Second))

	var lobConf pb.AppConfConf
	for _, conf := range lobJs.Kvs {
		err = json.Unmarshal(conf.Value, &lobConf)
		utl.ErrPanic(err)

		err = g_taj.NewConnection(lobConf.Addr, lobConf.Id)
		utl.UnUsed(err)
	}

	// connect to logics
	lgcJs, err := comp.GEtcdc.Get(comp.PathLogics(g_conf), clientv3.WithPrefix())
	utl.ErrPanic(err)

	lgcProto := ALProtocol{}
	g_logics = cpn.NewTcpClient(&hubConfC, &lgcProto, &lgcProto, cpn.WithReconn(3*time.Second))

	var lgcConf pb.AppConfConf
	for _, conf := range lgcJs.Kvs {
		err = json.Unmarshal(conf.Value, &lgcConf)
		utl.ErrPanic(err)

		err = g_logics.NewConnection(lgcConf.Addr, lobConf.Id)
		utl.UnUsed(err)
	}
	// start rpc
	comp.GRpc = htp.NewGinServer(g_conf.RpcAddr, htp.WithCors(true))
	err = comp.GRpc.Start(func(e *gin.Engine) {
		e.POST("/rpc", do_dispatch)
	})
	utl.ErrPanic(err)

	// register self
	// watch etcd
	// start listener
	g_serverProto = &CSProtocol{}
	g_server = cpn.NewWsServer(&hubConfS, g_serverProto, g_serverProto, g_conf.Addr, "/franklin", nil)
	go func() {
		if err = g_server.Start(); err != nil && err != http.ErrServerClosed {
			utl.ErrPanic(err)
		}
	}()
	// wait signal
	sig := utl.WaitForSignals(syscall.SIGINT)
	log.Debug("received signal", zap.String("sig", sig.String()))

	_ = g_server.Stop()
	_ = comp.GRpc.Stop()
	_ = g_logics.Stop()
	_ = g_taj.Stop()
	_ = g_rabbit.Stop()
	comp.GMq.Close()
	comp.GEtcdc.Close()
	_ = comp.GRds.Close()
	comp.GEv.Close()
	log.Sync()
}