// angular2\packages\core\src\di\injector.ts
export abstract class Injector {
 static THROW_IF_NOT_FOUND = _THROW_IF_NOT_FOUND;
 static NULL: Injector = new _NullInjector();

 /**
 * 用于根據(jù)給定的Token從注入器中獲取相應(yīng)的對(duì)象。
 * 如果沒(méi)有找到相應(yīng)的對(duì)象，將返回notFoundValue設(shè)置的值。若notFoundValue的值與
 * _THROW_IF_NOT_FOUND相等，則會(huì)拋出異常。
 */
 abstract get<T>(token: Type<T>|InjectionToken<T>, notFoundValue?: T): T;
}

const _THROW_IF_NOT_FOUND = new Object();

// angular2\packages\core\src\di\injector.ts
class _NullInjector implements Injector {
 get(token: any, notFoundValue: any = _THROW_IF_NOT_FOUND): any {
 if (notFoundValue === _THROW_IF_NOT_FOUND) {
  throw new Error(`No provider for ${stringify(token)}!`);
 }
 return notFoundValue;
 }
}

@Injectable()
class Engine {}

@Injectable()
class Car {
 constructor(public engine:Engine) {}
}

var injector = ReflectiveInjector.resolveAndCreate([Car, Engine]);
var car = injector.get(Car);
expect(car instanceof Car).toBe(true);
expect(car.engine instanceof Engine).toBe(true);

static resolveAndCreate(providers: Provider[], parent?: Injector): ReflectiveInjector {
 const ResolvedReflectiveProviders = ReflectiveInjector.resolve(providers);
 return ReflectiveInjector.fromResolvedProviders(ResolvedReflectiveProviders, parent);
}

static resolve(providers: Provider[]): ResolvedReflectiveProvider[] {
 return resolveReflectiveProviders(providers);
}

@Injectable()
class Engine {}

@Injectable()
class Car {
 constructor(public engine:Engine) {}
}

var providers = ReflectiveInjector.resolve([Car, [[Engine]]]);
expect(providers.length).toEqual(2);

expect(providers[0] instanceof ResolvedReflectiveProvider).toBe(true);
expect(providers[0].key.displayName).toBe("Car");
expect(providers[1].key.displayName).toBe("Engine");

export type Provider =
 TypeProvider | ValueProvider | ClassProvider | ExistingProvider | FactoryProvider | any[];

// ApiService
export interface TypeProvider extends Type<any> {}

// { provide: ApiService, useClass: ApiService } 
export interface ClassProvider {
 // 用于設(shè)置與依賴對(duì)象關(guān)聯(lián)的Token值，Token值可能是Type、InjectionToken、OpaqueToken的實(shí)例或字符串
 provide: any; 
 useClass: Type<any>;
 // 用于標(biāo)識(shí)是否multiple providers，若是multiple類型，則返回與Token關(guān)聯(lián)的依賴對(duì)象列表
 multi?: boolean; 
}
 
// { provide: 'API_URL', useValue: 'http://my.api.com/v1' }
export interface ValueProvider {
 provide: any;
 useValue: any;
 multi?: boolean;
}
 
// { provide: 'ApiServiceAlias', useExisting: ApiService } 
export interface ExistingProvider {
 provide: any;
 useExisting: any;
 multi?: boolean;
}
 
// { provide: APP_INITIALIZER, useFactory: configFactory, deps: [AppConfig], multi: true }
export interface FactoryProvider {
 provide: any;
 useFactory: Function;
 deps?: any[]; // 用于設(shè)置工廠函數(shù)的依賴對(duì)象
 multi?: boolean;
}

export interface ResolvedReflectiveProvider {
 // 唯一的對(duì)象用來(lái)從ReflectiveInjector中獲取對(duì)象
 key: ReflectiveKey;
 // 工廠函數(shù)用于創(chuàng)建key相關(guān)的依賴對(duì)象 
 resolvedFactories: ResolvedReflectiveFactory[];
 // 標(biāo)識(shí)當(dāng)前的provider是否為multi-provider
 multiProvider: boolean;
}

