package main

import (
	"context"
	"fmt"
	"os"
	"os/signal"
	"syscall"
	"time"

	pf "gitee.com/micro-tools/wf/extend/pb/protobuf"
	"gitee.com/micro-tools/wf/extend/units/tracing"
	"gitee.com/micro-tools/wf/extend/utils/ggrpc"
	"gitee.com/micro-tools/wf/extend/utils/gmicro"
	"gitee.com/micro-tools/wf/extend/utils/gmicro/registry"
	"gitee.com/micro-tools/wf/extend/utils/gmicro/registry/etcd"
	"gitee.com/micro-tools/wf/extend/utils/gmicro/selector"
	"gitee.com/micro-tools/wf/extend/utils/gmicro/selector/cache"
	"gitee.com/micro-tools/wf/extend/utils/gmicro/server"
	"gitee.com/micro-tools/wf/extend/utils/gmicro/service"
	"gitee.com/micro-tools/wf/frame/g"
	"gitee.com/micro-tools/wf/os/gtimer"
	"gitee.com/micro-tools/wf/util/grand"
	"google.golang.org/grpc"
)

var _name = "gmicro-client"

const DefJaegerURL = "172.16.13.6:6831"

func main() {
	flush, err := tracing.InitJaeger(_name, DefJaegerURL)
	if err != nil {
		g.Log().Fatal(err)
	}
	defer flush()
	var micro gmicro.Micro
	micro.Port = grand.N(1000, 2000)
	//rs := consul.NewRegistry(func(options *registry.Options) {
	//	options.Address = []string{"127.0.0.1:8500"}
	//})
	rs := etcd.NewRegistry(func(options *registry.Options) {
		options.Address = []string{"127.0.0.1:2379"}
	})
	micro.Selector = cache.NewSelector(selector.Registry(rs))
	opts := make([]server.Option, 0)
	opt := server.Options{
		Registry:         rs,
		Metadata:         map[string]string{},
		Name:             _name,
		RegisterInterval: time.Second * time.Duration(10),
		RegisterTTL:      time.Second * time.Duration(20),
	}
	opts = append(opts, server.Registry(rs))
	opts = append(opts, server.RegisterInterval(opt.RegisterInterval))
	opts = append(opts, server.RegisterTTL(opt.RegisterTTL))
	opts = append(opts, server.Name(opt.Name))
	opts = append(opts, server.Address(fmt.Sprintf(":%d", micro.Port)))
	sv := server.NewServer(opts...)
	ctx, cancel := context.WithCancel(context.Background())
	sv.OnInit(g.Log())
	micro.Service = service.NewService(
		service.Server(sv),
		service.Tracing(true),
		service.RegisterTTL(sv.Options().RegisterTTL),
		service.RegisterInterval(sv.Options().RegisterInterval),
		service.Context(ctx),
	)
	go func() {
		err := micro.Service.Run()
		if err != nil {
			g.Log().Warningf("service run fail id(%s) error(%s)", micro.Service.Server().ID(), err)
		}
	}()

	gtimer.SetInterval(5*time.Second, func() {
		search(&micro)
	})
	// close
	c := make(chan os.Signal, 1)
	signal.Notify(c, os.Interrupt, os.Kill, syscall.SIGTERM)
	sig := <-c
	//如果一分钟都关不了则强制关闭
	timeout := time.NewTimer(60 * time.Second)
	wait := make(chan struct{})
	go func() {
		cancel()
		sv.OnDestroy()
		time.Sleep(time.Second)
		wait <- struct{}{}
	}()
	select {
	case <-timeout.C:
		g.Log().Panic(fmt.Sprintf("%s close timeout (signal: %s)", _name, sig))
	case <-wait:
		g.Log().Infof("micro closing down (signal: %s)", sig)
	}
}

func search(micro *gmicro.Micro) {
	next, err := micro.Selector.Select("gmicro-server")
	if err != nil {
		return
	}
	node, err := next()
	if err != nil {
		return
	}
	cli := ggrpc.Client{
		Name: _name,
		Config: ggrpc.ClientConfig{
			Address:   fmt.Sprintf("%s:%d", node.Address, node.Port),
			AutoClose: true,
			Timeout:   0,
			Tracing:   true,
		},
		Client: nil,
	}
	err = cli.NewClient(func(conn *grpc.ClientConn, ctx context.Context) (err error) {
		client := pf.NewUserClient(conn)
		insert(ctx, client)
		return nil
	})
	if err != nil {
		g.Log().Error(err.Error())
	}
}

func insert(ctx context.Context, client pf.UserClient) {
	insertRes, err := client.Insert(ctx, &pf.InsertReq{
		Name: "aa",
	})
	if err != nil {
		g.Log().Ctx(ctx).Fatalf(`%+v`, err)
	}
	g.Log().Ctx(ctx).Println("insert:", insertRes.Id)
}