import { Cursor } from '../baseframework/Cursor';
import {
  HorizontalAlignment,
  VerticalAlignment,
} from '../models/controls/ContainerEnums';
import { ContextMenuManager } from '../models/controls/ContextMenuManager';
import { Size, SizeChangedEventArgs } from '../models/controls/Size';
import { ThicknessModel } from '../models/controls/ThicknessModel';
import { ToolTipModel } from '../models/controls/ToolTipModel';
import { SubscriptionEvent } from '../utils/SubscriptionEvent';
import { setSingleTimeoutForCurrentEventHandler } from '../utils/TimeoutHelper';
import { Application } from './Application';
import { Dependency } from './Dependency';
import { DependencyObject } from './DependencyObject';
import { DependencyProperty } from './DependencyProperty';
import { DependencyPropertyChangedEventArgs } from './DependencyPropertyChangedEventArgs';
import { ResourceDictionary } from './ResourceDictionary';
import { RuntimeStyleInfo } from './RuntimeStyleInfo';
import { UIElement } from './UIElement';

/**
 * Framework element model
 *
 * @export
 * @class FrameworkElement
 * @extends {UIElement}
 * @wType System.Windows.FrameworkElement
 */
export class FrameworkElement extends UIElement {
  /**
   * ActualHeightProperty dependency property
   *
   * @static
   * @type {DependencyProperty}
   * @memberof FrameworkElement
   */
  static ActualHeightProperty: DependencyProperty = new DependencyProperty(
    'ActualHeight',
    0,
    null
  );

  /**
   * ActualWidthProperty dependency property
   *
   * @static
   * @type {DependencyProperty}
   * @memberof FrameworkElement
   */
  static ActualWidthProperty: DependencyProperty = new DependencyProperty(
    'ActualWidth',
    0,
    null
  );

  /**
   * CursorProperty dependency property
   *
   * @static
   * @type {DependencyProperty}
   * @memberof FrameworkElement
   */
  static CursorProperty: DependencyProperty = new DependencyProperty(
    'Cursor',
    null,
    null
  );

  /**
   * DataContextProperty dependency property
   *
   * @static
   * @type {DependencyProperty}
   * @memberof FrameworkElement
   */
  static DataContextProperty: DependencyProperty = new DependencyProperty(
    'DataContext',
    null,
    FrameworkElement.DataContextCallback
  );

  /**
   * FlowDirectionProperty dependency property
   *
   * @static
   * @type {DependencyProperty}
   * @memberof FrameworkElement
   */
  static FlowDirectionProperty: DependencyProperty = new DependencyProperty(
    'FlowDirection',
    null,
    null
  );

  /**
   * HeightProperty dependency property
   *
   * @static
   * @type {DependencyProperty}
   * @memberof FrameworkElement
   */
  static readonly HeightProperty = new DependencyProperty(
    'Height',
    Number.NaN,
    FrameworkElement.HeightChangeCallback
  );

  /**
   * HorizontalAlignmentProperty dependency property
   *
   * @static
   * @type {DependencyProperty}
   * @memberof FrameworkElement
   */
  static HorizontalAlignmentProperty: DependencyProperty =
    new DependencyProperty(
      'HorizontalAlignment',
      HorizontalAlignment.Stretch,
      null
    );

  /**
   * HorizontalContentAlignment dependency property.
   *
   * @static
   * @type {DependencyProperty}
   * @memberof FrameworkElement
   */
  static readonly HorizontalContentAlignmentProperty: DependencyProperty =
    new DependencyProperty(
      'HorizontalContentAlignment',
      HorizontalAlignment.Center,
      null
    );

  /**
   * IsEnabledProperty dependency property
   *
   * @static
   * @type {DependencyProperty}
   * @memberof FrameworkElement
   * @wIgnore
   */
  static readonly IsEnabledProperty = new DependencyProperty(
    'IsEnabled',
    true,
    FrameworkElement.IsEnabledCallback
  );

