import {Component, EventEmitter, Input, OnInit, Output} from '@angular/core';
import {GameModel} from "../../project/game-model/GameModel";
import {FlatTreeControl} from "@angular/cdk/tree";
import {MatTreeFlatDataSource, MatTreeFlattener} from "@angular/material/tree";
import {AbstractItemGroup} from "../../project/game-model/inventory/AbstractItemGroup";
import {ConcreteItemGroup} from "../../project/game-model/inventory/ConcreteItemGroup";
import {ModelComponent} from "../../project/game-model/ModelComponent";
import {ModelComponentType} from "../../project/game-model/ModelComponentType";
import {ItemGroup} from "../../project/game-model/inventory/ItemGroup";
import {Item} from "../../project/game-model/inventory/Item";
import {Overview} from "../Overview";

interface FlatNode {
  expandable: boolean,
  name: string,
  level: number,
  type: ModelComponentType
}

@Component({
  selector: 'app-item-overview',
  templateUrl: './item-overview.component.html',
  styleUrl: './item-overview.component.scss'
})
export class ItemOverviewComponent implements OnInit, Overview{

  @Input() gameModel: GameModel | undefined
  @Output() openItemgroupEmitter: EventEmitter<ItemGroup> = new EventEmitter();
  @Output() onOpenItemEditor: EventEmitter<Item> = new EventEmitter();

  private _transformer = (node: ModelComponent, level: number) => {
    if(node instanceof AbstractItemGroup) {
      return {
        expandable: !!node.children && node.children.length > 0,
        name: node.componentName,
        level: level,
        type: ModelComponentType.ITEMGROUP,
      };
    } else if(node instanceof ConcreteItemGroup) {
      return {
        expandable: !!node.items && node.items.length > 0,
        name: node.componentName,
        level: level,
        type: ModelComponentType.ITEMGROUP,
      }
    } else  {
      return {
        expandable: false,
        name: node.componentName,
        level: level,
        type: ModelComponentType.ITEM
      }
    }
  };


  treeControl = new FlatTreeControl<FlatNode>(
    node => node.level,
    node => node.expandable,
  );

  treeFlattener = new MatTreeFlattener(
    this._transformer,
    node => node.level,
    node => node.expandable,
    node => this.getNodeChildren(node)
  );

  dataSource = new MatTreeFlatDataSource(this.treeControl, this.treeFlattener);
  selectedItem: FlatNode | undefined

  hasChild = (_: number, node: FlatNode) => node.expandable;

  getNodeChildren(node: ModelComponent): ModelComponent[] {
    if(node instanceof ConcreteItemGroup) {
      return node.items;
    } else if(node instanceof AbstractItemGroup) {
      return node.children;
    } else {
      return [];
    }
  }

  ngOnInit() {
    this.dataSource.data = this.gameModel!.itemgroups;
  }

  protected readonly ModelComponentType = ModelComponentType;

  onSelectItem(node: FlatNode) {
    this.selectedItem = node;
  }

  openItemEditor(node: FlatNode) {
    if(node.type == ModelComponentType.ITEMGROUP) {
      const itemGroup = GameModel.findItemgroupByName(node.name, this.gameModel!.itemgroups);
      if(itemGroup) {
        this.openItemgroupEmitter.emit(itemGroup);
      }
    } else if(node.type == ModelComponentType.ITEM) {
      const item = this.searchItemByName(node.name);
      if(item !== undefined) {
        this.onOpenItemEditor.emit(item);
      }
    }
  }

  private searchItemByName(itemName: string): Item | undefined {
    let groupQueue: ItemGroup[] = this.gameModel!.itemgroups.concat();
    while(groupQueue.length > 0) {
      const currentGroup = groupQueue.shift()!;

      if(currentGroup instanceof AbstractItemGroup) {
        groupQueue = groupQueue.concat(currentGroup.children);
      } else if(currentGroup instanceof ConcreteItemGroup) {
        const searchResult = currentGroup.items.find(item => item.componentName === itemName);
        if(searchResult != undefined) {
          return searchResult;
        }
      }
    }
    return undefined;
  }

  get selectedModelComponent() {
    if(this.selectedItem) {
      if(this.selectedItem.type === ModelComponentType.ITEMGROUP) {
        let groupQueue: ItemGroup[] = this.gameModel!.itemgroups.concat();
        while(groupQueue.length > 0) {
          const currentGroup = groupQueue.shift()!;

          if(currentGroup.componentName === this.selectedItem.name) {
            return currentGroup;
          }

          if(currentGroup instanceof AbstractItemGroup) {
            groupQueue = groupQueue.concat(currentGroup.children);
          }
        }
      } else {
        return this.searchItemByName(this.selectedItem!.name)
      }
    } else {
      return undefined
    }
  }

  refresh(): void {
    this.dataSource.data = this.gameModel!.itemgroups;
    console.log("Opened Refreshed")
  }

}