import { IModuleCatalog } from './IModuleCatalog';
import { DependencyContainer, Lifecycle } from 'tsyringe';
import { ModuleCatalog } from './ModuleCatalog';
import { RegionManager } from './RegionManager';
import {
  IServiceLocator,
  ServiceLocator,
  ServiceLocatorAdapter,
} from './servicelocation';
import { DependencyObject } from '../basecomponentmodel/DependencyObject';
import { createDIContainer } from './SimpleDIContainer';
import {
  eventAggregatorInjectionToken,
  moduleCatalogInjectionToken,
  moduleManagerInjectionToken,
  regionBehaviorFactoryInjectionToken,
  regionManagerInjectionToken,
  regionViewRegistryInjectionToken,
  serviceLocatorInjectionToken,
} from './injectionTokens';
import { IModuleManager, ModuleManager } from './ModuleManager';
import { RegionAdapterMappings } from './RegionAdapterMappings';
import { ContentControlModel } from '../models/controls/ContentControlModel';
import { AdapterForContentControl } from './adapters/AdapterForContentControl';
import { EventAggregator } from './events/EventAggregator';
import { IEventAggregator } from './events/IEventAggregator';
import {
  RegionBehaviorFactory,
  IRegionBehaviorFactory,
} from './IRegionBehaviorFactory';
import { RegionViewRegistry } from './RegionViewRegistry';
import { TabControlModel, ItemsControlModel, SelectorModel } from '../models';
import { InjectionToken } from 'tsyringe';
import { AdapterForTabControl } from './adapters/AdapterForTabControl';
import { ReflectionHelper } from '../baseframework/ReflectionSupport';
import { AdapterForItemsControl } from './adapters/AdapterForItemsControl';
import { AdapterForSelectorControl } from './adapters/AdapterForSelectorControl';
import { AutoPopulateRegionBehavior } from './adapters/behaviors/AutoPopulateRegionBehavior';
import { regionManagerProperty } from './directives/RegionManager.directive';
import { IRegionManager } from './IRegionManager';

/**
 *  Base class for bootstrappers
 *
 * @export
 * @abstract
 * @class DIBootstrapper
 * @wType Microsoft.Practices.Prism.UnityExtensions.UnityBootstrapper
 */
export abstract class DIBootstrapper {
  /**
   *  Catalog of objects of Modules
   *
   * @memberof DIBootstrapper
   */
  ModuleCatalog: IModuleCatalog;
  /**
   *  Application shell
   *
   * @memberof DIBootstrapper
   */
  Shell: DependencyObject;
  /**
   *  Event Aggregator property
   *
   * @memberof DIBootstrapper
   * @wIgnore
   */
  EventAggregator: IEventAggregator;
  /**
   *  Dependency container used by the bootstrapper
   *
   * @memberof DIBootstrapper
   */
  #container: DependencyContainer = null;
  /**
   *  Dependency Injection container
   *
   * @memberof DIBootstrapper
   */
  get Container(): DependencyContainer {
    if (this.#container == null) {
      this.#container = this.CreateContainer();
    }
    return this.#container;
  }
  set Container(value: DependencyContainer) {
    this.#container = value;
  }

  /**
   *  Configure dependency injection container
   *
   * @memberof DIBootstrapper
   */
  ConfigureContainer(): void {
    this.RegisterIfTypeIsMissing(
      serviceLocatorInjectionToken,
      ServiceLocatorAdapter,
      true
    );
    this.RegisterIfTypeIsMissing(
      regionBehaviorFactoryInjectionToken,
      RegionBehaviorFactory,
      true
    );
    this.RegisterIfTypeIsMissing(
      RegionAdapterMappings,
      RegionAdapterMappings,
      true
    );
    this.RegisterIfTypeIsMissing(
      regionManagerInjectionToken,
      RegionManager,
      true
    );
    this.RegisterIfTypeIsMissing(
      regionViewRegistryInjectionToken,
      RegionViewRegistry,
      true
    );
    this.RegisterIfTypeIsMissing(
      moduleManagerInjectionToken,
      ModuleManager,
      true
    );
    this.RegisterIfTypeIsMissing(
      eventAggregatorInjectionToken,
      EventAggregator,
      true
    );

    if (!this.Container.isRegistered(moduleCatalogInjectionToken)) {
      this.ModuleCatalog = this.CreateModuleCatalog();
      this.Container.registerInstance(
        moduleCatalogInjectionToken,
        this.ModuleCatalog
      );
    }
  }

