const logger = (now: number) => console.log(`lasted logged in ${now}`);

class User {
  async login() {
    await setTimeout(() => console.log('login success'), 100);
    logger(new Date().valueOf());
  }
}

/**
 * 使用高阶函数
 * 柯里化解构登录与日志记录
 */

type DecoratorFunc = (
    target: any,
    key: string,
    descriptor: PropertyDescriptor,
) => void;

// 模拟的装饰器工厂函数
const createDecorator =
    (decorator: DecoratorFunc) => (Model: any, key: string) => {
        // 获取即将使用装饰器的类原型
        const target = Model.prototype;
        // 获取这个原型上某个方法的描述
        const descriptor = Object.getOwnPropertyDescriptor(target, key);
        // 更改描述,生成新的方法
        decorator(target, key, descriptor);
    };

const logger: DecoratorFunc = (target, key, descriptor) =>
    // 将修改后的函数重新定义到原型链上
    Object.defineProperty(target, key, {
        ...descriptor,
        value: async (...args: any[]) => {
            try {
                return descriptor.value.apply(this, args); // 调用之前的函数
            } finally {
                const now = new Date().valueOf();
                console.log(`lasted logged in ${now}`);
            }
        },
    });

class User {
    async login() {
        console.log('login success');
        await new Promise((resolve) => {
            setTimeout(resolve, 100);
        });
    }
}

export const exp1 = () => {
    console.log();
    console.log(
        '-----------------------示例1:高阶函数柯里化(装饰器内部原理)-----------------------',
    );
    console.log(
        '-----------------------实现登录和日志记录解耦-----------------------',
    );
    console.log();
    const loggerDecorator = createDecorator(logger);
    loggerDecorator(User, 'login');
    const user = new User();
    user.login();
    console.log();
    console.log('-----------------------示例1:执行完毕-----------------------');
};

// 控制台输出
// login success
// 停顿100ms
// lasted logged in 1571771681793

const HelloDerorator = <T extends new (...args: any[]) => any>(
    constructor: T,
) => {
    return class extends constructor {
        newProperty = 'new property';

        hello = 'override';

        sayHello() {
            return this.hello;
        }
    };
};

@HelloDerorator
export class Hello {
    [key: string]: any; // 此处用于防止eslint提示sayHello方法不存在

    hello: string;

    constructor() {
        this.hello = 'test';
    }
}

const exp2 = () => {
    console.log(
        '-----------------------示例2:简单的类装饰器-----------------------',
    );
    console.log(
        '-----------------------动态添加一个sayHello方法以及覆盖hello的值-----------------------',
    );
    console.log();
    const hello = new Hello();
    console.log(hello.sayHello());
    console.log();
    console.log('-----------------------示例2:执行完毕-----------------------');
};


// 控制台打印 override

const SetNameDerorator = (firstname: string, lastname: string) => {
    const name = `${firstname}.${lastname}`;
    return <T extends new (...args: any[]) => any>(target: T) => {
        return class extends target {
            _name: string = name;

            getMyName() {
                return this._name;
            }
        };
    };
};

@SetNameDerorator('jesse', 'pincman')
class UserService {
    getName() {}
}

const exp3 = () => {
    console.log();
    console.log(
        '-----------------------示例3:装饰器工厂-----------------------',
    );
    console.log(
        '-----------------------通过继承方式 重载getName方法-----------------------',
    );
    console.log();
    const user = new UserService();
    console.log(user.getName());
    console.log();
    console.log('-----------------------示例3:执行完毕-----------------------');
};

// 控制台打印 jesse.pincman

type UserProfile = Record<string, any> & {
    phone?: number;
    address?: string;
};

const ProfileDecorator = (profile: UserProfile) => (target: any) => {
    const Original = target;
    let userinfo = '';
    Object.keys(profile).forEach((key) => {
        userinfo = `${userinfo}.${profile[key].toString()}`;
    });
    // 添加一个原型属性
    Original.prototype.userinfo = userinfo;
    // 使用函数创建一个新的类(类构造器),返回值为传入类的对象,这样就重载了构造函数
    function constructor(...args: any[]) {
        console.log('contruct has been changed');
        return new Original(...args);
    }
    // 赋值原型链
    constructor.prototype = Original.prototype;
    // 添加一个静态属性
    // constructor.myinfo = `myinfo ${userinfo}`;
    return constructor as typeof Original;
};