export class ResolvedReflectiveFactory {
 constructor(
  public factory: Function,
  public dependencies: ReflectiveDependency[]) {}
}

export class ReflectiveDependency {
 constructor(
  public key: ReflectiveKey, 
  public optional: boolean, 
  public visibility: Self|SkipSelf|null) {}

 static fromKey(key: ReflectiveKey): ReflectiveDependency {
 return new ReflectiveDependency(key, false, null);
 }
}

export class ReflectiveKey {
 constructor(public token: Object, public id: number) {
 if (!token) {
  throw new Error('Token must be defined!');
 }
 }
 
 // 返回序列化的token
 get displayName(): string { return stringify(this.token); }

 // 獲取token對(duì)應(yīng)的ReflectiveKey
 static get(token: Object): ReflectiveKey {
 return _globalKeyRegistry.get(resolveForwardRef(token));
 }

 // 獲取系統(tǒng)中已注冊(cè)ReflectiveKey的個(gè)數(shù)
 static get numberOfKeys(): number { return _globalKeyRegistry.numberOfKeys; }
}

const _globalKeyRegistry = new KeyRegistry(); // 創(chuàng)建Key倉(cāng)庫(kù)

export class KeyRegistry {
 private _allKeys = new Map<Object, ReflectiveKey>();

 /**
 * 若token是ReflectiveKey類的實(shí)例，則直接返回。若_allKeys對(duì)象中包含token屬性
 * 則返回token對(duì)應(yīng)的ReflectiveKey對(duì)象。否則創(chuàng)建一個(gè)新的ReflectiveKey對(duì)象，并
 * 保存到_allKeys對(duì)象中
 */
 get(token: Object): ReflectiveKey {
 if (token instanceof ReflectiveKey) return token;

 if (this._allKeys.has(token)) {
  return this._allKeys.get(token) !;
 }

 const newKey = new ReflectiveKey(token, ReflectiveKey.numberOfKeys);
 this._allKeys.set(token, newKey);
 return newKey;
 }

 // 獲取已保存ReflectiveKey的個(gè)數(shù)
 get numberOfKeys(): number { return this._allKeys.size; }
}

export function resolveReflectiveProviders(providers: Provider[])
 : ResolvedReflectiveProvider[] {
  const normalized = _normalizeProviders(providers, []); // 步驟一
  const resolved = normalized.map(resolveReflectiveProvider); // 步驟二
  const resolvedProviderMap = mergeResolvedReflectiveProviders(resolved, new Map()); // 步驟三
  return Array.from(resolvedProviderMap.values()); // 步驟四
}

const normalized = _normalizeProviders(providers, []);

// 規(guī)范化Providers
function _normalizeProviders(providers: Provider[], res: Provider[]): Provider[] {
 providers.forEach(b => {
  // providers: [Type] => providers: [{provide: Type, useClass: Type }]
  if (b instanceof Type) { 
   res.push({provide: b, useClass: b});
  } else if (b && typeof b == 'object' && (b as any).provide !== undefined) {
   res.push(b as NormalizedProvider);
  } else if (b instanceof Array) { // 若b是數(shù)組，則遞歸調(diào)用_normalizeProviders()方法
   _normalizeProviders(b, res);
  } else {
   throw invalidProviderError(b);
  }
 });
 return res;
}

interface NormalizedProvider extends TypeProvider, ValueProvider, ClassProvider, 
  ExistingProvider, FactoryProvider {}

const resolved = normalized.map(resolveReflectiveProvider);

// 解析NormalizedProvider為ResolvedReflectiveProvider
function resolveReflectiveProvider(provider: NormalizedProvider): ResolvedReflectiveProvider {
 return new ResolvedReflectiveProvider_(
   ReflectiveKey.get(provider.provide), [resolveReflectiveFactory(provider)],
   provider.multi || false);
}

// 用于創(chuàng)建已解析的Provider實(shí)例
export class ResolvedReflectiveProvider_ implements ResolvedReflectiveProvider {
 constructor(
   public key: ReflectiveKey, 
   public resolvedFactories: ResolvedReflectiveFactory[],
   public multiProvider: boolean) {}

