package tower

import (
	"net/http"
)

type Group struct {
	prefix           string
	parent           *Tower
	groupMiddlewares []Middleware
}

func (g *Group) Use(groupMiddlewares ...Middleware) {
	g.groupMiddlewares = append(g.groupMiddlewares, groupMiddlewares...)
}

func (g *Group) Group(prefix string, mws ...Middleware) *Group {
	child := &Group{
		parent: g.parent,
		prefix: g.buildFullPath(prefix),
	}

	child.groupMiddlewares = make([]Middleware, 0, len(g.groupMiddlewares)+len(mws))
	child.groupMiddlewares = append(child.groupMiddlewares, g.groupMiddlewares...)
	child.groupMiddlewares = append(child.groupMiddlewares, mws...)

	return child
}

func (g *Group) Static(prefix, dir string) {
	if prefix == "" || prefix[0] != '/' {
		prefix = "/" + prefix
	}

	if prefix[len(prefix)-1] == '/' {
		prefix = prefix[:len(prefix)-1]
	}
	prefix += "/*filepath"

	g.parent.router.ServeFiles(g.buildFullPath(prefix), http.Dir(dir))
}

func (g *Group) GET(path string, h Handler, routeMiddlewares ...Middleware) {
	g.Handle(http.MethodGet, path, h, routeMiddlewares...)
}

func (g *Group) POST(path string, h Handler, routeMiddlewares ...Middleware) {
	g.Handle(http.MethodPost, path, h, routeMiddlewares...)
}

func (g *Group) PUT(path string, h Handler, routeMiddlewares ...Middleware) {
	g.Handle(http.MethodPut, path, h, routeMiddlewares...)
}

func (g *Group) PATCH(path string, h Handler, routeMiddlewares ...Middleware) {
	g.Handle(http.MethodPatch, path, h, routeMiddlewares...)
}

func (g *Group) DELETE(path string, h Handler, routeMiddlewares ...Middleware) {
	g.Handle(http.MethodDelete, path, h, routeMiddlewares...)
}

func (g *Group) Handle(method string, path string, h Handler, routeMiddlewares ...Middleware) {
	fullPath := g.buildFullPath(path)

	mws := make([]Middleware, 0, len(g.groupMiddlewares)+len(routeMiddlewares))
	mws = append(mws, g.groupMiddlewares...)
	mws = append(mws, routeMiddlewares...)

	g.parent.Handle(method, fullPath, h, mws...)
}

func (g *Group) buildFullPath(path string) string {
	normalizedPrefix := normalizePath(g.prefix)
	normalizedPath := normalizePath(path)

	if normalizedPrefix == "/" && normalizedPath == "/" {
		return "/"
	}

	return normalizePath(g.prefix) + normalizePath(path)
}