/**
 * 泛型最大的作用：
 * （1）：类型提示
 * （2）：类型约束
 * 
 */

//泛型可以附初始值
class Component<P = {}, S = {}> {
    props: P;
    constructor(props?: P) {
        this.props = props;
    }
}


class Ball<P, S> extends Component<P, S> {

}


class GameObject<T> {
    getElemntByQualifiedName<T>(value: { new(): T }): T {
        return new value();
    }
}

interface LengthWise {
    length: number;
}

interface Person {
    name: string;
    age: number;
}

interface EventType {
    click: { type: string, bubbles: boolean }
    mousedown: { type: string, bubbles: boolean };
    mouseup: { type: string };
}


interface EventTyp3<T> {
    addEventListener(type: T, handler: () => void): void;
    addEventListener(type: string, handler: () => void): void;
}

class BeeKeeper {
    hasMask: boolean;
}

class ZooKeeper {
    nametag: string;
}

class Animal {
    numLegs: number;
}

class Bee extends Animal {
    keeper: BeeKeeper;
}

class Lion extends Animal {
    keeper: ZooKeeper;
}

export class GenericsExample {
    execute() {
        let component = new Component({ a: 1, b: 2 });


        let gameobject = new GameObject<Component<1, 2>>();
        let comp = gameobject.getElemntByQualifiedName(Component);

        //类型推断
        let values = [1, 2, 3, 4, 5];
        let finds = values.find((value, index, arr) => {
            return value > 3;
        });
        console.log(finds);


        //泛型约束 typescript 1.8
        //希望传入的数据有个length属性
        this.genericsConstraint("1");//ok
        // this.genericsConstraint(1);//error
        this.genericsConstraint({ length: 100, width: 100 });//ok   

        //约束key是对象obj的属性
        let states = {
            width: 100,
            height: 100
        };

        //为了保证键值在有限范围内，需要通过 extends keyof 来处理
        let propertyValue = this.getPropertyValue(states, "width");
        console.log(propertyValue);

        type personKey = keyof Person;
        let key: personKey;
        switch (key) {
            case 'name':

                break;

            case "age":

                break;

            // case "location": //error

            //     break;
        }

        this.addEventListener("mousedown", (evt) => {
            console.log(evt)
        }, this);

        //assign
        console.log(this.assign({ a: 1, b: 2, c: 3 }, { a: 10, c: 20 }));

        //-------------------泛型参数默认类型--TODO-------------------//
        class GameObject1<T extends Component = Component>{

        }
        //因为有默认类型，这里不需要传入泛型类
        let gameobject1 = new GameObject1();
        x
        // class Component2<P, S> {
        //     props: P;
        //     constructor(props?: P) {
        //         this.props = props;
        //     }
        // }

        // class GameOBject2<T extends Component2>{

        // }

        // let gameobject2 = new GameOBject2();

        interface Person {
            name: string;
            age: number;
            location: string;
        }

        type P = keyof Person;
        let p: P;
        //等价于下面
        let p1: "name" | "age" | "location";

        type P2 = keyof Person[];

        /** keyof 处理类型继承，类似交叉类型 */
        class Sub {
            a: number;
            b: number;
        }

        class Parent extends Sub {
            c: number;
        }

        type b = keyof Parent;

        /**-----------------------泛型类型---------------------- */
        function identity<T>(arg: T): T {
            return arg;
        }

        let myIdentity: <T>(arg: T) => T = identity;
        let myIdentity2: { <T>(arg: T): T } = identity;

        interface GenericIdentityFn {
            <T>(arg: T): T;
        }
        let myIdentify3: GenericIdentityFn = identity;
        myIdentify3(10);

        interface GenericIdentityFn2<T> {
            (arg: T): T;
        }
        let myIdentify4: GenericIdentityFn2<string> = identity;
        myIdentify4('10');

        this.create(Parent);
        this.create2(Parent);

        this.createInstance(Bee);
        this.createInstance(Animal);
        // this.createInstance(BeeKeeper); //error
    }

    genericsConstraint<T extends LengthWise | { length: number }>(value: T): T {
        return value;
    }

    /** 
     * 将源值的部分数据附给target
     */
    assign<T extends U, U>(target: T, source: U): T {
        for (let id in source) {
            (<any>target)[id] = source[id];
        }
        return target;
    }

    /** 注册一个可选范围键值 */
    addEventListener<S, K extends keyof EventType>(type: K, listener: (evt?: EventType[K]) => void, thisObject: any): void {
        //logic
    }

    removeEventListener<K extends keyof EventType>(type: K, listener: (evt?: EventType[K]) => void): void {

    }

    /**
     * typescript 2.1
     * @param obj 
     * @param key 
     */
    getPropertyValue<T, K extends keyof T>(obj: T, key: K): T[K] {
        return obj[key];
    }

    create<T>(o: { new(): T }): T {
        return new o();
    }

    create2<T>(o: new () => T): T {
        return new o();
    }

    createInstance<T extends Animal>(o: new () => T): T {
        return new o();
    }
}