wrapper.go

// Copyright 2014 Manu Martinez-Almeida.  All rights reserved.
// Use of this source code is governed by a MIT style
// license that can be found in the LICENSE file.

package pine

import (
	"encoding/json"
	"fmt"
	"net/http"
	"reflect"
	"strings"
	"sync"
	"unsafe"

	"github.com/xiusin/pine/di"
)

// IRouterWrapper 路由包装器接口, 用于控制器方法映射到路由.
type IRouterWrapper interface {
	warpHandler(string, IController) Handler

	ANY(path string, handle string, mws ...Handler)
	GET(path string, handle string, mws ...Handler)
	POST(path string, handle string, mws ...Handler)
	PUT(path string, handle string, mws ...Handler)
	HEAD(path string, handle string, mws ...Handler)
	DELETE(path string, handle string, mws ...Handler)
}

// routerWrapper 控制器映射路由包装器.
type routerWrapper struct {
	sync.Mutex
	reflectMethod map[string][]reflect.Value
	share         *sync.Map
	hasShareField bool
	router        AbstractRouter
	controller    IController
}

func newRouterWrapper(router AbstractRouter, controller IController) *routerWrapper {
	return &routerWrapper{
		share:         &sync.Map{},
		reflectMethod: make(map[string][]reflect.Value),
		router:        router,
		controller:    controller,
	}
}

// warpHandler 用于包装 controller 方法为 Handler.
// 通过反射传入 controller 实例用于每次请求构建或新的实例.
func (cmr *routerWrapper) warpHandler(method string, controller IController) Handler {
	rvCtrl, rtCtrl := reflect.ValueOf(controller), reflect.TypeOf(controller)

	fieldNum := rvCtrl.Elem().NumField()
	for i := 0; i < fieldNum; i++ {
		field := rtCtrl.Elem().Field(i)
		if strings.HasPrefix(field.Name, "Share") && rvCtrl.Elem().Field(i).CanAddr() {
			if rvCtrl.Elem().Field(i).IsNil() {
				func() {
					defer func() {
						if err := recover(); err != nil {
							Logger().Warn("reflect", field.Name, "failed", "reason: ", err)
						}
					}()
					// 自动构建指针对应的类型
					autoConstructValue := reflect.New(rtCtrl.Elem().Field(i).Type.Elem())
					rvCtrl.Elem().Field(i).Set(autoConstructValue)
					cmr.share.Store(field.Name, rvCtrl.Elem().Field(i))
				}()
			}
			cmr.share.Store(field.Name, rvCtrl.Elem().Field(i))
			cmr.hasShareField = true
		}
	}
	return func(context *Context) {
		// 使用反射类型构建一个新的控制器实例
		c := reflect.New(rvCtrl.Elem().Type())
		rf := reflect.Indirect(c).FieldByName("context")
		ptr := unsafe.Pointer(rf.UnsafeAddr())
		*(**Context)(ptr) = context
		cmr.result(c, rvCtrl.Elem().Type().Name(), method)
	}
}

