type Engine struct {
}

//通过 Default() 我们可以创建一个默认的 http 服务器
func Default() *Engine {
	engine := New()
	return engine
}

func New() *Engine {
	engine := &Engine{}
	return engine
}

//为了能够让 Engine 作为服务器运行起来，我们需要让它实现 Handler 接口，也就是实现 ServeHTTP 方法
//将来我们会在这个方法中编写框架处理请求的逻辑
func (engine *Engine) ServeHTTP(w http.ResponseWriter, req *http.Request) {
	w.Write([]byte("hello"))
}

//封装了http.ListenAndServe，如果用户没有给出端口，我们就用8080作为默认端口
func (engine *Engine) Run(addr ...string) error {
	address := resolveAddress(addr)
	return http.ListenAndServe(address, engine)
}

为了能够让 Engine 作为服务器运行起来，我们需要让它实现 Handler 接口，也就是实现 ServeHTTP 方法，将来我们会在这个方法中编写框架处理请求的逻辑。

同时我们提供了一个启动框架的 Run 方法，里面封装了http.ListenAndServe，如果用户没有给出端口，我们就用8080作为默认端口。

下面我们完善处理请求的部分，我们要提供一些方法，让用户可以把请求处理器注册到框架中。

如果你看了文章的开头部分，应该会记得 go 内置的 http 服务器是通过一个 map 映射表记录这些请求处理器的。这么做能够完成静态路由的功能，但是无法完成动态路由的功能。想要完成动态路由，通常都会用前缀树实现。

我本来想只是简单地借用原生的请求处理器完成静态路由，但是发现原生的处理器有个地方设计得比较简洁，就是我们在注册请求处理方法的时候不需要指定这个请求是 POST 请求还是 GET 请求。

虽然理论上来说我们只要在开发的时候明白这是一个 POST 或是 GET 请求就行，但是为了代码的可读性以及规范性，我想还是对 GET / POST 请求做一下标记比较好。

所以我打算重新实现这个请求处理器，一来是添加上 GET / POST 请求标识，二来为了以后扩展成动态路由作准备（gin 框架也是重新实现了路由部分，而且自己实现了动态路由）。

实现原理和原生的一样，用一个映射表保存请求路径和请求处理器，只不过在路径前面增加一个 GET / POST 标识。（原生的静态路由实现要健壮很多，不过这不是本文的重点了）

增加和修改的部分如下：

//对请求处理环节，我们使用一个映射表进行匹配，完成最简单的静态路由
func (engine *Engine) ServeHTTP(w http.ResponseWriter, req *http.Request) {
	key := req.Method + "-" + req.RequestURI
	if handler, ok := engine.router[key]; ok {
		handler(w, req)
	} else {
		http.NotFound(w, req)
	}
}

//添加路由的方法
func (engine *Engine) addRouter(method string, pattern string, handlerFunc http.HandlerFunc) {
	if engine.router == nil {
		engine.router = make(map[string]http.HandlerFunc)
	}
	key := method + "-" + pattern
	engine.router[key] = handlerFunc
}

func (engine *Engine) Get(pattern string, handlerFunc http.HandlerFunc) {
	engine.addRouter("GET", pattern, handlerFunc)
}

func (engine *Engine) Post(pattern string, handlerFunc http.HandlerFunc) {
	engine.addRouter("Post", pattern, handlerFunc)
}

func main() {
	engine := jun.Default()
	engine.Get("/hello", func(w http.ResponseWriter, req *http.Request) {
		w.Write([]byte("hello!"))
	})
	engine.Run()
}

type RouterGroup struct {
	basePath string
}

type RouterGroup struct {
	basePath string
	engine   *Engine
}

type Engine struct {
	RouterGroup
	router map[string]http.HandlerFunc
}

//多了一层 RouterGroup 封装
func (group *RouterGroup) addRouter(method string, pattern string, handlerFunc http.HandlerFunc) {
	if group.engine.router == nil {
		group.engine.router = make(map[string]http.HandlerFunc)
	}
	pattern = group.basePath + pattern
	key := method + "-" + pattern
	group.engine.router[key] = handlerFunc
}

func (group *RouterGroup) Get(pattern string, handlerFunc http.HandlerFunc) {
	group.addRouter("GET", pattern, handlerFunc)
}

func (group *RouterGroup) Post(pattern string, handlerFunc http.HandlerFunc) {
	group.addRouter("POST", pattern, handlerFunc)
}

func New() *Engine {
	engine := &Engine{
		RouterGroup: RouterGroup{
			basePath: "",
		},
	}
	engine.RouterGroup.engine = engine
	return engine
}

func (group *RouterGroup) Group(relativePath string) *RouterGroup {
	return &RouterGroup{
		basePath: relativePath,
		engine:   group.engine,
	}
}