 get resolvedFactory(): ResolvedReflectiveFactory { return this.resolvedFactories[0]; }
}

// 解析NormalizedProvider對(duì)象，創(chuàng)建ResolvedReflectiveFactory對(duì)象
function resolveReflectiveFactory(provider: NormalizedProvider): ResolvedReflectiveFactory {
 let factoryFn: Function;
 let resolvedDeps: ReflectiveDependency[];
 if (provider.useClass) {
  // { provide: ApiService, useClass: ApiService } 
  const useClass = resolveForwardRef(provider.useClass);
  factoryFn = reflector.factory(useClass);
  resolvedDeps = _dependenciesFor(useClass);
 } else if (provider.useExisting) {
  // { provide: 'ApiServiceAlias', useExisting: ApiService } 
  factoryFn = (aliasInstance: any) => aliasInstance;
  resolvedDeps = [ReflectiveDependency.fromKey(ReflectiveKey.get(provider.useExisting))];
 } else if (provider.useFactory) {
  // { provide: APP_INITIALIZER, useFactory: configFactory, deps: [AppConfig], 
  //   multi: true }
  factoryFn = provider.useFactory;
  resolvedDeps = constructDependencies(provider.useFactory, provider.deps);
 } else {
  // { provide: 'API_URL', useValue: 'http://my.api.com/v1' }
  factoryFn = () => provider.useValue;
  // const _EMPTY_LIST: any[] = [];
  resolvedDeps = _EMPTY_LIST;
 }
 return new ResolvedReflectiveFactory(factoryFn, resolvedDeps);
}

const resolvedProviderMap = mergeResolvedReflectiveProviders(resolved, new Map());

export function mergeResolvedReflectiveProviders(
  providers: ResolvedReflectiveProvider[],
  normalizedProvidersMap: Map<number, ResolvedReflectiveProvider>):
  Map<number, ResolvedReflectiveProvider> {
  for (let i = 0; i < providers.length; i++) {
  const provider = providers[i];
   // 從normalizedProvidersMap對(duì)象中獲取key.id對(duì)應(yīng)的ResolvedReflectiveProvider對(duì)象
  const existing = normalizedProvidersMap.get(provider.key.id);
  if (existing) {
    // 如果當(dāng)前的provider不是multi provider，則拋出異常
   if (provider.multiProvider !== existing.multiProvider) {
    throw mixingMultiProvidersWithRegularProvidersError(existing, provider);
   }
   // 如果當(dāng)前的provider是multi provider，則把當(dāng)前provider的resolvedFactories
   // 列表中的每一項(xiàng)添加到已存在的provider對(duì)象的resolvedFactories列表中。
   if (provider.multiProvider) {
    for (let j = 0; j < provider.resolvedFactories.length; j++) {
     existing.resolvedFactories.push(provider.resolvedFactories[j]);
    }
   } else { 
    // 如果當(dāng)前的provider不是multi provider，則覆蓋已存在的provider
    normalizedProvidersMap.set(provider.key.id, provider);
   }
  } else {
   let resolvedProvider: ResolvedReflectiveProvider;
   // 如果當(dāng)前的provider是multi provider，則創(chuàng)建一個(gè)新的ResolvedReflectiveProvider對(duì)象
   if (provider.multiProvider) {
    resolvedProvider = new ResolvedReflectiveProvider_(
      provider.key, provider.resolvedFactories.slice(), provider.multiProvider);
   } else {
    resolvedProvider = provider;
   }
   // 在normalizedProvidersMap中保存已解析的ResolvedReflectiveProvider對(duì)象
   normalizedProvidersMap.set(provider.key.id, resolvedProvider);
  }
 }
 return normalizedProvidersMap;
}

// resolvedProviderMap的values，創(chuàng)建ResolvedReflectiveProvider[]
Array.from(resolvedProviderMap.values());