  /**
   * LanguageProperty dependency property
   *
   * @static
   * @type {DependencyProperty}
   * @memberof FrameworkElement
   */
  static LanguageProperty: DependencyProperty = new DependencyProperty(
    'Language',
    null,
    null
  );

  /**
   * MarginProperty dependency property
   *
   * @static
   * @type {DependencyProperty}
   * @memberof FrameworkElement
   */
  static MarginProperty: DependencyProperty = new DependencyProperty(
    'Margin',
    null,
    null
  );

  /**
   * MaxHeightProperty dependency property
   *
   * @static
   * @type {DependencyProperty}
   * @memberof FrameworkElement
   */
  static MaxHeightProperty: DependencyProperty = new DependencyProperty(
    'MaxHeight',
    0,
    null
  );

  /**
   * MaxWidthProperty dependency property
   *
   * @static
   * @type {DependencyProperty}
   * @memberof FrameworkElement
   */
  static MaxWidthProperty: DependencyProperty = new DependencyProperty(
    'MaxWidth',
    0,
    null
  );

  /**
   * MinHeightProperty dependency property
   *
   * @static
   * @type {DependencyProperty}
   * @memberof FrameworkElement
   */
  static MinHeightProperty: DependencyProperty = new DependencyProperty(
    'MinHeight',
    0,
    null
  );

  /**
   * MinWidthProperty dependency property
   *
   * @static
   * @type {DependencyProperty}
   * @memberof FrameworkElement
   */
  static MinWidthProperty: DependencyProperty = new DependencyProperty(
    'MinWidth',
    0,
    null
  );

  /**
   * NameProperty dependency property
   *
   * @static
   * @type {DependencyProperty}
   * @memberof FrameworkElement
   */
  static NameProperty: DependencyProperty = new DependencyProperty(
    'Name',
    null,
    null
  );

  /**
   * StyleProperty dependency property
   *
   * @static
   * @type {DependencyProperty}
   * @memberof FrameworkElement
   */
  static StyleProperty: DependencyProperty = new DependencyProperty(
    'Style',
    null,
    FrameworkElement.StyleCallback
  );

  /**
   * TagProperty dependency property
   *
   * @static
   * @type {DependencyProperty}
   * @memberof FrameworkElement
   */
  static TagProperty = new DependencyProperty('Tag', null, null);

  /**
   * VerticalAlignmentProperty dependency property
   *
   * @static
   * @type {DependencyProperty}
   * @memberof FrameworkElement
   */
  static VerticalAlignmentProperty: DependencyProperty = new DependencyProperty(
    'VerticalAlignment',
    VerticalAlignment.Stretch,
    null
  );

  /**
   * VerticalContentAlignment dependency property.
   *
   * @static
   * @type {DependencyProperty}
   * @memberof FrameworkElement
   */
  static VerticalContentAlignmentProperty: DependencyProperty =
    new DependencyProperty(
      'VerticalContentAlignment',
      VerticalAlignment.Center,
      null
    );

  /**
   * WidthProperty dependency property
   *
   * @static
   * @type {DependencyProperty}
   * @memberof FrameworkElement
   * @wProperty WidthProperty
   */
  static WidthProperty: DependencyProperty = new DependencyProperty(
    'Width',
    Number.NaN,
    FrameworkElement.WidthChangeCallback
  );

  private currentStyleChange: string[];
  private sizeChangedPendingTimeout: any;

