package micro

import (
	"context"
	"fmt"
	"gitee.com/micro-tools/micro/module"
	"gitee.com/micro-tools/micro/module/base"
	"gitee.com/micro-tools/wf/extend/units/tracing"
	"gitee.com/micro-tools/wf/extend/utils/gmicro/registry"
	"gitee.com/micro-tools/wf/extend/utils/gmicro/selector"
	"gitee.com/micro-tools/wf/extend/utils/gmicro/selector/cache"
	"gitee.com/micro-tools/wf/frame/g"
	"gitee.com/micro-tools/wf/os/glog"
	"github.com/sony/sonyflake"
	"google.golang.org/grpc"
	"os"
	"os/signal"
	"sync"
	"syscall"
	"time"
)

const NAME = "wu-micro"
const AUTHORS = "shenghao.xu"
const VERSION = "v0.3.2"

// DefaultApp 默认应用
type DefaultApp struct {
	serverList sync.Map
	opts       module.Options
	sf         *sonyflake.Sonyflake
}

func (d *DefaultApp) Run(mods ...module.Module) error {
	if d.opts.Tracing.Status {
		flush, err := tracing.InitJaeger(d.opts.Tracing.Name, d.opts.Tracing.URL)
		if err != nil {
			g.Log().Fatal(err)
		}
		defer flush()
	}
	d.opts.Log = NewLogger(d.opts.Debug)
	d.opts.Log.Infof("%s %s %s starting up", NAME, AUTHORS, d.opts.Version)
	manager := base.NewModuleManager()
	for i := 0; i < len(mods); i++ {
		manager.Register(mods[i], d.opts.Log)
	}
	manager.Init(d)

	go func(version string) {
		time.Sleep(100 * time.Millisecond)
		d.opts.Log.Infof("%s %s %s started", NAME, AUTHORS, version)
	}(d.opts.Version)

	// close
	c := make(chan os.Signal, 1)
	signal.Notify(c, os.Interrupt, os.Kill, syscall.SIGTERM)
	sig := <-c
	//如果一分钟都关不了则强制关闭
	timeout := time.NewTimer(d.opts.KillWaitTTL)
	wait := make(chan struct{})
	go func() {
		if d.Options().RegistryEnable {
			manager.Destroy()
		}
		_ = d.OnDestroy()
		wait <- struct{}{}
	}()
	select {
	case <-timeout.C:
		d.opts.Log.Panic(fmt.Sprintf("%s close timeout (signal: %s)", NAME, sig))
	case <-wait:
		d.opts.Log.Infof("micro closing down (signal: %s)", sig)
	}
	return nil
}

func Create(opts ...module.Option) module.App {
	return newApp(opts...)
}

func (d *DefaultApp) Options() module.Options {
	return d.opts
}

func (d *DefaultApp) Registry() registry.Registry {
	return d.opts.Registry
}

func (d *DefaultApp) OnDestroy() error {

	return nil
}

func NewLogger(debug bool) *glog.Logger {
	lg := glog.DefaultLogger()
	if debug == true {
		lg.SetLevel(glog.LEVEL_DEV)
	} else {
		lg.SetLevel(glog.LEVEL_ALL ^ glog.LEVEL_DEBU)
	}
	lg.SetAsync(true)
	lg.SetFlags(glog.F_TIME_STD | glog.F_FILE_SHORT)
	return lg
}

func (d *DefaultApp) Logger() *glog.Logger {
	return d.opts.Log
}

// GetServerBySelector 获取服务实例,可设置选择器
func (d *DefaultApp) GetServerBySelector(serviceName string) (module.ServerSession, error) {
	next, err := d.opts.Selector.Select(serviceName)
	if err != nil {
		return nil, err
	}
	node, err := next()
	if err != nil {
		return nil, err
	}
	session, ok := d.serverList.Load(node.Id)
	if !ok {
		s, err := base.NewServerSession(d, serviceName, node)
		if err != nil {
			return nil, err
		}
		d.serverList.Store(node.Id, s)
		return s, nil
	}
	err = session.(module.ServerSession).SetNode(node)
	if err != nil {
		return nil, err
	}
	return session.(module.ServerSession), nil
}

// GetRouteServer 通过选择器过滤服务实例
func (d *DefaultApp) GetRouteServer(filter string) (s module.ServerSession, err error) {
	moduleType := filter
	return d.GetServerBySelector(moduleType)
}

func (d *DefaultApp) Call(ctx context.Context, serviceName string, fnc func(context.Context, *grpc.ClientConn) error) error {
	server, err := d.GetRouteServer(serviceName)
	if err != nil {
		return err
	}
	client := server.GetClient()
	if client != nil {
		var cancel context.CancelFunc
		_, ok := ctx.Deadline()
		if !ok {
			ctx, cancel = context.WithTimeout(ctx, time.Second*10)
			defer cancel()
		}
		if err = fnc(ctx, client); err != nil {
			return err
		}
	}
	return nil
}

func newApp(opts ...module.Option) module.App {
	options := newOptions(opts...)
	app := new(DefaultApp)
	app.opts = options
	return app
}

func newOptions(opts ...module.Option) module.Options {
	opt := module.Options{
		Version:          VERSION,
		RegisterInterval: time.Second * time.Duration(10),
		RegisterTTL:      time.Second * time.Duration(20),
		KillWaitTTL:      time.Second * time.Duration(60),
		RPCExpired:       time.Second * time.Duration(10),
		Debug:            true,
		RegistryEnable:   true,
	}
	for _, o := range opts {
		o(&opt)
	}
	if opt.Registry != nil {
		opt.Selector = cache.NewSelector(selector.Registry(opt.Registry))
	}
	return opt
}