package ecgo

// 应用全局对象
import (
	"reflect"
	"sync"
)

var (
	app  *Application
	once sync.Once
)

// Application 全局应用对象
type Application struct {
	controllers      map[string]IController
	middlewares      map[string]IMiddleware
	uris             map[string]routeParam
	globalMiddleware []string //全局中间件
	// Config     *Config
	// Log        *Log
}

// App() 生成全局Application对象
func App() *Application {
	once.Do(func() {
		app = &Application{
			controllers: make(map[string]IController),
			middlewares: make(map[string]IMiddleware),
			uris:        make(map[string]routeParam),
		}
		// 添加全局缺省中间件
		app.addGlobalMiddlewware(&entranceMiddleware{})
	})
	return app
}

// 添加路由对象
func (app *Application) addRouter(router IRouter) {
	r := reflect.ValueOf(router)
	r.Elem().FieldByName("Router").Set(reflect.ValueOf(&Router{}))
	router.Handler()
}

// 添加路由路径
func (app *Application) addRouteUri(name string, param routeParam) {
	if _, ok := app.uris[name]; ok {
		panic("路由重复:" + name)
	}
	app.uris[name] = param
}

// 添加控制器
func (app *Application) addController(contr IController) {
	c := reflect.ValueOf(contr)
	c.Elem().FieldByName("Controller").Set(reflect.ValueOf(&Controller{}))
	name := reflect.TypeOf(contr).Elem().Name()
	app.controllers[name] = contr
}

// 添加路由中间件
func (app *Application) addMiddlewware(name string, middleware IMiddleware) {
	mw := reflect.ValueOf(middleware).Elem()
	mw.FieldByName("Middleware").Set(reflect.ValueOf(&Middleware{}))
	app.middlewares[name] = middleware
}

// 添加全局中间件
func (app *Application) addGlobalMiddlewware(middleware IMiddleware) {
	name := reflect.TypeOf(middleware).Elem().Name()
	app.addMiddlewware(name, middleware)
	app.globalMiddleware = append(app.globalMiddleware, name)
}