package httpserver

import (
	"fmt"
	"log/slog"
	"net/http"
	"path"
	"strings"
)

// RouteGroup 定义路由组的数据结构
type RouteGroup struct {
	// 路由组名
	prefix string
	// 路由组所属引擎
	server *HttpServer
	// 路由组所支持的中间件
	middlewares []HandleFunc
	// 路由组的静态文件处理中间件
	staticMiddleware HandleFunc
}

// NewRouteGroup 新建一个路由组
func (own *RouteGroup) NewGroup(prefix string) *RouteGroup {
	group := &RouteGroup{
		prefix:      own.prefix + prefix, // 新路由组名，在上一个路由组名的基础上追加
		server:      own.server,
		middlewares: make([]HandleFunc, 0),
	}
	own.server.groups = append(own.server.groups, group)
	return group
}

// AddMiddlewares 添加中间件到当前路由组
func (own *RouteGroup) AddMiddlewares(middlewares ...HandleFunc) {
	own.middlewares = append(own.middlewares, middlewares...)
}

// GET 添加GET请求路由到当前路由组
func (own *RouteGroup) GET(part string, handler HandleFunc) {
	own.addRoute(http.MethodGet, part, handler)
}

// POST 添加POST请求路由到当前路由组
func (own *RouteGroup) POST(part string, handler HandleFunc) {
	own.addRoute(http.MethodPost, part, handler)
}

// PUT 添加PUT请求路由到当前路由组
func (own *RouteGroup) PUT(part string, handler HandleFunc) {
	own.addRoute(http.MethodPut, part, handler)
}

// DELETE 添加DELETE请求路由到当前路由组
func (own *RouteGroup) DELETE(part string, handler HandleFunc) {
	own.addRoute(http.MethodDelete, part, handler)
}

// OPTIONS 添加DELETE请求路由到当前路由组
func (own *RouteGroup) OPTIONS(part string, handler HandleFunc) {
	own.addRoute(http.MethodOptions, part, handler)
}

func (own *RouteGroup) addRoute(method string, part string, handler HandleFunc) {
	own.server.router.addRoute(method, own.prefix+part, handler)
}

// SetStatic 设置静态文件服务路由
func (own *RouteGroup) SetStatic(part string, root string) {
	fs := http.Dir(root)
	absolutePath := path.Join(own.prefix, part)
	fileServer := http.StripPrefix(absolutePath, http.FileServer(fs))
	const method = http.MethodGet

	if own.staticMiddleware == nil {
		slog.Info(fmt.Sprintf("Add file route success: %s - %s", method, absolutePath))
	} else {
		slog.Error(fmt.Sprintf("Add file route failed:  %s - %s already exist", method, absolutePath))
	}

	own.staticMiddleware = func(ctx *Context) {
		if ctx.Method != method {
			ctx.ResponseErrorString(http.StatusMethodNotAllowed, ERR_METHOD_NOT_ALLOWED)
			return
		}

		paths := strings.Split(ctx.Path, absolutePath)
		if len(paths) != 2 {
			ctx.ResponseErrorString(http.StatusNotFound, ERR_NOT_FOUND)
			return
		}
		if _, err := fs.Open(paths[1]); err != nil {
			slog.Error(err.Error())
			ctx.ResponseErrorString(http.StatusNotFound, ERR_NOT_FOUND)
			return
		}

		ctx.StatusCode = http.StatusOK
		fileServer.ServeHTTP(ctx.Response, ctx.Request)
	}
}