package common

// default setting:
//   Transport: grpc
//   Server: grpc
//   Client: grpc
//   RegisterTTL: 30s
//   RegisterInterval: 20s
//   Registry: etcd
//   broker: rabbitmq
//   Selector: cache
//   Codec: protobuf
//   Tracing: jaeger
//   Metrics: jaeger
//   breaker: hystrix 注：客户端熔断
//   ratelimit: uber/ratelimit

import (
	"fmt"
	"github.com/micro/cli"
	"log"
	"time"
	"shop-common/config"

	//gh "github.com/afex/hystrix-go/hystrix"
	"github.com/micro/go-micro"
	"github.com/micro/go-micro/registry"
	"github.com/micro/go-micro/web"
	"github.com/micro/go-plugins/registry/etcdv3"
	"github.com/micro/go-plugins/wrapper/breaker/hystrix"
	"github.com/micro/go-micro/broker"
	"github.com/micro/go-plugins/broker/rabbitmq"
	ratelimit "github.com/micro/go-plugins/wrapper/ratelimiter/uber"
	"github.com/micro/go-plugins/wrapper/trace/opentracing"
)

var (
	defaultOpts    []micro.Option
	defaultWebOpts []web.Option
	defaultServer  micro.Option
	defaultClient  micro.Option
)

func init() {
	defaultOpts = []micro.Option{
		micro.RegisterTTL(time.Second * 30),
		micro.RegisterInterval(time.Second * 20),
		//micro.Transport(http.NewTransport()),
	}
	defaultWebOpts = []web.Option{
		web.RegisterTTL(time.Second * 30),
		web.RegisterInterval(time.Second * 20),
	}
	//gh.DefaultMaxConcurrent = 100
	//gh.DefaultVolumeThreshold = 50
}

func GetMicroClient(serviceName string, exOpts ...micro.Option) micro.Service {
	opts := getOpts(serviceName)
	if defaultClient != nil {
		opts = append(opts, defaultClient)
	}
	t, _, err := NewJaegerTracer(serviceName, config.TracingConf.Addr)
	if err != nil {
		log.Fatalf("opentracing tracer create error:%v", err)
	}
	opts = append(opts,
		micro.WrapClient(hystrix.NewClientWrapper(), //客户端熔断
		opentracing.NewClientWrapper(t), //链路追踪
		ratelimit.NewClientWrapper(1024))) //限流
	opts = append(opts, exOpts...)

	srv := micro.NewService(opts...)

	srv.Init()
	return srv
}

func GetMicroServer(service string, exOpts ...micro.Option) micro.Service {
	opts := getOpts(service)
	fmt.Println("config.BrokerConf.Addrs:", config.BrokerConf.Addrs)
	brokermq := rabbitmq.NewBroker(func(options *broker.Options) {
		options.Addrs = config.BrokerConf.Addrs
	})
	if err := brokermq.Connect(); err != nil {
		log.Fatalf("broker Connect error: %v", err)
	}
	t, _, err := NewJaegerTracer(service, config.TracingConf.Addr)
	if err != nil {
		log.Fatalf("opentracing tracer create error:%v", err)
	}
	opts = append(opts, micro.Broker(brokermq))
	opts = append(opts,
		micro.WrapHandler(opentracing.NewHandlerWrapper(t),//链路追踪
		ratelimit.NewHandlerWrapper(1024))) //限流
	opts = append(opts, exOpts...)

	srv := micro.NewService(opts...)
	srv.Init()
	return srv
}

func getOpts(serviceName string) []micro.Option {
	opts := append([]micro.Option{},
		defaultOpts...,
	)
	version := config.ServiceConf.Version
	if version == "" {
		version = "latest"
	}
	opts = append(opts, micro.Version(version), micro.Name(serviceName))

	reg := etcdv3.NewRegistry(func(op *registry.Options) {
		op.Addrs = config.RegistryConf.Addrs
	})
	opts = append(opts, micro.Registry(reg))

	return opts
}

func GetMicroWeb(serviceName string, exOpts ...web.Option) web.Service {
	opts := append(exOpts,
		defaultWebOpts...,
	)
	version := config.ServiceConf.Version
	if version == "" {
		version = "latest"
	}
	opts = append(opts, web.Version(version), web.Name(serviceName), web.Action(func(ctx *cli.Context) {
		
	}))

	opts = append(opts, web.Registry(etcdv3.NewRegistry(func(op *registry.Options) {
		op.Addrs = config.RegistryConf.Addrs
	})))

	srv := web.NewService(opts...)
	srv.Init()
	return srv
}