// 因为静态属性是无法通过[key: string]: any;获取类型提示的,所以这里添加一个接口用于动态各类添加静态属性
interface StaticUser {
    new (): UserService;
    myinfo: string;
}

@ProfileDecorator({ phone: 133, address: 'zhejiang' })
class ProfileService {}

const exp4 = () => {
    console.log();
    console.log(
        '-----------------------示例4:修类的构造函数,原型属性,静态属性等-----------------------',
    );
    console.log(
        '-----------------------设置原型属性值,重载构造防反,添加静态属性-----------------------',
    );
    console.log();
    // console.log((ProfileService as unknown as StaticUser).myinfo);
    const profile = new ProfileService();
    console.log((profile as any).userinfo);
    console.log();
    console.log('-----------------------示例4:执行完毕-----------------------');
};

// 打印静态属性则控制台输出 myinfo .133.zhejiang
// 控制台输出 contruct has been changed
// 控制台输出 .133.zhejiang

const userRoles: string[] = [];

// 通过属性装饰器把角色赋值给userRoles
const RoleDerorator = (roles: string[]) => (target: any, key: string) => {
    roles.forEach((role) => userRoles.push(role));
};

// 根据userRoles生成Roles对象并赋值给类原型的roles属性
const SetRoleDerorator = <
    T extends new (...args: any[]) => {
        [key: string]: any;
    },
>(
    constructor: T,
) => {
    const roles = [
        { name: 'super-admin', desc: '超级管理员' },
        { name: 'admin', desc: '管理员' },
        { name: 'user', desc: '普通用户' },
    ];
    return class extends constructor {
        constructor(...args: any) {
            super(...args);
            this.roles = roles.filter((role) => userRoles.includes(role.name));
        }
    };
};

@SetRoleDerorator
class UserEntity {
    @RoleDerorator(['admin', 'user'])
    roles: string[] = [];
}

export const exp5 = () => {
    console.log();
    console.log(
        '-----------------------示例5:属性装饰器-----------------------',
    );
    console.log(
        '-----------------------使用装饰器根据权限过滤用户列表-----------------------',
    );
    console.log();
    const user = new UserEntity();
    console.log(user.roles);
    console.log();
    console.log('-----------------------示例5:执行完毕-----------------------');
};

// 控制台输出 [ { name: 'admin', desc: '管理员' }, { name: 'user', desc: '普通用户' } ]

const loggerDecorator = () => {
    return function logMethod(
        target: any,
        propertyName: string,
        propertyDescriptor: PropertyDescriptor,
    ): PropertyDescriptor {
        const method = propertyDescriptor.value;

        // 重载方法
        propertyDescriptor.value = function async(...args: any[]) {
            try {
                return method.apply(this, args); // 调用之前的函数
            } finally {
                const now = new Date().valueOf();
                console.log(`lasted logged in ${now}`);
            }
        };
        return propertyDescriptor;
    };
};

class UserService {
    @loggerDecorator()
    async login() {
        console.log('login success');
        await new Promise((resolve) => {
            setTimeout(resolve, 100);
        });
    }
}

export const exp6 = () => {
    console.log();
    console.log(
        '-----------------------示例6:方法装饰器-----------------------',
    );
    console.log(
        '-----------------------使用装饰器重写示例1-----------------------',
    );
    console.log();
    const user = new UserService();
    user.login();
    console.log();
    console.log('-----------------------示例6:执行完毕-----------------------');
};

// 控制台输出结果与前面的示例1相同

// 参数格式化配置
const parseConf: ((...args: any[]) => any)[] = [];

export const parse =
    (parseTo: (...args: any[]) => any) =>
    (target: any, propertyName: string, index: number) => {
        parseConf[index] = parseTo;
    };