  /**
   * StyleCallback
   *
   * @static
   * @param {DependencyObject} sender
   * @param {DependencyPropertyChangedEventArgs} args
   * @memberof FrameworkElement
   * @wIgnore
   */
  public static StyleCallback(
    sender: DependencyObject,
    args: DependencyPropertyChangedEventArgs
  ) {
    const newStyle = args.NewValue;
    const frmElement = sender as FrameworkElement;

    if (frmElement == null) {
      return;
    }

    if (args.OldValue != null) {
      for (const s of frmElement.currentStyleChange) {
        if (!frmElement.IsPropertySet(s)) {
          delete frmElement.properties[s];
        }
      }
    }
    frmElement.currentStyleChange = [];
    if (newStyle instanceof RuntimeStyleInfo) {
      for (const setter of newStyle.Setters) {
        frmElement.isEnableSetPropertiesRegistry = false;
        let propertyName = setter.resolvePropertyName();
        if (
          !frmElement.IsPropertySet(propertyName) &&
          setter.Apply(frmElement)
        ) {
          frmElement.currentStyleChange.push(propertyName);
        }
        frmElement.isEnableSetPropertiesRegistry = true;
      }
    }
    frmElement.isDefaultStyleApplied = false;
  }

  /**
   * HeightChange Callback
   * Executed when the Height changes
   *
   * @static
   * @param {DependencyObject} sender
   * @param {DependencyPropertyChangedEventArgs} args
   * @memberof FrameworkElement
   * @wIgnore
   */
  public static HeightChangeCallback(
    sender: DependencyObject,
    args: DependencyPropertyChangedEventArgs
  ) {
    const ctx = sender as any;
    if (ctx.ActualHeight !== args.NewValue) {
      ctx.scheduleFiringSizeChanged();
    }
  }

  /**
   * WidthChange Callback
   * Executed when the Width changes
   *
   * @static
   * @param {DependencyObject} sender
   * @param {DependencyPropertyChangedEventArgs} args
   * @memberof FrameworkElement
   * @wIgnore
   */
  public static WidthChangeCallback(
    sender: DependencyObject,
    args: DependencyPropertyChangedEventArgs
  ) {
    const ctx = sender as any;
    if (ctx.ActualWidth !== args.NewValue) {
      ctx.scheduleFiringSizeChanged();
    }
    if (args.NewValue < 0) {
      ctx.Width = 0;
    }
  }

  /**
   * DataContext Callback
   * Executed when the Width changes
   *
   * @static
   * @param {DependencyObject} sender
   * @param {DependencyPropertyChangedEventArgs} args
   * @memberof FrameworkElement
   * @wIgnore
   */
  public static DataContextCallback(
    sender: DependencyObject,
    args: DependencyPropertyChangedEventArgs
  ) {
    if (sender instanceof FrameworkElement) {
      sender.OnDataContextCallback(args);
    }
  }

  /**
   * IsEnabled dependency property callback
   *
   * @static
   * @param {DependencyObject} sender
   * @param {DependencyPropertyChangedEventArgs} args
   * @memberof FrameworkElement
   * @wIgnore
   */
  public static IsEnabledCallback(
    sender: DependencyObject,
    args: DependencyPropertyChangedEventArgs
  ) {
    if (sender instanceof FrameworkElement) {
      sender.OnIsEnabledChanged(args);
    }
  }
  /**
   * On IsEnabled changed handler
   *
   * @param {DependencyPropertyChangedEventArgs} args
   * @memberof FrameworkElement
   * @wIgnore
   */
  public OnIsEnabledChanged(args: DependencyPropertyChangedEventArgs) {}

  /**
   * Angular Lifecycle Hook
   *
   * @memberof FrameworkElement
   */
  public OnInit(): void {
    /* OnInit Angular Lifecycle hook */
  }

  /**
   * Angular Lifecycle Hook
   *
   * @memberof FrameworkElement
   */
  public AfterContentInit(): void {
    /* AfterContentInit Angular Lifecycle hook */
  }

  /**
   * Angular Lifecycle Hooks
   *
   * @memberof FrameworkElement
   */
  public OnChanges(): void {
    /* OnChanges Angular Lifecycle hook */
  }

  /**
   * Angular Lifecycle Hooks
   *
   * @memberof FrameworkElement
   */
  public DoCheck(): void {
    /* DoCheck Angular Lifecycle hook */
  }

