package frame

import (
	"github.com/gin-gonic/gin"
	"net/http"
)

type HandlerFunc = func(permission *Permission, ctx *gin.Context) bool

type IRouter interface {
	Builder(*Group)
	Name() string
}

type Group struct {
	*gin.RouterGroup
	permission       *Permission
	parentPermission *Permission
	code             string
	authCheck        HandlerFunc
	permissions      *[]*TreePermission
}

func (group *Group) GetPermissions() *[]*TreePermission {
	return group.permissions
}

func (group *Group) SetAuthCheck(authCheck HandlerFunc) *Group {
	group.authCheck = authCheck
	return group
}

func (group *Group) Use(middleware ...IMidHandler) *Group {
	for _, v := range middleware {
		group.RouterGroup.Use(MidFactory(v))
	}
	return group
}
func (group *Group) Group(name string, handlers ...interface{}) *Group {
	handl := []gin.HandlerFunc{}
	for _, v := range handlers {
		if h := Convert(v); h != nil {
			handl = append(handl, h)
		}
	}

	newGroup := &Group{permissions: group.permissions, RouterGroup: group.RouterGroup.Group(name, handl...), permission: nil, parentPermission: group.permission, authCheck: group.authCheck}
	return newGroup
}

func (group *Group) Handle(httpMethod, relativePath string, handlers ...interface{}) *Router {
	handl := []gin.HandlerFunc{}
	for _, v := range handlers {
		if h := Convert(v); h != nil {
			handl = append(handl, h)
		}
	}
	if group.parentPermission == nil {
		group.parentPermission = group.permission
	} else {
		if group.parentPermission.Cat == 1 {
			group.parentPermission = group.permission
		}
	}
	r := &Router{permissions: group.permissions, authCheck: group.authCheck, parentPermission: group.parentPermission}
	group.RouterGroup.Handle(httpMethod, relativePath, r.wareFunc(handl)...)
	return r
}

// POST is a shortcut for router.Handle("POST", path, handle).
func (group *Group) POST(relativePath string, handlers ...interface{}) *Router {
	return group.Handle(http.MethodPost, relativePath, handlers...)
}

// GET is a shortcut for router.Handle("GET", path, handle).
func (group *Group) GET(relativePath string, handlers ...interface{}) *Router {

	return group.Handle(http.MethodGet, relativePath, handlers...)
}

type Router struct {
	parentPermission *Permission
	permission       *Permission
	authCheck        HandlerFunc
	permissions      *[]*TreePermission
}

// 权限配置使用
func (this *Router) Permission(cat int, code string, label string) {
	permission := new(Permission)
	permission.add(this.permissions, this.parentPermission, cat, code, label)
	this.permission = &Permission{
		cat,
		code,
		label,
	}
}

// DELETE is a shortcut for router.Handle("DELETE", path, handle).
func (group *Group) DELETE(relativePath string, handlers ...interface{}) *Router {
	return group.Handle(http.MethodDelete, relativePath, handlers...)
}

// PATCH is a shortcut for router.Handle("PATCH", path, handle).
func (group *Group) PATCH(relativePath string, handlers ...interface{}) *Router {
	return group.Handle(http.MethodPatch, relativePath, handlers...)
}

func (group *Router) wareFunc(handlers []gin.HandlerFunc) []gin.HandlerFunc {
	fns := make([]gin.HandlerFunc, 0)
	//这个时候拿到的permission是上一次的
	for _, handler := range handlers {
		fns = append(fns, group.getFunc(handler))
	}
	return fns
}

func (group *Group) Permission(cat int, code string, label string) *Group {
	permission := new(Permission)
	permission.add(group.permissions, group.parentPermission, cat, code, label)
	group.code = code
	group.permission = &Permission{
		cat,
		code,
		label,
	}
	return group
}

// PUT is a shortcut for router.Handle("PUT", path, handle).
func (group *Group) PUT(relativePath string, handlers ...interface{}) *Router {
	return group.Handle(http.MethodPut, relativePath, handlers...)
}

// OPTIONS is a shortcut for router.Handle("OPTIONS", path, handle).
func (group *Group) OPTIONS(relativePath string, handlers ...interface{}) *Router {
	return group.Handle(http.MethodOptions, relativePath, handlers...)
}

// HEAD is a shortcut for router.Handle("HEAD", path, handle).
func (group *Group) HEAD(relativePath string, handlers ...interface{}) *Router {
	return group.Handle(http.MethodHead, relativePath, handlers...)
}

// HEAD is a shortcut for router.Handle("HEAD", path, handle).
func (group *Group) Native() *gin.RouterGroup {
	return group.RouterGroup
}

// Any registers a route that matches all the HTTP methods.
// GET, POST, PUT, PATCH, HEAD, OPTIONS, DELETE, CONNECT, TRACE.
func (group *Group) Any(relativePath string, handlers ...interface{}) *Group {
	group.Handle(http.MethodGet, relativePath, handlers...)
	group.Handle(http.MethodPost, relativePath, handlers...)
	group.Handle(http.MethodPut, relativePath, handlers...)
	group.Handle(http.MethodPatch, relativePath, handlers...)
	group.Handle(http.MethodHead, relativePath, handlers...)
	group.Handle(http.MethodOptions, relativePath, handlers...)
	group.Handle(http.MethodDelete, relativePath, handlers...)
	group.Handle(http.MethodConnect, relativePath, handlers...)
	group.Handle(http.MethodTrace, relativePath, handlers...)
	return group
}

func (group *Router) getFunc(handler gin.HandlerFunc) gin.HandlerFunc {
	fn := func(c *gin.Context) {
		if group.permission != nil {
			if group.authCheck != nil {
				if !group.authCheck(group.permission, c) {
					return
				}
			}
			c.Set("permission", group.permission)
		}
		handler(c)
		//如果没有处理返回自动返回
		body := c.Writer.(*BodyLogWriter).Body
		s := Context{
			Context: c,
		}
		cat := c.Writer.Header().Get("Content-Type")
		if body.String() == "" && cat != "application/octet-stream" {
			s.Ok()
		}
	}
	return fn
}