import { ElementRef, Inject, Injectable } from '@angular/core';
import { Observable } from 'rxjs/Observable';
import { Subject } from 'rxjs/Subject';
import { isEmpty } from './fn.utils';
import { MatTree } from './mat-tree';
import { MatTreeController } from './mat-tree-controller';
import { NodeCheckedEvent, NodeUncheckedEvent, NodeIndeterminedEvent, NodeExpandedEvent, NodeCollapsedEvent, LoadNextLevelEvent, AfterTreeInitEvent, MovetoRightEvent } from './mat-tree.events';

@Injectable()
export class MatTreeService {
  public nodeChecked$: Subject<NodeCheckedEvent> = new Subject<NodeCheckedEvent>();
  public nodeUnchecked$: Subject<NodeUncheckedEvent> = new Subject<NodeUncheckedEvent>();
  public nodeIndetermined$: Subject<NodeIndeterminedEvent> = new Subject<NodeIndeterminedEvent>();

  public afterTreeInit$: Subject<AfterTreeInitEvent> = new Subject<AfterTreeInitEvent>();

  public nodeExpanded$: Subject<NodeExpandedEvent> = new Subject<NodeExpandedEvent>();
  public nodeCollapsed$: Subject<NodeCollapsedEvent> = new Subject<NodeCollapsedEvent>();
  public loadNextLevel$: Subject<LoadNextLevelEvent> = new Subject<LoadNextLevelEvent>();

  public move$: Subject<MovetoRightEvent> = new Subject<MovetoRightEvent>();

  public isCheckboxClicked = false;

  public leafs = [];
  // controllers的value改为数组，因为要控制多个
  private controllers: Map<string | number, MatTreeController[]> = new Map();

  public fireNodeChecked(tree: MatTree): void {
    this.nodeChecked$.next(new NodeCheckedEvent(tree));
  }

  public fireNodeUnchecked(tree: MatTree): void {
    this.nodeUnchecked$.next(new NodeUncheckedEvent(tree));
  }

  public fireNodeIndetermined(tree: MatTree): void {
    this.nodeIndetermined$.next(new NodeIndeterminedEvent(tree));
  }

  public setLeaf(tree: MatTree) {
    // if (!this.leafs.find(leaf => leaf.id === tree.id) && tree.isLeaf()) {
    //   this.leafs.push(tree);
    // }
    this.afterTreeInit$.next(new AfterTreeInitEvent(tree));
  }

  public setController(id: string | number, controller: MatTreeController): void {
    if (this.controllers.has(id)) {
      this.controllers.set(id, [controller, ...this.controllers.get(id)]);
    } else {
      this.controllers.set(id, [controller]);
    }
  }

  public deleteController(id: string | number): void {
    if (this.controllers.has(id)) {
      this.controllers.delete(id);
    }
  }

  public getController(id: string | number): MatTreeController[] {
    if (this.controllers.has(id)) {
      return this.controllers.get(id);
    }

    return null;
  }

  public fireNodeSwitchFoldingType(tree: MatTree): void {
    if (tree.isNodeExpanded()) {
      this.fireNodeExpanded(tree);
      if (this.shouldFireLoadNextLevel(tree)) {
        this.fireLoadNextLevel(tree);
      }
    } else if (tree.isNodeCollapsed()) {
      this.fireNodeCollapsed(tree);
    }
  }

  public moveNode(tree: MatTree) {
    this.move$.next(new MovetoRightEvent(tree));
  }

  private fireNodeExpanded(tree: MatTree): void {
    this.nodeExpanded$.next(new NodeExpandedEvent(tree));
  }

  private fireNodeCollapsed(tree: MatTree): void {
    this.nodeCollapsed$.next(new NodeCollapsedEvent(tree));
  }

  private fireLoadNextLevel(tree: MatTree): void {
    this.loadNextLevel$.next(new LoadNextLevelEvent(tree));
  }

  private shouldFireLoadNextLevel(tree: MatTree): boolean {
    const shouldLoadNextLevel =
      tree.node.emitLoadNextLevel &&
      !tree.node.loadChildren &&
      // !tree.childrenAreBeingLoaded() &&
      isEmpty(tree.children);

    if (shouldLoadNextLevel) {
      // tree.loadingChildrenRequested();
    }

    return shouldLoadNextLevel;
  }

  public hasController(id: string | number): boolean {
    return this.controllers.has(id);
  }
}