package framework

import (
	"flag"
	"fmt"
	"gitee.com/kristas/booting-go/framework/bean"
	. "gitee.com/kristas/booting-go/framework/bean/bean_factory"
	"gitee.com/kristas/booting-go/framework/config_loader"
	logRegisters "gitee.com/kristas/booting-go/framework/logging/registers"
	"gitee.com/kristas/booting-go/framework/web"
	"github.com/kataras/iris/v12"
	"github.com/sirupsen/logrus"
	"reflect"
	"strings"
	"sync"
)

var app *BootApplication
var once sync.Once

type BootApplication struct {
	IrisApp    *iris.Application  `bean:"iris_app"`
	Log        *logrus.Logger     `bean:"log"`
	Server     Server             `value:"server"`
	Iris       iris.Configuration `value:"iris"`
	Logging    Logging            `value:"logging"`
	components bean.Components
}

type Server struct {
	Name string `json:"name" yaml:"name"`
	Port int    `json:"port" yaml:"port"`
}

type Logging struct {
	Level string `json:"level" yaml:"level"`
}

var innerBeanRegisters = []func(){
	web.RegisterIrisApp,
	logRegisters.RegisterDefaultLogger,
}

func registerInnerBeans() {
	for i := range innerBeanRegisters {
		innerBeanRegisters[i]()
	}
}

var (
	environment string
	p string
)

func initFlag() {
	flag.StringVar(&environment,"env","local","local,dev,test,prod...")
	flag.StringVar(&p,"p","8080","the port your server listen at.")
	flag.Parse()
}

func Application() *BootApplication {
	once.Do(func() {
		initFlag()
		config_loader.DefaultLocalConfigReader(environment)
		app = new(BootApplication)
		config_loader.InjectStructure(app)
		registerInnerBeans()
		Autowired(app)
	})
	return app
}

func (r *BootApplication) Run(args ...string) {
	r.Log.WithField("env",environment).Info("environment")
	r.useComponent()
	r.Log.Fatal(
		app.IrisApp.Listen(
			fmt.Sprintf(":%d", app.Server.Port),
			iris.WithConfiguration(app.Iris),
		),
	)
}

func (r *BootApplication) Use(c ...bean.Bean) *BootApplication {
	r.components = append(r.components, c...)
	return r
}

var beanInitQueue = []func(b ...bean.Bean){
	registerComponents,
	injectValue,
	factoryBeanCreated,
	injectComponents,
	initComponents,
	callControllerMethod,
}

func (r *BootApplication) useComponent() {
	for i := range beanInitQueue {
		beanInitQueue[i](r.components...)
	}
}

func registerComponents(b ...bean.Bean) {
	for i := range b {
		beanPtr := b[i]
		beanName := beanPtr.Bean()
		if beanName == "" {
			Register(beanPtr)
		} else {
			RegisterWithName(beanName, beanPtr)
		}
	}
}

func injectValue(b ...bean.Bean) {
	for i := range b {
		config_loader.InjectStructure(b[i])
	}
}

func factoryBeanCreated(b ...bean.Bean) {
	for i := range b {
		beanPtr := b[i]
		v := reflect.ValueOf(beanPtr)
		handleMethod := v.MethodByName("AfterPropertiesSet")
		if handleMethod.IsValid() {
			handleMethod.Call(nil)
		}
	}
}

func injectComponents(b ...bean.Bean) {
	for i := range b {
		beanPtr := b[i]
		Autowired(beanPtr)
	}
}

func initComponents(b ...bean.Bean) {
	for i := range b {
		beanPtr := b[i]
		v := reflect.ValueOf(beanPtr)
		handleMethod := v.MethodByName("Init")
		if handleMethod.IsValid() {
			handleMethod.Call(nil)
		}
	}
}

func callControllerMethod(b ...bean.Bean) {
	for i := range b {
		beanPtr := b[i]
		var beanName string
		if beanName = beanPtr.Bean(); beanName == "" {
			beanName = reflect.TypeOf(beanPtr).Elem().String()
		}
		if isController(beanName) {
			handleControllerMethod(beanPtr)
		}
	}
}

func isController(beanName string) bool {
	return strings.Contains(strings.ToLower(beanName), "controller")
}

func handleControllerMethod(b bean.Bean) {
	v := reflect.ValueOf(b)
	for i := 0; i < v.NumMethod(); i++ {
		method := v.Method(i)
		if method.IsValid() {
			method.Call(nil)
		}
	}
}