import {
  Component,
  OnInit,
  ViewChild,
  EventEmitter,
  Output,
  NgZone
} from '@angular/core';
import { Observable } from 'rxjs/Observable';
import { MainPageService } from './../../../main-page.service';
import { Router } from '@angular/router';
import { ConnectorVariantModel } from '../../../../models/parts/connectorVariant.model';
import { FormGroup, FormControl, Validators } from '@angular/forms';
import { list } from './mock-variant-grid-data';
import { mockedPicture } from './mock-picture-base64';
import { mockedStepFile } from './mock-step-file-base64';
import { SystemModel } from '../../../../models/dictionaries/system.model';
import { ShowViewerArgs } from '../../../../models/viewer/ShowViewerArgs.model';
import { CorosiveProtectionModel } from '../../../../models/dictionaries/corosive-protection.model';
import { UniversalConnectorModel, ConnectorType } from '../../../../models/parts/universal-connector.model';
import { DesignBaseModel } from '../../../../models/dictionaries/design-base.model';


@Component({
  selector: 'app-connector-managment',
  templateUrl: './connector-managment.component.html',
  styleUrls: ['./connector-managment.component.scss']
})
export class ConnectorManagmentComponent implements OnInit {
  @ViewChild('fileUploadInput') fileInput;
  @Output() onShowViewer: EventEmitter<ShowViewerArgs> = new EventEmitter();

  public connectorData: any;
  public editedConnector = new UniversalConnectorModel(ConnectorType.Connector);
  public editedVariant = new ConnectorVariantModel();
  public variantTemplateModel = new ConnectorVariantModel();
  public showPicture = false;
  public canOpenGraphicalTool = false;
  private stpConvertTaskId: string;
  public currentVariantTabId = '';
  public currentVariantTab = 0;
  public isStpVisible = false;
  public isPngVisible = false;
  public pictureData: string;
  public systemsArray: SystemModel[] = [];
  public corrosionProtectionsArray: CorosiveProtectionModel[] = [];
  public designBasesArray: DesignBaseModel[] = [];
  public observable: Observable<any>;
  private duplicateMode = false;
  public choosenDesignBase: string;
  public formGroup: FormGroup;
  public variantFormGroup: FormGroup;
  public connectorTypeArray: any[] = [];

  ////////////////////////////////////////// temporary mocked variables
  public mockList: any[] = list;
  public mockedPictureBase64 = mockedPicture;
  public mockedStepFileBase64 = mockedStepFile;
  public variantGridData: any[] = this.mockList[0];
  public headersVariantGrid: string[] = ['Vertification', 'Method', 'Fx+', 'Fx-'];
  public displayedColumns: string[] = ['Vertification', 'Method', 'Fx+', 'Fx-'];
  public variantsList: ConnectorVariantModel[] = [];
  ///////////////////////////////////////////


  constructor(private mainPageService: MainPageService, private zone: NgZone) {
    this.connectorTypeArray = this.mainPageService.getConnectorTypeArray();
   }

  public ngOnInit(): void {
    this.loadData();
  }

  loadData(): void {
    this.mainPageService.loadAllSystems().subscribe((response) => {
      this.systemsArray = response;
    });
    this.mainPageService.loadAllCorosionProtections().subscribe((response) => {
      this.corrosionProtectionsArray = response;
    });
    this.mainPageService.loadAllDesignBases().subscribe((response) => {
      this.designBasesArray = response;
      this.choosenDesignBase = this.designBasesArray[0]._id;
    });
    this.createForm();
    this.createVariantForm();
  }

  loadConnectorVariants() {
    this.mainPageService.loadAllConnectorVariants(this.connectorData._id).subscribe((response) => {
      this.variantsList = response;
      if (this.variantsList.length > 0) {
        Object.assign(this.editedVariant, this.variantsList[this.currentVariantTab]);
      }
      if (this.variantsList.length > 0) {
        this.currentVariantTabId = this.variantsList[this.currentVariantTab]._id;
      }
    });
  }