func main() {
	router := jun.Default()
	userGroup := router.Group("/user")

	userGroup.Post("/login", func(w http.ResponseWriter, req *http.Request) {
		w.Write([]byte("login successfully!"))
	})

	userGroup.Post("/logout", func(w http.ResponseWriter, req *http.Request) {
		w.Write([]byte("logout successfully!"))
	})

	router.Run()
}

func func1(w http.ResponseWriter, req *http.Request) {
		w.WriteHeader(http.StatusOK)
		w.Header().Set("Content-Type", "application/json")
		encoder := json.NewEncoder(w)

		message := map[string]interface{}{
			"message": "pong",
		}
		if err := encoder.Encode(message); err != nil {
			http.Error(w, err.Error(), 500)
		}
}

func func2(c *gin.Context) {
	c.JSON(200, gin.H{
		"message": "pong",
	})
}

//用 H 来封装这个用于转换为 json 的 map，减少代码量
type H map[string]interface{}

type Context struct {
	Writer  http.ResponseWriter
	Request *http.Request
	engine  *Engine
}

//新建一个 Context
func newContext(w http.ResponseWriter, req *http.Request) *Context {
	return &Context{
		Writer:  w,
		Request: req,
	}
}

//封装的响应 JSON 的方法
func (c *Context) JSON(code int, obj interface{}) {
	c.Writer.WriteHeader(code)
	c.Writer.Header().Set("Content-Type", "application/json")

	encoder := json.NewEncoder(c.Writer)
	if err := encoder.Encode(obj); err != nil {
		http.Error(c.Writer, err.Error(), http.StatusInternalServerError)
	}
}

//我们还可以封装一系列方法，比如获取参数，响应 html 等等······

func (engine *Engine) ServeHTTP(w http.ResponseWriter, req *http.Request) {
	context := newContext(w, req)
	context.engine = engine

	key := req.Method + "-" + req.RequestURI
	if handler, ok := engine.router[key]; ok {
		handler(context)
	} else {
		http.NotFound(w, req)
	}
}

//自己定义一个 HandlerFunc
type HandlerFunc func(*Context)

func (group *RouterGroup) Get(pattern string, handlerFunc HandlerFunc) {
	group.addRouter("GET", pattern, handlerFunc)
}

//······

func main() {
	router := jun.Default()

	router.Get("/ping", func(c *jun.Context) {
		c.JSON(http.StatusOK, jun.H{
			"message": "pong",
		})
	})

	router.Run()
}

type Context struct {
	Writer  http.ResponseWriter
	Request *http.Request
	engine  *Engine

    //这次请求需要被哪些中间件处理
	handlers []HandlerFunc
	//这是一个用于依次调用中间件的值
	index    int
}

//这个是整个责任链的核心方法，每当这个方法被调用，就执行下一个中间件函数
func (c *Context) Next() {
	c.index++
	for c.index < len(c.handlers) {
	    //执行下一个中间件函数
		c.handlers[c.index](c)
		c.index++
	}
}

type RouterGroup struct {
	basePath string
	engine   *Engine
	//存放分组需要执行的中间件
	Handlers []HandlerFunc
}

func (group *RouterGroup) Use(middlewares ...HandlerFunc) *RouterGroup {
	group.Handlers = append(group.Handlers, middlewares...)
	return group
}

func (engine *Engine) ServeHTTP(w http.ResponseWriter, req *http.Request) {
	context := newContext(w, req)
	context.engine = engine

	// 根据路径判断这个请求属于哪个组，然后获取这个组上安装的中间件，把这些中间件放到上下文中
	for _, group := range engine.groups {
		if strings.HasPrefix(req.URL.Path, group.basePath) {
			context.handlers = append(context.handlers, group.Handlers...)
		}
	}

	// 把请求处理器也作为“中间件”放到上下文中
	key := req.Method + "-" + req.RequestURI
	if handler, ok := engine.router[key]; ok {
		context.handlers = append(context.handlers, handler)
	} else {
		context.handlers = append(context.handlers, func(context *Context) {
			http.Error(context.Writer, "404 page not found", http.StatusNotFound)
		})
	}

	//处理请求！
	context.Next()
}

func main() {
	router := jun.Default()
	
	//添加中间件
	router.Use(Timer)

	router.Get("/ping", func(c *jun.Context) {
		c.JSON(http.StatusOK, jun.H{
			"message": "pong",
		})
	})

	router.Run()
}

func Timer(c *jun.Context) {
	t := time.Now()
	c.Next()
	log.Printf("use time: %v\n", time.Since(t))
}

// Default returns an Engine instance with the Logger and Recovery middleware already attached.
func Default() *Engine {
	debugPrintWARNINGDefault()
	engine := New()
	engine.Use(Logger(), Recovery())
	return engine
}