import {A} from './A';
import {B} from './B';


class C {
  constructor() {
    this.a = new A();
    this.b = new B();
  }
}

import {IA} from './A';
import {IB} from './B';

class C {
  @inject()
  a: IA
  @inject()
  b: IB
}

class ExampleActivity extends Activity {
  @BindView(R.id.user) EditText username;
  @BindView(R.id.pass) EditText password;

  @BindString(R.string.login_error) String loginErrorMessage;

  @OnClick(R.id.submit) void submit() {
    // TODO call server...
  }

  @Override public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.simple_activity);
    ButterKnife.bind(this);
    // TODO Use fields...
  }
}

import { Injectable } from '@angular/core';
import { HEROES } from './mock-heroes';

@Injectable({providedIn: 'root'})
export class HeroService {
  getHeroes() { return HEROES; }
}

import { Component }   from '@angular/core';
import { Hero }        from './hero';
import { HeroService } from './hero.service';
 
@Component({
  selector: 'app-hero-list',
  template: `
    <div *ngFor="let hero of heroes">
      {{hero.id}} - {{hero.name}}
    </div>
  `
})
export class HeroListComponent {
  heroes: Hero[];
 
  constructor(heroService: HeroService) {
    this.heroes = heroService.getHeroes();
  }
}

class Apple {
  // ....
}

const instance = new Apple();  // 正射

const instance = Reflect.construct(Apple, []); // 反射

const requiredMetadataKey = Symbol("required");

function required(target: Object, propertyKey: string | symbol, parameterIndex: number) {

  // 元信息收集
  // 1. 通过requiredMetadataKey获取函数参数的存储队列
  // 2. 如果存在则将参数的元数据进行存储
  // 3. 如果不存在则创建当前函数唯一的元信息存储队列
  let existingRequiredParameters: number[] = Reflect.getOwnMetadata(requiredMetadataKey, target, propertyKey) || [];
  existingRequiredParameters.push(parameterIndex);
  Reflect.defineMetadata(requiredMetadataKey, existingRequiredParameters, target, propertyKey);
}

function validate(target: any, propertyName: string, descriptor: TypedPropertyDescriptor < Function > ) {
  let method = descriptor.value;

  // 元信息遍历
  // 1. 为该方法新增拦截逻辑，重写descriptor的value即可
  // 2. 当调用该方法时(运行时触发)，遍历此前的元信息，挨个取值并验证是否符合验证条件
  descriptor.value = function () {
    let requiredParameters: number[] = Reflect.getOwnMetadata(requiredMetadataKey, target, propertyName);
    if (requiredParameters) {
      for (let parameterIndex of requiredParameters) {
        if (parameterIndex >= arguments.length || arguments[parameterIndex] === undefined) {
          throw new Error("Missing required argument.");
        }
      }
    }
    // 执行方法本身
    return method.apply(this, arguments);
  }
}

class Greeter {
  greeting: string;

  constructor(message: string) {
    this.greeting = message;
  }

  @validate
  greet(@required name: string) {
    return "Hello " + name + ", " + this.greeting;
  }
}

let gg = new Greeter('...')
console.log(gg.greet('xx'))

export function debounce(delay: number): Function {
  return (
    target: Object,
    propertyKey: string,
    propertyDesciptor: PropertyDescriptor
  ) => {
    const method = propertyDesciptor.value;
    let timer = null;
    propertyDesciptor.value = (...args) => {
      if (timer) {
        clearTimeout(timer);
        timer = null;
      }
      timer = setTimeout(() => method(...args), delay);
    };
    return propertyDesciptor;
  };
}

class A {
  @debounce(1000)
  say(message: any) {
    console.log(message);
  }
}

let a = new A()
a.say('hello')

import { Vue, Component, Watch, Emit } from 'vue-property-decorator'

@Component
export default class YourComponent extends Vue {
  count = 0
  
  @Watch('child')
  onChildChanged(val: string, oldVal: string) {}
  
  @Emit()
  addToCount(n: number) {
    this.count += n
  }
}