// result 处理控制器方法返回值.
// c 是控制器一个反射值, ctrlName 控制器名称, method 方法名称.
func (cmr *routerWrapper) result(c reflect.Value, ctrlName, method string) {
	var err error
	var ins []reflect.Value
	// 转换为 context 实体实例
	ctx := c.MethodByName("Ctx").Call(nil)[0].Interface().(*Context)

	if cmr.hasShareField {
		cmr.share.Range(func(key, value any) bool {
			c.Elem().FieldByName(key.(string)).Set(value.(reflect.Value))
			return true
		})
	}

	// 请求前置操作, 可以用于初始化等功能
	construct := c.MethodByName("Construct")
	if construct.IsValid() {
		construct.Call(nil)
	}

	destruct := c.MethodByName("Destruct")
	if destruct.IsValid() {
		defer func() { destruct.Call(nil) }()
	}

	func() {
		cmr.Lock()
		defer cmr.Unlock()
		var exist bool
		if ins, exist = cmr.reflectMethod[method]; !exist {
			// 反射执行函数参数, 解析并设置可获取的参数类型
			mt := c.MethodByName(method).Type()
			if numIn := mt.NumIn(); numIn > 0 {
				for i := 0; i < numIn; i++ {
					if in := mt.In(i); in.Kind() == reflect.Ptr || in.Kind() == reflect.Interface {
						if in.Kind() == reflect.Interface { // 解析 interface 类型的服务, 如 cache.AbstractCache
							if di.Exists(in.String()) {
								ins = append(ins, reflect.ValueOf(di.MustGet(in.String())))
							} else {
								panic(fmt.Errorf("con't resolve service `%s` in di", in))
							}
						} else { // 解析指针类型的服务: 如: *string, *int
							inV := reflect.New(in.Elem())
							if di.Exists(inV.Interface()) {
								ins = append(ins, reflect.ValueOf(di.MustGet(inV.Interface())))
							} else {
								panic(fmt.Errorf("con't resolve service `%s` in di", inV))
							}
						}
					} else {
						panic(fmt.Errorf("controller %s method: %s params(NO.%d)(%s)  not support. only ptr or interface ", c.Type().String(), mt.Name(), i, in.String()))
					}
				}
				cmr.reflectMethod[method] = ins
			}
		}
	}()

	values := c.MethodByName(method).Call(ins)

	if len(values) > 1 {
		Logger().Warn("can't support auto parse multi values")
	}

	// 查看是否设置了解析返回值
	// 只接收返回值 error, interface, string, int, map struct 等.
	// 具体查看函数: parseValue
	if ctx.autoParseValue && len(values) == 1 {
		var body []byte
		for _, val := range values {
			var skip bool
			switch val.Kind() {
			case reflect.Chan, reflect.Func, reflect.Interface, reflect.Map, reflect.Ptr, reflect.Slice, reflect.UnsafePointer:
				skip = val.IsNil()
			default:
				skip = !val.IsValid()
			}
			if skip {
				continue
			}
			body, err = cmr.parseValue(val)
		}
		if err == nil {
			ctx.Render().ContentType(ctx.app.ReadonlyConfiguration.GetDefaultResponseType())
			_ = ctx.Render().Bytes(body)
		} else {
			ctx.Response.ResetBody()
			ctx.Response.SetStatusCode(http.StatusInternalServerError)
			panic(err)
		}
	}
}

func (cmr *routerWrapper) parseValue(val reflect.Value) ([]byte, error) {
	var value []byte
	var err error
	var valInterface = val.Interface()
	switch val.Type().Kind() {
	// 如果是字符串直接返回
	case reflect.String:
		value = []byte(val.String())

	// 如果返回的为切片
	case reflect.Slice:
		// 字节切片直接返回, 其他切片进行 json 转换
		if val, ok := valInterface.([]byte); ok {
			value = val
		} else if value, err = json.Marshal(valInterface); err != nil {
			return nil, err
		}

	// 如果是 interface
	case reflect.Interface:
		// 判断是不是 err 类型
		if errVal, ok := val.Interface().(error); ok {
			err = errVal
		} else {
			// 使用相同的方法分析参数
			value, err = cmr.parseValue(val.Elem())
		}
	default:
		if val.Type().Name() == "error" {
			err = valInterface.(error)
		} else {
			value, err = json.Marshal(valInterface)
		}
	}
	return value, err
}

func (cmr *routerWrapper) GET(path, method string, mws ...Handler) {
	cmr.router.GET(path, cmr.warpHandler(method, cmr.controller), mws...)
}

func (cmr *routerWrapper) PUT(path, method string, mws ...Handler) {
	cmr.router.PUT(path, cmr.warpHandler(method, cmr.controller), mws...)
}

func (cmr *routerWrapper) ANY(path, method string, mws ...Handler) {
	cmr.router.ANY(path, cmr.warpHandler(method, cmr.controller), mws...)
}

func (cmr *routerWrapper) POST(path, method string, mws ...Handler) {
	cmr.router.POST(path, cmr.warpHandler(method, cmr.controller), mws...)
}

func (cmr *routerWrapper) HEAD(path, method string, mws ...Handler) {
	cmr.router.HEAD(path, cmr.warpHandler(method, cmr.controller), mws...)
}

func (cmr *routerWrapper) DELETE(path, method string, mws ...Handler) {
	cmr.router.DELETE(path, cmr.warpHandler(method, cmr.controller), mws...)
}