import { RegionBehavior } from '../../RegionBehavior';
import { DependencyObject } from '../../../basecomponentmodel/DependencyObject';
import { SelectorModel } from '../../../models/SelectorModel';
import { tryToConvertType } from '../../../baseframework/ReflectionSupport';
import { InvalidOperationException } from '../../../baseframework/Exceptions';
import {
  CollectionChangeAction,
  CollectionChangeInfo,
  SimpleList,
} from '../../../baseframework/collections';
import { IHostAwareRegionBehavior } from '../../IRegionBehavior';

/**
 * Behavior for the Selector Region added items, and keeps sync the selector items source.
 *
 * @export
 * @class SelectorItemsSourceSyncBehavior
 * @extends {RegionBehavior}
 * @implements {IHostAwareRegionBehavior}
 * @wType Microsoft.Practices.Prism.Regions.Behaviors.SelectorItemsSourceSyncBehavior
 */
export class SelectorItemsSourceSyncBehavior
  extends RegionBehavior
  implements IHostAwareRegionBehavior
{
  /**
   * TabControlRegionSyncBehavior key used to register the behavior in the collection
   *
   * @static
   * @type {string}
   * @memberof SelectorItemsSourceSyncBehavior
   */
  public static readonly BehaviorKey: string =
    'SelectorItemsSourceSyncBehavior';

  private updatingActiveViewsWhenSelectionChanged: boolean = false;

  /**
   * The host control for the region
   *
   * @private
   * @type {TabControlModel}
   * @memberof TabControlRegionSyncBehavior
   */
  private hostControl: SelectorModel = null;

  /**
   * Gets the HostControl
   *
   * @type {DependencyObject}
   * @memberof TabControlRegionSyncBehavior
   */
  get HostControl(): DependencyObject {
    return this.hostControl;
  }

  /**
   * Sets the HostControl
   *
   * @memberof TabControlRegionSyncBehavior
   */
  set HostControl(value: DependencyObject) {
    let newValue: SelectorModel = tryToConvertType<SelectorModel>(
      value,
      SelectorModel
    );
    this.hostControl = newValue;
  }

  /**
   *
   * Override this method to perform the logic after the behavior has been attached.
   *
   */
  public OnAttach(): void {
    if (this.hostControl == null) {
      throw new InvalidOperationException(
        'HostControl Control can not be Null'
      );
    }

    if (this.hostControl.ItemsSource != null) {
      throw new Error('Invalid operation, items control has items source');
    }

    this.SynchronizeItems();
    this.hostControl.SelectionChanged.addHandler((sender, e) =>
      this.OnSelectionChanged(sender, e)
    );
    this.Region.ActiveViews.CollectionChanged.addHandler((sender, e) =>
      this.OnActiveViewsChanged(sender, e)
    );
    this.Region.Views.CollectionChanged.addHandler((sender, e) =>
      this.OnViewsChanged(sender, e)
    );
  }

  private SynchronizeItems(): void {
    let existingItems: SimpleList<any> = new SimpleList<any>();
    if (this.hostControl.items.count > 0) {
      for (let childItem of this.hostControl.items) {
        existingItems.add(childItem);
      }
    }
    for (let view of this.Region.Views) {
      this.hostControl.items.add(view);
    }
    for (let existingItem of existingItems) {
      this.Region.Add(existingItem);
    }
  }

  private OnSelectionChanged(sender: any, e: any): void {
    try {
      this.updatingActiveViewsWhenSelectionChanged = true;
      for (let removedItem of e.RemovedItems) {
        if (
          this.Region.Views.Contains(removedItem) &&
          this.Region.ActiveViews.Contains(removedItem)
        ) {
          this.Region.Deactivate(removedItem);
        }
      }
      for (let addedItem of e.AddedItems) {
        if (
          this.Region.Views.Contains(addedItem) &&
          !this.Region.ActiveViews.Contains(addedItem)
        ) {
          this.Region.Activate(addedItem);
        }
      }
    } finally {
      this.updatingActiveViewsWhenSelectionChanged = false;
    }
  }

  private OnActiveViewsChanged(sender: any, e: CollectionChangeInfo): void {
    if (this.updatingActiveViewsWhenSelectionChanged) {
      return;
    }
    if (e.action == CollectionChangeAction.Add) {
      if (
        this.hostControl.SelectedItem != null &&
        this.hostControl.SelectedItem != e.NewItems.getItem(0) &&
        this.Region.ActiveViews.Contains(this.hostControl.SelectedItem)
      ) {
        this.Region.Deactivate(this.hostControl.SelectedItem);
      }
      this.hostControl.SelectedItem = e.NewItems.getItem(0);
    } else if (
      e.action == CollectionChangeAction.Remove &&
      e.OldItems.contains(this.hostControl.SelectedItem)
    ) {
      this.hostControl.SelectedItem = null;
    }
  }

  private OnViewsChanged(sender: any, e: CollectionChangeInfo): void {
    if (e.action == CollectionChangeAction.Add) {
      let startIndex = e.NewStartingIndex;
      for (let newItem of e.NewItems) {
        this.hostControl.items.insert(startIndex++, newItem);
      }
    } else if (e.action == CollectionChangeAction.Remove) {
      for (let oldItem of e.OldItems) {
        this.hostControl.items.remove(oldItem);
      }
    }
  }
}