export default {
  data() {
    return {
      count: 0,
    }
  },
  watch: {
    child: [
      {
        handler: 'onChildChanged',
        immediate: false,
        deep: false,
      },
    ],
  },
  methods: {
    onChildChanged(val, oldVal) {},
    addToCount(n) {
      this.count += n
      this.$emit('add-to-count', n)
    }
  },
}

function inject(identifier?: ObjectIdentifier) {
  return function (target: any, targetKey: string, index?: number): void {

    if (typeof index === 'number') {
      if (!identifier) {
        const args = getParamNames(target);
        if (target.length === args.length && index < target.length) {
          identifier = args[index];
        }
      }
      const metadata = new Metadata(INJECT_TAG, identifier);
      tagParameter(target, targetKey, index, metadata);
    } else {
      if (!identifier) {
        identifier = targetKey;
      }
      const metadata = new Metadata(INJECT_TAG, identifier);
      tagProperty(target, targetKey, metadata);
    }
  };
} 
// https://github.com/midwayjs/injection/blob/master/src/annotation/inject.ts

// 使用 IoC
import {Container} from 'injection';
import {A} from './A';
import {B} from './B';
const container = new Container();
container.bind(A);
container.bind(B);

class C {
  consturctor() {
    this.a = container.get('A');
    this.b = container.get('B');
  }
}

// A.js
...
@provide()
export class A {
  @inject
  b: IB
}

// B.js

...
@provide()
export class B {
  @inject
  a: IA
}


// main.js
import {Container} from 'injection';
import {A} from './A';
import {B} from './B';
const container = new Container();
container.bind(A);
container.bind(B);

class C {
  consturctor() {
    this.a = container.get('A');
    this.b = container.get('B');
  }
}

bind<T>(identifier: ObjectIdentifier, target: T, options?: ObjectDefinitionOptions): void {
  let definition;
  // definition.autowire = true;
  if (is.class(identifier) || is.function(identifier)) {
    options = target;
    target = <any> identifier;
    identifier = this.getIdentifier(target);
    options = null;
  }

if (is.class(target)) {
  definition = new ObjectDefinition();
} else {
  definition = new FunctionDefinition(this);
}

definition.path = target;
definition.id = identifier;

debug(`=> bind and build definition, id = [${definition.id}]`);

// inject constructArgs
const constructorMetaData = Reflect.getMetadata(TAGGED, target);
if (constructorMetaData) {
  debug(`   register inject constructor length = ${target[ 'length' ]}`);
  const maxLength = Math.max.apply(null, Object.keys(constructorMetaData));
  for (let i = 0; i < maxLength + 1; i++) {
    const propertyMeta = constructorMetaData[ i ];
    if (propertyMeta) {
      const refManagedIns = new ManagedReference();
      refManagedIns.name = propertyMeta[ 0 ].value;
      definition.constructorArgs.push(refManagedIns);
    } else {
      // inject empty value
      const valueManagedIns = new ManagedValue();
      valueManagedIns.value = undefined;
      definition.constructorArgs.push(valueManagedIns);
    }
  }
}

// inject properties
const metaDatas = recursiveGetMetadata(TAGGED_PROP, target);
for (const metaData of metaDatas) {
  debug(`   register inject properties = [${Object.keys(metaData)}]`);
  for (const metaKey in metaData) {
    for (const propertyMeta of metaData[ metaKey ]) {
      const refManaged = new ManagedReference();
      refManaged.name = propertyMeta.value;
      definition.properties.set(metaKey, refManaged);
    }
  }
}

this.convertOptionsToDefinition(options, definition);
// 对象自定义的annotations可以覆盖默认的属性
this.registerCustomBinding(definition, target);

this.registerDefinition(identifier, definition);
debug(`   bind and build definition complete, id = [${definition.id}]`);
}

...

get<T>(identifier: ObjectIdentifier, args?: any): T {
  ...
  return this.getManagedResolverFactory().create(definition, args);
}

....

doConstruct(Clzz: any, args?: any): any {
  ...
  inst = Reflect.construct(Clzz, args);
  return inst;
}