/**
 * 基于一個(gè)類似數(shù)組或可迭代對(duì)象創(chuàng)建一個(gè)新的數(shù)組實(shí)例
 * 
 * arrayLike：轉(zhuǎn)換成真實(shí)數(shù)組的類數(shù)組對(duì)象或可遍歷對(duì)象。
 * mapFn(可選)：如果指定了該參數(shù)，則最后生成的數(shù)組會(huì)經(jīng)過(guò)該函數(shù)的加工處理后再返回。
 * thisArg(可選)：執(zhí)行mapFn函數(shù)時(shí)this的值。
 */
Array.from(arrayLike[, mapFn[, thisArg]])

static fromResolvedProviders(providers: ResolvedReflectiveProvider[], parent?: Injector):
 ReflectiveInjector {
  return new ReflectiveInjector_(providers, parent);
}

@Injectable()
class Engine {}

@Injectable()
class Car {
 constructor(public engine:Engine) {}
}

var providers = ReflectiveInjector.resolve([Car, Engine]);
var injector = ReflectiveInjector.fromResolvedProviders(providers);
expect(injector.get(Car) instanceof Car).toBe(true);

// 構(gòu)造次數(shù)
_constructionCounter: number = 0;

// ResolvedReflectiveProvider列表
 public _providers: ResolvedReflectiveProvider[];

// 父級(jí)注入器
 public _parent: Injector|null;

// ReflectiveKey id列表
 keyIds: number[];

// 依賴對(duì)象列表
 objs: any[];

export class ReflectiveInjector_ implements ReflectiveInjector {
 constructor(_providers: ResolvedReflectiveProvider[], _parent?: Injector) {
   this._providers = _providers;
   // 設(shè)置父級(jí)注入器
   this._parent = _parent || null;

   const len = _providers.length;

   this.keyIds = new Array(len);
   this.objs = new Array(len);

   // 初始化keyIds列表和objs對(duì)象列表
   for (let i = 0; i < len; i++) {
    this.keyIds[i] = _providers[i].key.id;
    this.objs[i] = UNDEFINED;
   }
 }
}

const UNDEFINED = new Object();

// 基于Provider列表并創(chuàng)建子注入器
resolveAndCreateChild(providers: Provider[]): ReflectiveInjector {
  const ResolvedReflectiveProviders = ReflectiveInjector.resolve(providers);
  return this.createChildFromResolved(ResolvedReflectiveProviders);
}

// 基于已解析的ResolvedReflectiveProvider列表，創(chuàng)建子注入器
createChildFromResolved(providers: ResolvedReflectiveProvider[]): ReflectiveInjector {
  const inj = new ReflectiveInjector_(providers);
  inj._parent = this;
  return inj;
}

// 獲取當(dāng)前注入器的父級(jí)注入器
get parent(): Injector|null { return this._parent; }

// 獲取token對(duì)應(yīng)的依賴對(duì)象
get(token: any, notFoundValue: any = THROW_IF_NOT_FOUND): any {
  return this._getByKey(ReflectiveKey.get(token), null, notFoundValue);
}

// 根據(jù)ReflectiveKey及visibility可見性，獲取對(duì)應(yīng)的依賴對(duì)象
private _getByKey(key: ReflectiveKey, visibility: Self|SkipSelf|null, notFoundValue: any): any {
  // const INJECTOR_KEY = ReflectiveKey.get(Injector); 
  if (key === INJECTOR_KEY) {
   return this;
  }

  // 判斷該依賴對(duì)象是否使用@Self裝飾器定義，表示從本級(jí)注入器獲取依賴對(duì)象
  if (visibility instanceof Self) {
   return this._getByKeySelf(key, notFoundValue);

  } else {
   // 使用默認(rèn)的方式獲取依賴對(duì)象
   return this._getByKeyDefault(key, notFoundValue, visibility);
  }
}

// 從本級(jí)注入器獲取依賴對(duì)象
 _getByKeySelf(key: ReflectiveKey, notFoundValue: any): any {
  const obj = this._getObjByKeyId(key.id);
  return (obj !== UNDEFINED) ? obj : this._throwOrNull(key, notFoundValue);
}