  /**
   * Angular Lifecycle Hooks
   *
   * @memberof FrameworkElement
   */
  public AfterContentChecked(): void {
    /* AfterContentChecked Angular Lifecycle hook */
  }

  /**
   * Angular Lifecycle Hooks
   *
   * @memberof FrameworkElement
   */
  public AfterViewChecked(): void {
    /* AfterViewChecked Angular Lifecycle hook */
  }

  /*
   * Angular Lifecycle Hook
   *
   * @memberof FrameworkElement
   */
  public OnDestroy(): void {
    /* OnDestroy Angular Lifecycle hook */
  }

  /**
   * Angular Lifecycle Hook.
   * According to SL Documentation
   * LayoutUpdated is the last object lifetime event to occur in the sequence before a control is ready for interaction.
   * A setTimeout is set to ensure that it is triggered after everything is resolved.
   *
   * @memberof FrameworkElement
   */
  public AfterViewInit(): void {
    this.fireLoaded();
    setTimeout(() => {
      this.LayoutUpdated.fire([this, null]);
      this.MeasureOverride(new Size(Infinity, Infinity));
    }, 100);
  }

  /**
   * Updates the layout
   *
   * @memberof FrameworkElement
   * @wMethod UpdateLayout
   * @wIgnore
   */
  UpdateLayout(): void {
    super.UpdateLayout();
    this.LayoutUpdated.fire([this, null]);
  }

  /**
   * Opens an instance of the XamContextMenu
   * This is declared here because it can be set as an attached property
   * and the component should know when it has a XamContextMenu setted to be displayed.
   *
   * @param {ContextMenuManager} menu
   * @memberof FrameworkElement
   * @wIgnore
   */
  OpenCtxMenu(menu: ContextMenuManager): void {
    this.ctxMenuManager = menu;
    this.CtxMenuOpened.fire([this, menu]);
  }

  /**
   * Set tooltip component
   *
   * @param {ToolTipModel} tooltip
   * @memberof FrameworkElement
   * @wIgnore
   */
  SetTooltipToModel(tooltip: ToolTipModel): void {
    this.tooltip = tooltip;
    this.ToolTipSet.fire([this, tooltip]);
  }

  /**
   * Measure override method
   * NOTE:
   *      We are not supporting this functionality in angular, this implementation is meant only to avoid runtime exceptions, but any code
   *      that relies on MeasureOverride should be review and analyze for manual changes
   *
   * @param {Size} availableSize
   * @return {*}  {Size}
   * @memberof FrameworkElement
   */
  MeasureOverride(availableSize: Size): Size {
    return new Size(
      availableSize?.Width ?? Infinity,
      availableSize?.Height ?? Infinity
    );
  }

  public Loaded: SubscriptionEvent<(s: any, a: any) => void> =
    new SubscriptionEvent();
  public Unloaded: SubscriptionEvent<(s: any, a: any) => void> =
    new SubscriptionEvent();
  public LayoutUpdated: SubscriptionEvent<(sender: any, e: any) => void> =
    new SubscriptionEvent();

  /**
   * Context menu opened event
   *
   * @memberof FrameworkElement
   * @wIgnore
   */
  public CtxMenuOpened: SubscriptionEvent<(sender: any, e: any) => void> =
    new SubscriptionEvent();

  /**
   * ToolTipSet event
   *
   * @memberof FrameworkElement
   * @wIgnore
   */
  public ToolTipSet: SubscriptionEvent<(sender: any, e: any) => void> =
    new SubscriptionEvent();

  public SizeChanged: SubscriptionEvent<
    (s: any, a: SizeChangedEventArgs) => void
  > = new SubscriptionEvent();
  public name = '';
  /**
   * Flag to determine if the framework element has the docus
   *
   * @type {boolean}
   * @memberof FrameworkElement
   */
  public hasFocus = false;

