// demo1
@testDecorate
class MyTesDecorateClass {
  // ...
}
function testDecorate(target) {
  target.useDecorate = true;
}
MyTesDecorateClass.useDecorate // true

// demo2 demo1添加一个静态属性，如果要添加实例属性，可以通过目标类的prototype对象操作
function testDecorate(target) {
  target.prototype.useDecorate = true;
}
@testable
class MyTesDecorateClass {}
let obj = new MyTesDecorateClass();
obj.useDecorate // true

// demo1 方法中的简单使用
class Person {
  @readonly
  name() { return `${this.first} ${this.last}` }
}
function readonly(target, name, descriptor){
  // descriptor对象原来的值如下 - 为什么是这些值呢？先卖个关子，后面再讲。
  // {
  //   value: specifiedFunction,
  //   enumerable: false,
  //   configurable: true,
  //   writable: true
  // };
  descriptor.writable = false;
  return descriptor;
}

// demo2 叠加使用
function dec(id){
  console.log('evaluated', id);
  return (target, property, descriptor) => console.log('output', id);
}
class Example {
    @dec(1)
    @dec(2)
    method(){}
}
// 输出结果 - 小朋友，看到这个输出顺序，你是否有很多问号？带着这个问号接着往下看吧。
// evaluated 1
// evaluated 2
// output 2
// output 1

public async request (ctx: ParameterizedContext, next: Function): Promise<void> {
    // 如果是接口的话，需要校验用户权限 判断请求路径是否是 localhost/api/xxxxxx
    const isApiRquest = ctx.request.url.split('/')[1] === 'api'
    const correctAuthorization = isApiRquest ? this.jwtVerify(ctx) : false
    if (isApiRquest && correctAuthorization) {
      // 处理用户请求参数
      const userParam = this.formatParams(ctx, correctAuthorization)
      // 校验用户请求参数
      const correctParam = await this.verifyParameters(userParam, ctx)
      // 参数校验通过，才到下一个中间件
      if (correctParam) await next()
    } else {
      // 不是接口请求，直接跳过此中间件
      if (!isApiRquest) await next()
    }
}
// 使用中间件，直接在全局应用一下，这样的话，就可以不用在没次请求中加上身份校验的校验，但是这也会有个问题，就是有些路由是不需要身份校验的，需要添加一个白名单。
app
  .use(requestMiddleware)
  .use(api.routes())
  .use(api.allowedMethods())

import Controller from '../controller/index';
const router = new Router();
router.post('/getList', Controller.getList);
// 请求方式 localhost[:port]/api/路由模块/getList

// router.ts 需要先判断请求的参数
const {
  startTime,
  endTime,
  ...otherQuery
} = ctx.query;
const query = { ...ctx.query };
// 列表请求需要 开始时间-结束时间-分页数据-其他的查询参数（空值传参过滤）
const [options, skip, limit, result] = super.disposeGetListQuery(query);

// RequestControllerAbstract.ts 继承的抽象类
public disposeGetListQuery (query: GetListQuery): [object, number, number, object] {
  if (!query || typeof query !== 'object') {
    return;
  }
  const { startTime, endTime, pageSize, pageNum } = query;
  const num = Number(pageNum) || 1;
  const limit = Number(pageSize) || 20;
  const skip = (num - 1) * limit;
  const ignoreList = ['startTime', 'endTime', 'pageNum', 'pageSize'];
  // 吧其他参数包装起来-顺便过滤空值传参
  const options = {
    // 这边只做了个简单的空值过滤，实际场景中，还会有请求参数类型和格式还有值的要求，这边就不详细展开了
    ...filterNullValue(query, ignoreList)
  };
  if (startTime) {
    options['time'] = options.time || {};
    options['time']['$gte'] = Number(new Date(startTime));
  }
  if (endTime) {
    options['time'] = options.time || {};
    options['time']['$lte'] = Number(new Date(endTime));
  }
  // 定义返回数据
  const result: ListReturnData = {
    total: 0,
    pageSize: limit,
    pageNum: num,
    list: []
  };
  // 列表请求接口一般也要做好分页功能，所以这边直接把分页的内容返回过去
  return [options, skip, limit, result];
}

// 路由
@Controller('/test') // 定义了是那个模块
class Test {
  @get('/getList/:id22') // 直接定义了接口名和参数
  @RequestHeaders(ReqHeaders) // 某些接口为了安全，会在header中一些隐私数据
  @RequestQuery(ReqQuery) // 校验请求参数
  @RequestQuery(ListReqParams) // 可以校验多个点（也可以在一个中传对象，这边写出来只是为了提升一下逼格）
  @Paging() //是否要分页
  @auth() // 请求这个接口是否需要校验身份
  async getList(ctx: ParameterizedContext, next: Function) {
    // 通过分页包装后，就可以直接在这边拿到分页参数了
    const result = {
      total: [total] 根据查询条件,
      pageNum: this.pageNum,
      pageSize: this.pageSize,
      list: [] // 通过数据库查询获取
    }
    super.handleRespose('success', ctx, result)
      }
    }
  }
}
// 请求方式 localhost[:port]/api/test/getList/111