// 在函数调用前执行格式化操作
export const parseDecorator = (
    target: any,
    propertyName: string,
    descriptor: PropertyDescriptor,
): PropertyDescriptor => {
    console.log('开始格式化数据');
    return {
        ...descriptor,
        value(...args: any[]) {
            // 获取格式化后的参数列表
            const newArgs = args.map((v, i) =>
                parseConf[i] ? parseConf[i](v) : v,
            );
            console.log('格式化完毕');
            return descriptor.value.apply(this, newArgs);
        },
    };
};

export interface UserType {
    id: number;
    username: string;
}

class UserService {
    private users: UserType[] = [
        { id: 1, username: 'admin' },
        { id: 2, username: 'pincman' },
    ];

    getUsers() {
        return this.users;
    }

    @parseDecorator
    delete(@parse((arg: any) => Number(arg)) id: number) {
        this.users = this.users.filter((userObj) => userObj.id !== id);
        return this;
    }
}

export const exp78 = () => {
    console.log();
    console.log(
        '-----------------------示例7:参数装饰器-----------------------',
    );
    console.log('-----------------------格式化参数-----------------------');
    console.log();
    const userService = new UserService();
    userService.delete(1);
    console.log(userService.getUsers());
    console.log();
    console.log('-----------------------示例7:执行完毕-----------------------');
};


// 控制台输出: [ { id: 2, username: 'pincman' } ]

export const HiddenDecorator = () => {
    return (
        target: any,
        propertyName: string,
        descriptor: PropertyDescriptor,
    ) => {
        descriptor.enumerable = false;
    };
};

export const PrefixDecorator = (prefix: string) => {
    return (
        target: any,
        propertyName: string,
        descriptor: PropertyDescriptor,
    ) => {
        return {
            ...descriptor,
            set(value: string) {
                descriptor.set.apply(this, [`${prefix}_${value}`]);
            },
        };
    };
};

export class UserEntity {
    private _nickname: string;

    // @ts-ignore
    private fullname: string;

    @HiddenDecorator()
    @PrefixDecorator('jesse_')
    get nickname() {
        return this._nickname;
    }

    set nickname(value: string) {
        this._nickname = value;
        this.fullname = `${value}_fullname`;
    }
}

export const exp78 = () => {
    // ...

    console.log();
    console.log(
        '-----------------------示例8:get/set装饰器-----------------------',
    );
    console.log(
        '-----------------------禁止nickname出现在遍历中,为nickname添加前缀-----------------------',
    );
    console.log();
    const user = new UserEntity();

    user.nickname = 'pincman';
    console.log(user);
    console.log(user.nickname);
    console.log();
    console.log('-----------------------示例8:执行完毕-----------------------');
};

// 第一个console.log控制台输出,可以看到遍历对象后并没有nickname字段的值
// UserService {
//  users: [ { id: 1, username: 'admin' }, { id: 2, username: 'pincman' } ],
//  roles: [],
//  hello: 'test',
//  password: '123456',
//  _nickname: 'gkr__lichnow',
//  fullname: 'gkr__lichnow_fullname'
//}
// 第二个console.log控制台输出
// gkr__lichnow

 return <T extends new (...args: any[]) => any>(target: T) => {
    return class extends target {
      getMyName() {
        return this._name;
      }
    };
  };

const ProfileDerorator = (profile: UserProfile) => {
  return (target: any) => {
    const original = target;
    function constructor(...args: any[]) {
      console.log('contruct has been changed');
      return new original(...args);
    }
    // 赋值原型链
    constructor.prototype = original.prototype;
    // 添加一个静态属性
    constructor.myinfo = `myinfo ${userinfo}`;
    return constructor as typeof original;
  };
};

const loggerDecorator = () => {
  return function logMethod(
    target: Object,
    propertyName: string,
    propertyDescriptor: PropertyDescriptor,
  ): PropertyDescriptor {
    const method = propertyDescriptor.value;
    // 重载方法
    propertyDescriptor.value = function async (...args: any[]) {...};
    return propertyDescriptor;
  };
};

const parseFunc = (
  target: Object,
  propertyName: string,
  descriptor: PropertyDescriptor,
): PropertyDescriptor => {
  return {
    ...descriptor,
    value(...args: any[]) {
      // 获取格式化后的参数列表
      const newArgs = parseConf.map((toParse, index) => toParse(args[index]));

      return descriptor.value.apply(this, newArgs);
    },
  };
};