  /**
   *   Initialize module configuration
   *
   * @memberof DIBootstrapper
   */
  InitializeModules(): void {
    const moduleManager = this.Container.resolve<IModuleManager>(
      moduleManagerInjectionToken
    );
    moduleManager.Run();
  }

  /**
   *  Execute the bootstrapper
   *
   * @memberof DIBootstrapper
   */
  Run(): void {
    this.Container = this.CreateContainer();
    this.ConfigureContainer();
    this.ConfigureServiceLocator();

    this.ConfigureModuleCatalog();

    this.ConfigureRegionAdapterMappings();
    this.ConfigureDefaultRegionBehaviors();

    this.Shell = this.CreateShell();
    if (this.Shell != null) {
      this.Shell.setValue(
        regionManagerProperty,
        this.Container.resolve<IRegionManager>(regionManagerInjectionToken)
      );
      this.InitializeShell();
    }
    this.InitializeModules();
  }

  /**
   *  Configure region adapter mappings
   *
   * @return {*}  {RegionAdapterMappings}
   * @memberof DIBootstrapper
   */
  ConfigureRegionAdapterMappings(): RegionAdapterMappings {
    const result = this.Container.resolve<RegionAdapterMappings>(
      RegionAdapterMappings
    );
    result.RegisterMapping(
      ReflectionHelper.getTypeInfo(ContentControlModel),
      this.Container.resolve<AdapterForContentControl>(AdapterForContentControl)
    );
    result.RegisterMapping(
      ReflectionHelper.getTypeInfo(ItemsControlModel),
      this.Container.resolve<AdapterForItemsControl>(AdapterForItemsControl)
    );
    result.RegisterMapping(
      ReflectionHelper.getTypeInfo(TabControlModel),
      this.Container.resolve<AdapterForTabControl>(AdapterForTabControl)
    );
    result.RegisterMapping(
      ReflectionHelper.getTypeInfo(SelectorModel),
      this.Container.resolve<AdapterForSelectorControl>(
        AdapterForSelectorControl
      )
    );
    return result;
  }

  /**
   * Configures the default region behaviors
   *
   * @returns {IRegionBehaviorFactory}
   * @memberof DIBootstrapper
   */
  ConfigureDefaultRegionBehaviors(): IRegionBehaviorFactory {
    const result = ServiceLocator.current.getInstance<IRegionBehaviorFactory>(
      regionBehaviorFactoryInjectionToken
    );
    if (result != null) {
      result.AddIfMissing(
        AutoPopulateRegionBehavior.BehaviorKey,
        ReflectionHelper.getTypeInfo(AutoPopulateRegionBehavior)
      );
    }
    return result;
  }

  /**
   *  Creates dependency injection container
   *
   * @protected
   * @return {*}  {DependencyContainer}
   * @memberof DIBootstrapper
   */
  protected CreateContainer(): DependencyContainer {
    return createDIContainer();
  }

  /**
   *  Create module catalog
   *
   * @protected
   * @return {*}  {IModuleCatalog}
   * @memberof DIBootstrapper
   */
  protected CreateModuleCatalog(): IModuleCatalog {
    return new ModuleCatalog();
  }

  /**
   *  Configure module catalog
   *
   * @protected
   * @memberof DIBootstrapper
   */
  protected ConfigureModuleCatalog(): void {}

  /**
   *  Create application shell
   *
   * @protected
   * @abstract
   * @return {*}  {DependencyObject} the application shell object
   * @memberof DIBootstrapper
   */
  protected abstract CreateShell(): DependencyObject;

  /**
   * Initializes the shell
   *
   * @protected
   * @type {void}
   * @memberof DIBootstrapper
   */
  protected InitializeShell(): void {}

  /**
   *  Configuration for service locator
   *
   * @protected
   * @memberof DIBootstrapper
   */
  protected ConfigureServiceLocator(): void {
    ServiceLocator.setLocatorProvider(() =>
      this.Container.resolve<IServiceLocator>(serviceLocatorInjectionToken)
    );
  }

  /**
   * Register a type if is not already register in the container
   *
   * @protected
   * @template T
   * @param {InjectionToken<T>} token
   * @param {*} type
   * @param {boolean} registerAsSingleton
   * @memberof DIBootstrapper
   */
  protected RegisterIfTypeIsMissing<T>(
    token: InjectionToken<T>,
    type: any,
    registerAsSingleton: boolean
  ) {
    if (!this.Container.isRegistered(token)) {
      if (registerAsSingleton) {
        this.Container.registerSingleton<T>(token, type);
      } else {
        this.Container.register<T>(token, type, {
          lifecycle: Lifecycle.Transient,
        });
      }
    }
  }
}