  /**
   * Gets value indicating if the control is enabled
   *
   * @type {boolean}
   * @memberof FrameworkElement
   * @wNoMap
   * /// TODO check property defined in Control instead of framework element
   */
  @Dependency(FrameworkElement.IsEnabledProperty)
  public IsEnabled: boolean;

  /**
   * Gets or sets the margin
   *
   * @type {ThicknessModel}
   * @memberof FrameworkElement
   */
  @Dependency(FrameworkElement.MarginProperty)
  public Margin: ThicknessModel;
  /**
   * Gets or sets the cursor
   *
   * @type {*}
   * @memberof FrameworkElement
   */
  @Dependency(FrameworkElement.CursorProperty)
  public Cursor: Cursor;
  /**
   * Gets or sets the clip
   *
   * @type {*}
   * @memberof FrameworkElement
   */
  @Dependency(FrameworkElement.ClipProperty)
  public Clip: any;
  /**
   * Gets or sets the flow direction
   *
   * @type {*}
   * @memberof FrameworkElement
   */
  @Dependency(FrameworkElement.FlowDirectionProperty)
  public FlowDirection: any;

  /**
   * Gets or sets the max width
   *
   * @type {number}
   * @memberof FrameworkElement
   * @wProperty MaxWidth
   */
  @Dependency(FrameworkElement.MaxWidthProperty)
  public maxWidth: number;

  /**
   * Gets or sets the min width
   *
   * @type {number}
   * @memberof FrameworkElement
   * @wProperty MinWidth
   */
  @Dependency(FrameworkElement.MinWidthProperty)
  public minWidth: number;

  /**
   * Gets or sets the min height
   *
   * @type {number}
   * @memberof FrameworkElement
   * @wProperty MinHeight
   */
  @Dependency(FrameworkElement.MinHeightProperty)
  public minHeight: number;

  /**
   * Gets or sets max height
   *
   * @type {number}
   * @memberof FrameworkElement
   * @wProperty MaxHeight
   */
  @Dependency(FrameworkElement.MaxHeightProperty)
  public maxHeight: number;

  /**
   * Resources property
   *
   * @type {ResourceDictionary}
   * @memberof FrameworkElement
   * @wProperty Resources
   */
  public resources: ResourceDictionary = new ResourceDictionary();

  /**
   * Instance related to a XamContextMenuComponent
   *
   * @type {ContextMenuManager}
   * @memberof FrameworkElement
   */
  public ctxMenuManager: ContextMenuManager;

  /**
   * Instance related to a tooltip component
   * for this control
   *
   * @type {ToolTipModel}
   * @memberof FrameworkElement
   */
  public tooltip: ToolTipModel = null;

  private parent: FrameworkElement = null;

  #allowDataContextAnchestorSet = true;

  /**
   * Reference to a callback function called whenever the parent have changed.
   *
   * @type {void}
   * @memberof FrameworkElement
   */
  #parentChangeHandler: (prop: string) => void;

  /**
   * Gets or sets the horizontal alignment
   *
   * @type {HorizontalAlignment}
   * @memberof FrameworkElement
   */
  @Dependency(FrameworkElement.HorizontalAlignmentProperty)
  public HorizontalAlignment: HorizontalAlignment;

  /**
   * Gets or sets the horizontal content alignment.
   *
   * @type {HorizontalAlignment}
   * @memberof FrameworkElement
   */
  @Dependency(FrameworkElement.HorizontalContentAlignmentProperty)
  public HorizontalContentAlignment: HorizontalAlignment;

  /**
   * Gets or sets the vertical alignment
   *
   * @type {VerticalAlignment}
   * @memberof FrameworkElement
   */
  @Dependency(FrameworkElement.VerticalAlignmentProperty)
  public VerticalAlignment: VerticalAlignment;

  /**
   * Gets or sets the vertical content alignment.
   *
   * @type {VerticalAlignment}
   * @memberof FrameworkElement
   */
  @Dependency(FrameworkElement.VerticalContentAlignmentProperty)
  public VerticalContentAlignment: VerticalAlignment;