// 补充一：如何实现授权装饰器
class Request {
  public auth() {
    return (target: any, name?: string, descriptor?: IDescriptor) => {
      if (typeof target === 'function' && name === undefined && descriptor === undefined) {
        // 装饰类
        target.prototype.baseAuthMidws = super.verifyAuthMiddleware;
      } else if (typeof target === 'object' && name && descriptor) {
        // 装饰类方法
        descriptor.value.prototype.baseAuthMidws = super.verifyAuthMiddleware;
      }
    }
  }
}
const request = new Request();
// 最终对外暴露的装饰器
export const auth = request.auth.apply(request);

// 补充二：如果动态导入路由
export default (dir: string = '../api', filePattern?: RegExp) => {
  // 根据规则，找到api/目录下的所有文件，把这些代码注册为路由文件
  util.exportFile(dir, filePattern);
  return rootRouter
}
// index.ts中
import decoratorRouter from './decorator/router'
const route = decoratorRouter();
app
  // .use(requestMiddleware) // 就不需要通过这种中间件的方式来处理权限校验了
  .use(route.routes())
  .use(route.allowedMethods())

// 通过这边可以看出来，decorator其实是一个语法糖，作用于对象的属性时，实质利用了Object.defineProperty方法，这边也就能解释 三-2中的问题了

// descriptor-属性描述符。对象里目前存在的属性描述符有两种主要形式：数据描述符和存取描述符。数据描述符是一个具有值的属性，该值可能是可写的，也可能不是可写的。存取描述符是由 getter-setter 函数对描述的属性
// 
function handleDescriptor(target, key, descriptor, [decorator, ...args]) {
  // 结构属性描述符descriptor 通常用来改变默认的属性访问
  const { configurable, enumerable, writable } = descriptor;
  // 接收原本的get/set方法和值
  const originalGet = descriptor.get;
  const originalSet = descriptor.set;
  const originalValue = descriptor.value;
  const isGetter = !!originalGet;
  return {
    configurable,
    enumerable,
    get() {
      // 对函数进行装饰，也可以认为是包装，本质上就是在原来函数/类的基础上，植入了装饰器的代码
      const fn = isGetter ? originalGet.call(this) : originalValue;
      const value = decorator.call(this, fn, ...args);
      if (isGetter) {
        return value;
      } else {
        const desc = {
          configurable,
          enumerable
        };
        desc.value = value;
        desc.writable = writable;
        // es7装饰器的本质
        Object.defineProperty(this, key, desc);
        return value;
      }
    },
    set: isGetter ? originalSet : createDefaultSetter()
  };
}
export default function decorate(...args) {
  return _decorate(handleDescriptor, args);
}

// createDefaultSetter 重置set方法
function createDefaultSetter(key) {
  return function set(newValue) {
    Object.defineProperty(this, key, {
      configurable: true, // 设置该属性可配置，避免封闭
      writable: true, // 设置为可写
      enumerable: true, // 设置为可被
      value: newValue
    });

    return newValue;
  };
}

// _decorate
function _decorate(handleDescriptor, entryArgs) {
  if (isDescriptor(entryArgs[entryArgs.length - 1])) {
    return handleDescriptor(...entryArgs, []);
  } else {
    return function () {
      return handleDescriptor(...Array.prototype.slice.call(arguments), entryArgs);
    };
  }
}

export function isDescriptor(desc) {
  if (!desc || !desc.hasOwnProperty) {
    return false;
  }
  const keys = ['value', 'initializer', 'get', 'set'];
  for (let i = 0, l = keys.length; i < l; i++) {
    if (desc.hasOwnProperty(keys[i])) {
      return true;
    }
  }
  return false;
}

const { defineProperty, getOwnPropertyDescriptor } = Object;
export default function applyDecorators(Class, props) {
  const { prototype } = Class;
  for (const key in props) {
    const decorators = props[key];
    for (let i = 0, l = decorators.length; i < l; i++) {
      const decorator = decorators[i];
      // 利用js原型链的特性来实现效果
      defineProperty(prototype, key,
        decorator(
          prototype,
          key, 
          getOwnPropertyDescriptor(prototype, key)
        )
      ); 
    }
  }
  return Class;
}