// 使用默認(rèn)的方式獲取依賴對(duì)象
_getByKeyDefault(key: ReflectiveKey, notFoundValue: any, 
  visibility: Self|SkipSelf|null): any {
  let inj: Injector|null;

  // 判斷該依賴對(duì)象是否使用@SkipSelf裝飾器定義，表示不從本級(jí)注入器獲取依賴對(duì)象
  if (visibility instanceof SkipSelf) {
   inj = this._parent;
  } else {
   inj = this;
  }

  // 從本級(jí)注入器獲取依賴對(duì)象，若本級(jí)獲取不到，則從父級(jí)注入器中查找
  while (inj instanceof ReflectiveInjector_) {
   const inj_ = <ReflectiveInjector_>inj;
   const obj = inj_._getObjByKeyId(key.id);
   if (obj !== UNDEFINED) return obj;
   inj = inj_._parent;
  }
  if (inj !== null) {
   return inj.get(key.token, notFoundValue);
  } else {
   return this._throwOrNull(key, notFoundValue);
  }
}

// 獲取keyId對(duì)應(yīng)的對(duì)象，如依賴對(duì)象未創(chuàng)建，則調(diào)用_new()方法創(chuàng)建一個(gè)，然后保存到
// this.objs對(duì)象列表中
private _getObjByKeyId(keyId: number): any {
  for (let i = 0; i < this.keyIds.length; i++) {
   if (this.keyIds[i] === keyId) {
    // const UNDEFINED = new Object();
    if (this.objs[i] === UNDEFINED) {
     this.objs[i] = this._new(this._providers[i]);
    }
    return this.objs[i];
   }
  }
  return UNDEFINED;
}

// 創(chuàng)建依賴對(duì)象
_new(provider: ResolvedReflectiveProvider): any {
  // 判斷是否存在循環(huán)依賴
  if (this._constructionCounter++ > this._getMaxNumberOfObjects()) {
   throw cyclicDependencyError(this, provider.key);
  }
  return this._instantiateProvider(provider);
}

// 獲取最大的對(duì)象個(gè)數(shù)
private _getMaxNumberOfObjects(): number { return this.objs.length; }

// 根據(jù)已解析的provider創(chuàng)建依賴對(duì)象。若是multi provider則，循環(huán)創(chuàng)建multi provider對(duì)象。 
private _instantiateProvider(provider: ResolvedReflectiveProvider): any {
  if (provider.multiProvider) {
   const res = new Array(provider.resolvedFactories.length);
   for (let i = 0; i < provider.resolvedFactories.length; ++i) {
    res[i] = this._instantiate(provider, provider.resolvedFactories[i]);
   }
   return res;
  } else {
   return this._instantiate(provider, provider.resolvedFactories[0]);
  }
}

// 根據(jù)已解析的provider和已解析的工廠創(chuàng)建依賴對(duì)象
private _instantiate(
   provider: ResolvedReflectiveProvider,
   ResolvedReflectiveFactory: ResolvedReflectiveFactory): any {
  // 獲取對(duì)象工廠函數(shù)
  const factory = ResolvedReflectiveFactory.factory;

  // 獲取工廠函數(shù)所依賴的對(duì)象列表
  let deps: any[];
  try {
   deps = ResolvedReflectiveFactory.dependencies
       .map(dep => this._getByReflectiveDependency(dep));
  } catch (e) {
   if (e.addKey) {
    e.addKey(this, provider.key);
   }
   throw e;
  }

  // 調(diào)用對(duì)象工廠函數(shù)創(chuàng)建依賴對(duì)象
  let obj: any;
  try {
   obj = factory(...deps);
  } catch (e) {
   throw instantiationError(this, e, e.stack, provider.key);
  }
  return obj;
 }

// 若通過(guò)@Optional裝飾器定義該依賴對(duì)象，表示該依賴對(duì)象是可選的，當(dāng)獲取不到時(shí)返回null。
private _getByReflectiveDependency(dep: ReflectiveDependency): any {
  return this._getByKey(dep.key, dep.visibility, dep.optional ? null : THROW_IF_NOT_FOUND);
}