  /**
   * Gets or sets the width
   *
   * @return {*}  {number}
   * @memberof FrameworkElement
   */
  @Dependency(FrameworkElement.WidthProperty)
  public Width: number;

  /**
   * Gets or sets the style
   *
   * @type {RuntimeStyleInfo}
   * @memberof FrameworkElement
   */
  @Dependency(FrameworkElement.StyleProperty)
  public Style: RuntimeStyleInfo;

  #height: number;
  /**
   * Gets or sets the height
   *
   * @return {*}  {number}
   * @memberof FrameworkElement
   */
  @Dependency(FrameworkElement.HeightProperty)
  set Height(value: number) {
    this.#height = value;
  }

  get Height(): number {
    return this.#height;
  }

  /**
   * Flag used to check if it is the first time loading a model or not.
   *
   * @type {boolean}
   * @memberof FrameworkElement
   */
  private isFirstTimeLoad = true;

  /**
   * Gets or sets the dataContext for this model
   *
   * @type {*}
   * @memberof FrameworkElement
   */
  public get DataContext(): any {
    (this.Parent as any)?.refreshDataContext?.();
    return this.getValue(FrameworkElement.DataContextProperty);
  }

  public set DataContext(value: any) {
    this.setValue(FrameworkElement.DataContextProperty, value);
  }

  /**
   * Checks if the model is being loaded for the first time.
   *
   * @memberof FrameworkElement
   * @wIgnore
   */
  get IsFirstTimeLoad(): boolean {
    return this.isFirstTimeLoad;
  }

  /**
   *
   *
   * @memberof FrameworkElement
   * @wIgnore
   */
  set IsFirstTimeLoad(value: boolean) {
    this.isFirstTimeLoad = value;
  }