  showConnector(sender) {
    this.currentVariantTab = 0;
    this.currentVariantTabId = '';
    this.connectorData = sender;
    this.editedConnector = {
      ...this.connectorData
    };
    this.setFilesData(sender);
    this.canOpenGraphicalTool = sender.isProtoConverted === true;
    this.loadConnectorVariants();
  }

  upload(): void {
    this.readThis(this.fileInput.nativeElement.files[0]);
  }

  readThis(inputFile: any): void {
    const file: File = inputFile;
    const myReader: FileReader = new FileReader();
    const scope = this;
    myReader.onloadend = function () {
      if (file.name.includes('.stp') || file.name.includes('.step')) {
        scope.isStpVisible = true;
        scope.sendSTPFile(myReader.result, scope.connectorData._id);
      } else {
        scope.zone.run(() => scope.pictureData = myReader.result);
        scope.isPngVisible = true;
        scope.sendPictureFile(myReader.result, scope.connectorData._id);
      }
    };
    myReader.readAsDataURL(file);
  }

  checkIfStpIsConverted(): void {
    const self = this;
    setTimeout(() => {
      self.mainPageService.checkTaskStatus(self.stpConvertTaskId)
        .subscribe((resp) => {
          if (resp.isFinished === true) {
            self.zone.run(() => self.canOpenGraphicalTool = resp.result);
            // self.canOpenGraphicalTool = resp.result;
          } else {
            self.checkIfStpIsConverted();
          }
        });
    }, 2000);
  }
  sendSTPFile(file, id): void {
    this.canOpenGraphicalTool = false;
    this.mainPageService.sentSTPFileForConnectors(file, id)
      .subscribe((response) => {
        this.connectorData.stepFile = response.fileId;
        this.stpConvertTaskId = response.id;
        console.log(response);
        this.checkIfStpIsConverted();
      },
        (error: any) => {
          console.log(error);
        }
      );
  }
  sendPictureFile(picture, id): void {
    this.mainPageService.sendPicture(picture, id)
      .subscribe((response) => {
        this.connectorData.picture = response.fileId;
      },
        (error: any) => {
          console.log(error);
        }
      );
  }

  openGraphicalTool(): void {
    this.onShowViewer.emit(new ShowViewerArgs(true, this.connectorData._id, 'CONNECTOR', null, this.connectorData.connectorUsageType));
  }

  openVariantGraphicalTool(variantId): void {
    this.onShowViewer.emit(new ShowViewerArgs(true, this.connectorData._id, 'CONNECTOR', variantId, this.connectorData.connectorUsageType));
  }

  save(): void {
    Object.assign(this.connectorData, this.editedConnector);
    // this.mainPageService.mysubject.next(this.connectorData._id);
    this.mainPageService.updateUniversalConnectorInDb(JSON.stringify(this.connectorData)).subscribe(() => { });
  }

  changeVariantTab(id) {
    this.currentVariantTabId = id;
    for (let i = 0; i < this.variantsList.length; i++) {
      if (this.variantsList[i]._id === this.currentVariantTabId) {
        this.currentVariantTab = i;
        Object.assign(this.editedVariant, this.variantsList[this.currentVariantTab]);
      }
    }
  }

  deletePicture() {
    this.pictureData = '';
    this.isPngVisible = false;
    this.mainPageService.deleteFile(this.connectorData.picture).subscribe(() => {
    },
      () => {
      }
    );
    this.connectorData.picture = null;
  }

  deleteStepFile() {
    this.isStpVisible = false;
    this.mainPageService.deleteFile(this.connectorData.stepFile).subscribe(() => {
    },
      () => {
      }
    );
    this.connectorData.stepFile = null;
  }

  setFilesData(connector) {
    if (connector.picture !== undefined && connector.picture !== null && connector.picture !== '') {
      this.isPngVisible = true;
      this.mainPageService.getPicture(connector.picture).subscribe((res) => {
        this.pictureData = res.src;
      },
        (error: any) => {
          console.log(error);
        }
      );
    } else {
      this.pictureData = '';
      this.isPngVisible = false;
    }

    if (connector.stepFile !== undefined && connector.stepFile !== null && connector.stepFile !== '') {
      this.isStpVisible = true;
    } else {
      this.isStpVisible = false;
    }
  }

