package router

import (
	"reflect"

	ctxpkg "github.com/noahlann/nnet/pkg/context"
	"github.com/noahlann/nnet/pkg/router"
)

// route 路由实现
type route struct {
	matcher      router.Matcher
	handler      router.Handler
	middlewares  []router.Handler
	requestType  reflect.Type
	responseType reflect.Type
	codecName    string
}

// newRoute 创建新路由
func newRoute(matcher router.Matcher, handler router.Handler, config *router.RouteConfig) *route {
	r := &route{
		matcher:      matcher,
		handler:      handler,
		middlewares:  make([]router.Handler, 0),
		requestType:  nil,
		responseType: nil,
		codecName:    "",
	}

	if config != nil {
		r.requestType = config.RequestType
		r.responseType = config.ResponseType
		r.codecName = config.CodecName
	}

	return r
}

// Use 添加中间件
func (r *route) Use(middleware ...router.Handler) router.Route {
	r.middlewares = append(r.middlewares, middleware...)
	return r
}

// Handler 获取处理器
func (r *route) Handler() router.Handler {
	return r.buildHandler()
}

// RequestType 获取请求类型
func (r *route) RequestType() reflect.Type {
	return r.requestType
}

// ResponseType 获取响应类型
func (r *route) ResponseType() reflect.Type {
	return r.responseType
}

// CodecName 获取编解码器名称
func (r *route) CodecName() string {
	return r.codecName
}

// buildHandler 构建处理器链
func (r *route) buildHandler() router.Handler {
	return func(ctx ctxpkg.Context) error {
		// 执行中间件
		for _, middleware := range r.middlewares {
			if err := middleware(ctx); err != nil {
				return err
			}
		}
		// 执行处理器
		return r.handler(ctx)
	}
}