import {
  AfterContentInit, Component, Input,
  EventEmitter,
  Output,
  SimpleChanges,
  OnInit,
} from '@angular/core';

import { Subscription } from 'rxjs';

import { DiscoverZone, Zone, Host, Port, Service } from '@overflow/commons-typescript/model/discovery';
import { TreeNode } from 'primeng/primeng';

import { ProbeHost } from '@overflow/commons-typescript/model/probe';

import { Anim } from './animation';
import { DiscoveryNotify } from '../subscriber/discovery.subscriber';

@Component({
  selector: 'of-discovery-result',
  templateUrl: './search-result.component.html',
  animations: Anim
})
export class SearchResultComponent implements OnInit {

  @Input() probeHost: ProbeHost;
  @Input() filterWord: string;
  @Input() filterServices: Service[];

  @Output() stop = new EventEmitter();
  @Input() started: boolean; // Temporary

  discoverySubscription: Subscription;
  zoneNode: TreeNode[] = [];
  hostNode: TreeNode[] = [];
  selectedItems = [];

  tempHostId = 0; // Temporary

  constructor(
  ) {
  }

  ngOnInit(): void {
    this.zoneNode.push({
      label: this.probeHost.probe.cidr,
      type: 'ZONE',
      data: {
      },
      children: this.hostNode,
      expanded: true
    });
  }

  tempHost() {
    const idx = Math.floor(Math.random() * (255));
    const host: Host = {
      id: this.tempHostId++,
      ipv4: '192.168.1.' + idx,
    };
    this.addHost(host);
  }

  tempPort() {
    const idx = Math.floor(Math.random() * (5000));
    const hostId = Math.floor(Math.random() * (this.tempHostId - 1));
    const port: Port = {
      id: idx,
      portNumber: idx,
      portType: idx % 2 === 0 ? 'TCP' : 'UDP',
      host: {
        id: hostId
      },
    };
    this.addPort(port);
  }

  tempService() {
    const randStr = Math.random().toString(36).substr(2, 5);
    const idx = Math.floor(Math.random() * (255));
    const hostId = Math.floor(Math.random() * (this.tempHostId - 1));
    const service: Service = {
      id: idx,
      serviceName: String(randStr),
      port: {
        portNumber: idx,
        portType: idx % 2 === 0 ? 'TCP' : 'UDP',
        host: {
          id: hostId
        }
      }
    };
    this.addService(service);
  }

  addHost(host: Host) {
    const idx = this.findHostIndex(host);
    this.hostNode.splice(idx, 0, {
      type: 'HOST',
      label: host.ipv4,
      data: {
        id: host.id,
        ip: this.convertIPtoNumber(host.ipv4),
        openPorts: []
      },
      expanded: true,
      children: []
    });
  }

  addService(service: Service) {
    const targetHostNode = this.findHostNodeByService(service);
    const idx = this.findServiceIndex(targetHostNode.children, service);
    targetHostNode.children.splice(idx, 0, {
      type: 'SERVICE',
      label: service.serviceName + ' (' + service.port.portNumber + ')',
      data: {
        id: service.id,
        name: service.serviceName,
        portType: service.port.portType,
        portNumber: service.port.portNumber,
      },
    });
  }
  addPort(port: Port) {
    this.hostNode.forEach(node => {
      if (node.data.id === port.host.id) {
        node.data.openPorts.push(port);
        return;
      }
    });
  }

  onTargetSelect(e, data) {
    if (e.checked) {
      this.selectedItems.push(data);
    } else {
      const index = this.selectedItems.indexOf(data);
      this.selectedItems.splice(index, 1);
    }
  }


  findHostIndex(host: Host): number {
    let index = 0;
    this.hostNode.forEach(node => {
      if (node.data.ip < this.convertIPtoNumber(host.ipv4)) {
        index++;
      }
    });
    return index;
  }

  findServiceIndex(serviceNodes: TreeNode[], service: Service) {
    let index = 0;
    serviceNodes.forEach(node => {
      // if (node.data.portNumber < service.port.portNumber) {
      //   index++;
      // }
      if (node.data.name.toUpperCase().localeCompare(service.serviceName.toUpperCase()) === -1) {
        index++;
      }
    });
    return index;
  }

  findHostNodeByService(service: Service) {
    let targetHost = null;
    this.hostNode.forEach((value, i) => {
      if (value.data.ip === this.convertIPtoNumber(service.port.host.ipv4)) {
        targetHost = value;
        return;
      }
    });
    return targetHost;
  }

  convertIPtoNumber(ip: string) {
    return ip.split('.').map((octet, index, array) => {
      // tslint:disable-next-line:radix
      return parseInt(octet) * Math.pow(256, (array.length - index - 1));
    }).reduce((prev, curr) => {
      return prev + curr;
    });
  }

  checkUnhighligtHost(label: string) {
    if (this.filterWord &&
      label.toUpperCase().indexOf(this.filterWord.toUpperCase()) === -1) {
      return true;
    }
    return false;
  }

  checkHighligtService(name: string) {
    // if (this.filterWord &&
    //   name.toUpperCase().indexOf(this.filterWord.toUpperCase()) === -1) {
    //   return true;
    // }
    let highlight = false;
    if (this.filterServices) {
      for (const service of this.filterServices) {
        if (service.serviceName === name) {
          highlight = true;
          break;
        }
      }
    }
    return highlight;
  }
}