  deleteConnector() {
    this.mainPageService.removeUniversalConnector(this.connectorData._id).subscribe(() => { }, () => { });
    this.mainPageService.deleteUniversalConnectorSubject.next(this.connectorData._id);
  }

  createNewVariant() {
    this.variantTemplateModel.variantId = this.connectorData._id;
    this.sendVariantToDb(this.variantTemplateModel);
  }

  sendVariantToDb(variant) {
    this.mainPageService.addNewConnectorVariantIntoDb(JSON.stringify(variant))
      .subscribe((response) => {
        console.log(response);
        this.variantsList.push(response);
        if (this.variantsList.length === 1) {
          Object.assign(this.editedVariant, this.variantsList[this.currentVariantTab]);
        }
        if (this.duplicateMode) {
          this.mainPageService.duplicateVariantData(
            this.variantsList[this.currentVariantTab]._id, this.variantsList[this.variantsList.length - 1]._id).subscribe(() => {});
          this.duplicateMode = false;
        }
        this.variantTemplateModel = new ConnectorVariantModel();
        if (this.currentVariantTabId === '') {
          this.currentVariantTabId = this.variantsList[0]._id;
        }
      },
        (error: any) => {
          console.log(error);
        }
      );
  }

  duplicateVariant() {
    this.duplicateMode = true;
    const newVariant = new ConnectorVariantModel();
    Object.assign(newVariant, this.variantsList[this.currentVariantTab]);
    newVariant.name = this.variantTemplateModel.name;
    this.sendVariantToDb(newVariant);
  }

  deleteVariant() {
    this.mainPageService.removeVariant(this.variantsList[this.currentVariantTab]._id).subscribe(() => {
      const idToDelete = this.currentVariantTabId;
      if (this.currentVariantTab === (this.variantsList.length - 1) && this.currentVariantTab !== 0) {
        this.currentVariantTab -= 1;
        this.currentVariantTabId = this.variantsList[this.currentVariantTab]._id;
      }
      else if (this.currentVariantTab === 0 && this.variantsList.length === 1) {
        this.currentVariantTabId = '';
        this.currentVariantTab = 0;
      }
      else {
        this.currentVariantTabId = this.variantsList[this.currentVariantTab + 1]._id;
      }
      this.variantsList = this.variantsList.filter(variant => variant._id !== idToDelete);
      Object.assign(this.editedVariant, this.variantsList[this.currentVariantTab]);
    }, () => { });
  }

  updateVariant() {
    Object.assign(this.variantsList[this.currentVariantTab], this.editedVariant);
    this.mainPageService.updateVariantInDb(JSON.stringify(this.variantsList[this.currentVariantTab])).subscribe(() => { });
  }

  private createForm() {
    this.formGroup = new FormGroup({
      name: new FormControl(this.editedConnector.name, Validators.required),
      articleNumber: new FormControl(this.editedConnector.articleNumber),
      description: new FormControl(this.editedConnector.description),
      system: new FormControl(this.editedConnector.system, Validators.required),
      corrosionProtection: new FormControl(this.editedConnector.corrosionProtection, Validators.required),
      connectorUsageType: new FormControl(this.editedConnector.connectorUsageType, Validators.required),
    });
  }

  public prepareVariantCreate() {
    this.variantTemplateModel = new ConnectorVariantModel();
    this.createVariantForm();
  }

  private createVariantForm() {
    this.variantFormGroup = new FormGroup({
      name: new FormControl(this.variantTemplateModel.name, Validators.required),
      description: new FormControl(this.variantTemplateModel.description),
      system: new FormControl(this.variantTemplateModel.system, Validators.required),
      corrosionProtection: new FormControl(this.variantTemplateModel.corrosionProtection, Validators.required),
    });
  }

}