  /**
   * Parent model for this model
   *
   * @type {FrameworkElement}
   * @memberof FrameworkElement
   */
  public get Parent(): FrameworkElement {
    return this.parent;
  }
  public set Parent(value: FrameworkElement) {
    if (this.parent !== value) {
      if (this.parent && this.#parentChangeHandler) {
        this.parent.change.removeHandler(this.#parentChangeHandler);
        if (value === null) {
          this.setDataContextFromAnchestor(null);
        }
      }
      this.#parentChangeHandler = null;
      this.parent = value;
      this.change.fire(['Parent']);
      if (this.parent) {
        this.tryApplyStyleFromParentOrDefault();
        this.setDataContextFromAnchestor(this.parent);
        this.#parentChangeHandler = (prop: string) => {
          if (prop == 'DataContext') {
            this.setDataContextFromAnchestor(this.parent);
          }
          this.change.fire(['Parent']);
        };
        value.change.addHandler(this.#parentChangeHandler);
      }
    }
  }

  /**
   * Gets or sets the tag
   *
   * @type {*}
   * @memberof FrameworkElement
   */
  @Dependency(FrameworkElement.TagProperty)
  public Tag: any;

  @Dependency(FrameworkElement.ActualHeightProperty)
  public ActualHeight: number;

  @Dependency(FrameworkElement.ActualWidthProperty)
  public ActualWidth: number;

  /**
   * Indicates if the current style is from a default style
   *
   * @protected
   * @type {boolean}
   * @memberof FrameworkElement
   */
  protected isDefaultStyleApplied: boolean;

  GetBindingExpression(dependencyProperty: DependencyProperty): any {
    return this.bindingExpressions.getItem(dependencyProperty.name);
  }

  /**
   * Find an object by its `Name`.
   *
   * @param {string} name
   * @return {*}  {unknown}
   * @memberof FrameworkElement
   */
  public FindName(name: string): unknown {
    if (this.Name === name) {
      return this;
    }
    const count = this.innerGetChildrenCount();
    for (let i = 0; i < count; i++) {
      const child = this.innerGetChild(i);
      if (child && child['Name'] === name) {
        // eslint-disable-line @typescript-eslint/dot-notation
        return child;
      }
      const found =
        child instanceof FrameworkElement ? child.FindName(name) : null;
      if (found) {
        return found;
      }
    }
    return null;
  }

  /**
   * Refresh element binding values
   *
   * @memberof FrameworkElement
   */
  public refreshBindings(): void {}

  /**
   * This method is involved in a `setTimeout` call when a control template is assigned
   * to the current model
   *
   * @memberof FrameworkElement
   */
  public OnApplyTemplate() {}

  /**
   * Clean up any subscription created for user bindings
   *
   * @memberof FrameworkElement
   * @wIgnore
   */
  public CleanupBindingSubscriptions(): void {
    if (this.bindingExpressions && this.bindingExpressions.count > 0) {
      for (const pairs of this.bindingExpressions) {
        pairs[1].CleanupSubscriptions();
      }
    }
  }

  /**
   * Calling CleanupBindingSubscriptions will set bindingExpression into an invalid state, the expressions
   * and bindings still might persist (if the model is not destroyed), yet the subscriptions were cleaned,
   * if this model is re-bind to a new angular component previous bindings and bindingExpressions will required
   * to be recreated to work properly.
   *
   * This happens when the angular component is destroyed but the model still persists, like when an *ngIf is
   * used to hide an item in the DOM, yet the model instance still persist until it gets visible again, the binding
   * and bindingExpression will be the same but their subscriptions are gone.
   *
   * @memberof FrameworkElement
   * @wIgnore
   */
  public RecreateInvalidBindings(): void {
    const bindingExpressions = [...this.bindingExpressions];
    for (const pairs of bindingExpressions) {
      if (pairs[1].InInvalidState) {
        if (pairs[1].Property && pairs[1].ParentBinding) {
          const oldInitializationFlagValue = this.IsInitializingBindings;
          try {
            this.IsInitializingBindings = true;
            this.SetBinding(pairs[1].Property, pairs[1].ParentBinding);
          } finally {
            this.IsInitializingBindings = oldInitializationFlagValue;
          }
        } else {
          console.error(
            'BindingExpression needs to be recreated but some info is missing'
          );
        }
      }
    }
  }

  /**
   *  Retrieves a resource with the given key or with the given property path
   *
   *  Paths are just a collection of properties to be identified. Also static
   *  fields could be accessed using object instances.
   *
   *  @example
   *  let obj = tmp.getApplicationResource('reskey', 'P1', 'P2')
   *
   * @param {string} key the key of the resource
   * @param {...string[]} properties  a collection of property paths
   * @return {*}  {any} the resulting data element
   * @memberof FrameworkElement
   */
  public getApplicationResource(key: string, ...properties: string[]): any {
    let result = this.getResourceByKey(key);
    if (result && properties && properties.length > 0) {
      // eslint-disable-next-line @typescript-eslint/prefer-for-of
      for (let i = 0; i < properties.length; i++) {
        if (result && typeof result[properties[i]] !== 'undefined') {
          // In this case the path fragment refers to an instance field or property
          result = result[properties[i]];
        } else if (
          result &&
          result.constructor &&
          typeof result.constructor[properties[i]] !== 'undefined'
        ) {
          // In this case the path fragment is referenting to a static field or property
          result = result.constructor[properties[i]];
        } else {
          result = null;
          break;
        }
      }
    }
    return result;
  }

  /**
   *  Gets the specific resource by the given key
   *
   * @param {string} key
   * @return {*}  {unknown}
   * @memberof FrameworkElement
   */
  public getResourceByKey(key: string): unknown {
    let resource =
      this.resources?.Get(key) ?? this.Parent?.getResourceByKey(key);
    if (!resource && Application.Current) {
      resource = Application.Current.getResourceByKey(key);
    }
    return resource;
  }

  /**
   * Fire `Loaded` event. The event is fired only once, even if `fireLoaded()`
   * is called multiple times.
   *
   * @memberof FrameworkElement
   */
  public fireLoaded(): void {
    if (this.isFirstTimeLoad) {
      this.Loaded.fire([this, null]);
      this.isFirstTimeLoad = false;
    }
  }

  /**
   *  Raise the `SizeChanged` event
   *
   * @memberof BaseComponent
   * @wIgnore
   */
  public RaiseSizeChangedEvent() {
    const argsEv = new SizeChangedEventArgs();
    argsEv.PreviousSize = this.RenderSize;
    const newSize = new Size(this.ActualWidth, this.ActualHeight);
    this.RenderSize = newSize;
    argsEv.NewSize = newSize;
    this.SizeChanged.fire([this, argsEv]);
  }

  /**
   * Callback action for DataContext property changes
   *
   * @protected
   * @param {DependencyPropertyChangedEventArgs} args
   * @memberof FrameworkElement
   * @wIgnore
   */
  protected OnDataContextCallback(args: DependencyPropertyChangedEventArgs) {
    this.#allowDataContextAnchestorSet = false;
  }

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

  /**
   * Tries to apply style from parent or default
   *
   * @protected
   * @memberof FrameworkElement
   */
  protected tryApplyStyleFromParentOrDefault(): void {
    if (this.Style == null || this.isDefaultStyleApplied) {
      var style = this.getResourceByKey(
        '__DEFAULT_STYLE__' + this.constructor.name.replace(/Model$/, '')
      );
      this.Style = style instanceof RuntimeStyleInfo ? style : null;
      this.isDefaultStyleApplied = this.Style ? true : false;
    }
  }

  /**
   * Sets the datacontext from anchestor when was not directly set to property
   *
   * @private
   * @param {*} dataContext
   * @memberof FrameworkElement
   */
  private setDataContextFromAnchestor(parent: any) {
    if (this.#allowDataContextAnchestorSet) {
      this.DataContext = parent?.DataContext;
      this.#allowDataContextAnchestorSet = true;
    }
  }

  /**
   * Gets the child number `idx` from this `FrameworkElement`.
   *
   * @private
   * @param {number} idx
   * @return {*}  {DependencyObject}
   * @memberof FrameworkElement
   */
  private innerGetChild(idx: number): DependencyObject {
    const parent = this.innerGetChildrenParent('GetChild');
    return parent.GetChild(idx);
  }

  /**
   * Gets the number of children on this `FrameworkElement`.
   *
   * @private
   * @return {*}  {number}
   * @memberof FrameworkElement
   */
  private innerGetChildrenCount(): number {
    const parent = this.innerGetChildrenParent('GetChildrenCount');
    return parent.GetChildrenCount();
  }

  /**
   * Gets the parent from which children should be taken from.
   *
   * @private
   * @param {string} prop
   * @return {*}  {FrameworkElement}
   * @memberof FrameworkElement
   */
  private innerGetChildrenParent(prop: string): FrameworkElement {
    /* eslint-disable @typescript-eslint/dot-notation */
    return this['templateModel'] && this['templateModel'][prop]
      ? this['templateModel']
      : this;
  }

  /**
   * Schedules executing the SizeChanged event
   *
   * @private
   * @memberof FrameworkElement
   */
  private scheduleFiringSizeChanged() {
    if (this.sizeChangedPendingTimeout == null) {
      this.sizeChangedPendingTimeout = setSingleTimeoutForCurrentEventHandler(
        () => {
          if (!isNaN(this.Width)) {
            this.ActualWidth = this.Width;
          }
          if (!isNaN(this.Height)) {
            this.ActualHeight = this.Height;
          }
          this.change.fire(['calculateActualSize']);
          this.RaiseSizeChangedEvent();
          this.sizeChangedPendingTimeout = null;
        }
      );
    }
  }
}