{
    "compilerOptions": {
        "target": "ES5",
        "experimentalDecorators": true,
        "emitDecoratorMetadata": true
    }
}

import 'reflect-metadata';

import { parse, parseDecorator, UserType } from './exp7-8';

class Point {
    x: number;

    y: number;
}

class Line {
    private _p0: Point;

    private _p1: Point;

    @validate
    // 这句可以省略,因为design:type是预定义属性
    // @Reflect.metadata('design:type', Point)
    set p0(value: Point) {
        this._p0 = value;
    }

    get p0() {
        return this._p0;
    }

    @validate
    // @Reflect.metadata("design:type", Point)
    set p1(value: Point) {
        this._p1 = value;
    }

    get p1() {
        return this._p1;
    }
}

function validate<T>(
    target: any,
    propertyKey: string,
    descriptor: TypedPropertyDescriptor<T>,
) {
    const { set } = descriptor;
    descriptor.set = function (value: T) {
        const type = Reflect.getMetadata('design:type', target, propertyKey);
        if (!(value instanceof type)) {
            throw new TypeError('Invalid type.');
        }
        set.apply(this, [value]);
    };
    return descriptor;
}

export const exp910 = () => {
    console.log();
    console.log(
        '-----------------------示例9:基本元元素类型反射-----------------------',
    );
    console.log(
        '-----------------------为访问器的set方法添加类型验证-----------------------',
    );
    console.log();
    const line = new Line();
    const p0 = new Point();
    p0.x = 1;
    p0.y = 2;
    line.p1 = p0;
    console.log(line);
    console.log();
    console.log('-----------------------示例9:执行完毕-----------------------');
};


// 控制台输出: Line { _p1: Point { x: 1, y: 2 } }

// 角色守卫
export const RoleGuardDecorator = (roles: string[]) => {
    console.log('开始验证角色');
    return function roleGuard(
        target: any,
        propertyKey: string,
        descriptor: PropertyDescriptor,
    ) {
        // 根据传入的参数定义守卫所需的角色
        Reflect.defineMetadata('roles', roles, target, propertyKey);
        const method = descriptor.value;
        descriptor.value = function (...args: any[]) {
            // 获取当前用户的角色
            const currentRoles = target.getRoles();
            // 获取我们定义的操作此方法所需的角色
            const needRoles = Reflect.getMetadata('roles', target, propertyKey);
            // 判断当前用户是否拥有所需的角色,没有则抛出异常
            for (const role of needRoles) {
                if (!currentRoles.includes(role)) {
                    throw new Error(
                        `you have not permission to run ${propertyKey}`,
                    );
                }
            }
            console.log('验证角色完毕');
            return method.apply(this, args);
        };
        return descriptor;
    };
};

export class UserService {
    protected users: UserType[] = [
        { id: 1, username: 'admin' },
        { id: 2, username: 'pincman' },
    ];

    getUsers() {
        return this.users;
    }

    // 设定当前用户的角色
    getRoles() {
        return ['user'];
    }

    @RoleGuardDecorator(['admin'])
    // 在装饰器中使用Reflect.defineMetadata()放定义roles只是为了方便封装
    // 当然,我们也可以在方法上直接定义roles,如下
    // Reflect.metadata('roles',['admin'])
    @parseDecorator
    delete(@parse((arg: any) => Number(arg)) id: number): UserService {
        this.users = this.getUsers().filter((userObj) => userObj.id !== id);
        return this;
    }
}

export const exp910 = () => {
    // ...
    console.log();
    console.log(
        '-----------------------示例10:自定义元元素反射-----------------------',
    );
    console.log(
        '-----------------------添加角色守卫来判断当前用户是否有删除权限-----------------------',
    );
    console.log();
    const user = new UserService();
    user.delete(1);
    console.log(user.getUsers());
    console.log();
    console.log(
        '-----------------------示例10:执行完毕-----------------------',
    );
};


// 控制台将输出异常
// Error: you have not permission to run delete