import { HttpClient } from '@angular/common/http';
import {
  Component,
  ComponentFactoryResolver,
  ElementRef,
  ViewChild,
} from '@angular/core';
import { SimpleDictionary } from '../baseframework/SimpleDictionary';
import { Uri } from '../baseframework/Uri';
import { Debugger } from '../diagnostics/Debugger';
import { RootVisualDirective } from '../directives/rootvisual.directive';
import { TypeResolver } from '../helpers/TypeResolver';
import { StartupEventArgs } from '../models/events/StartupEventArgs';
import { SubscriptionEvent } from '../utils/SubscriptionEvent';
import { NativeHost } from './NativeHost';
import { ResourceDictionary } from './ResourceDictionary';
/**
 * Class to represent the Application model
 *
 * @export
 * @class Application
 * @wType System.Windows.Application
 */
@Component({
  selector: 'wm-application',
  template: `<div></div>`,
})
export class Application {
  /**
   * The application resources
   *
   * @type {ResourceDictionary}
   * @memberof Application
   * @wProperty Resources
   */
  public resources: ResourceDictionary = new ResourceDictionary();

  @ViewChild(RootVisualDirective)
  rootVisualHost: any;

  public HasElevatedPermissions: boolean = false;

  public readonly IsRunningOutOfBrowser: boolean = false;

  public static Current: Application = new Application(null, null);

  public angularHttpClient: HttpClient;

  public ngAfterViewInit() {
    this.startApp();
  }

  private innerRootVisual: any = null;
  public get RootVisual(): any {
    return this.innerRootVisual;
  }
  public set RootVisual(value: any) {
    this.changeRootVisual(value);
    this.innerRootVisual = value;
  }

  Startup = new SubscriptionEvent<(sender: any, e: StartupEventArgs) => void>();
  Exit = new SubscriptionEvent<(sender: any, e: any) => void>();
  UnhandledException = new SubscriptionEvent<(sender: any, e: any) => void>();
  InstallStateChanged = new SubscriptionEvent<(sender: any, e: any) => void>();

  dialogService: any = null;

  /**
   * Initialize the child elements properties of the component in code behind.
   *
   * @protected
   * @memberof Application
   */
  protected initProperties() {}

  /**
   * Loads the model for the child elements defined in component.
   *
   * @protected
   * @memberof Application
   */
  protected loadModels() {}

  /**
   *  Load component logic
   *
   * @static
   * @param {unknown} component
   * @param {Uri} location
   * @memberof Application
   */
  public static LoadComponent(component: unknown, location: Uri) {
    // Not required implementation
  }

  getResourceByKey(key: string): any {
    let res: any = this.resources?.Get(key) ?? this.resources[key];
    if (typeof res === 'undefined') res = null;
    return res;
  }
  setResource(key: string, obj: any): any {
    return (this.resources[key] = obj);
  }

  public Install(): boolean {
    return false;
  }
  public get InstallState(): any {
    return undefined;
  }

  public changeRootVisual(component: any): any {
    let model: unknown = null;
    if (component.AngularComponentId) {
      model = component;
      component = TypeResolver.getType(component.AngularComponentId);
    }
    if (component instanceof Function) {
      const componentFactory =
        this.componentFactoryResolver.resolveComponentFactory(component);
      const viewContainerRef = (<any>this).rootVisualHost.viewContainerRef;
      viewContainerRef.clear();
      const componentRef = viewContainerRef.createComponent(componentFactory);
      if (model) {
        componentRef.instance.model = model;
      }

      return componentRef;
    } else if (
      component &&
      component.constructor &&
      component.constructor.visualType
    ) {
      const componentRef = this.changeRootVisual(
        component.constructor.visualType
      );
      if (
        componentRef &&
        componentRef.instance &&
        componentRef.instance.performDynamicInit
      ) {
        componentRef.instance.performDynamicInit(component);
      }
    } else {
      alert('ERROR: Cannot set root visual');
    }
  }

  constructor(
    private elementRef: ElementRef,
    private componentFactoryResolver: ComponentFactoryResolver
  ) {}

  /**
   * Starts the application and fire the startup event
   *
   * @memberof Application
   */
  public startApp() {
    const initParamsDict = new SimpleDictionary<string, string>();
    if (this.elementRef.nativeElement.hasAttribute('initparams') === true) {
      var initParams = this.elementRef.nativeElement
        .getAttribute('initparams')
        .split(/\s*,\s*/)
        .map((chunk) => chunk.split('='));
      initParams.forEach((param) => {
        initParamsDict.addEntry(param[0], param[1]);
      });
    }
    const startUpEventArgs = new StartupEventArgs(initParamsDict);
    setTimeout(() => this.Startup.fire([this, startUpEventArgs]));
  }

  public get Host(): NativeHost {
    return new NativeHost();
  }
}