package main

import (
	"encoding/json"
	"fmt"
	"github.com/gin-gonic/gin"
	"reflect"
	"time"
)

func main() {
	route := gin.Default()
	route.POST("user", ginHandlerWrapper(userHandler, 4))
	route.Run(":8080")
}

//-------------------------------------
// 业务逻辑包装函数
// f是一个函数，是真正的处理业务逻辑的handler
// mode代表入参的信息，我们约定入参的第一个参数是*gin.Context，后面最多有三个参数，按照约定的顺序分别是body，query和header
// mode最后三位如果是1就表示有一个对应入参，否则没有，例如mode=0x101，则表示handler函数是f(*gin.Context, *bodyStruct{}, *headerStruct{})
// 返回值我们约定是(data interface{}, err error)
// 这样处理的好处是：
// 1. 我们可以统一的处理参数校验，返回的数据封装，返回的错误处理
// 2. 一定程度的自由定义handler函数，handler函数的入参都是真正要处理的业务参数，e.g. body，使其进一步和gin解耦，不依赖gin的context；这一点我是参考spring mvc中controller的设计
func ginHandlerWrapper(f interface{}, mode uint8) (hf gin.HandlerFunc) {
	ft := reflect.TypeOf(f)
	if ft.Kind() != reflect.Func {
		panic("not func")
	}
	in := make([]*inParamsInfo, 0)
	var j uint8 = 4
	index := 1 // 第一个参数默认是context
	for i := 0; i < 3; i++ {
		if mode&j == j {
			pt := ft.In(index)
			pt = pt.Elem()
			param := reflect.New(pt).Interface()
			in = append(in, &inParamsInfo{
				typ:   info[i],
				value: param,
			})
			index++
		}
		j = j >> 1
	}

	fv := reflect.ValueOf(f)
	hf = func(cxt *gin.Context) {
		inParams := make([]reflect.Value, 0)
		inParams = append(inParams, reflect.ValueOf(cxt))
		var e error
		for _, pi := range in {
			switch pi.typ {
			case body: // body
				e = cxt.BindJSON(pi.value)
			case query: // query
				e = cxt.BindQuery(pi.value)
			case header: // header
				e = cxt.BindHeader(pi.value)
			}
			if e != nil {
				cxt.JSON(400, "invalid params")
				return
			}
			inParams = append(inParams, reflect.ValueOf(pi.value))
		}
		results := fv.Call(inParams)
		if results[1].Interface() != nil {
			cxt.JSON(500, "internal error")
			return
		}
		cxt.JSON(200, &CommonResponse{
			Code:      0,
			Info:      "",
			Data:      results[0].Interface(),
			Timestamp: time.Now().Unix(),
		})
	}
	return
}

const (
	body uint8 = iota
	query
	header
)

// 入参顺序
var info = []uint8{body, query, header}

type inParamsInfo struct {
	typ   uint8 // 入参类型
	value interface{}
}
// 统一返回
type CommonResponse struct {
	Code      int
	Info      string
	Data      interface{}
	Timestamp int64
}

//-------------------------------------------------
// 处理业务逻辑的handler
type user struct {
	Name string `json:"name" binding:"required,min=6,max=20"`
	Age  int    `json:"age" binding:"required"`
}

func userHandler(cxt *gin.Context, u *user) (data interface{}, err error) {
	bs, _ := json.Marshal(u)
	fmt.Printf("user: %s\n", bs)
	data = &user{
		Name: u.Name + "!!!",
		Age:  u.Age + 1,
	}
	return
}