import { Component, OnInit, Input, NgZone } from '@angular/core';
import { SubcomponentVerificationModel } from '../../models/dictionaries/subcomponents-verification.model';
import { InteractionEquationModel } from '../../models/dictionaries/interaction-equation.model';
import { MainPageService } from '../../main-page/main-page.service';
import { Router } from '@angular/router';
import { VariantVerificationModel } from '../../models/parts/variant-verification.model';
import { PageChangeEvent, GridDataResult } from '@progress/kendo-angular-grid';
import { FormGroup, FormBuilder, FormControl, Validators } from '@angular/forms';
import { UnitsConverter } from '../units-converter/units-converter';

declare var $: any;
const unitOptions = ['kN/kNm', 'kN/kNcm', 'kip/kip-ft'];

@Component({
  selector: 'app-variant-verification-grid',
  templateUrl: './variant-verification-grid.component.html',
  styleUrls: ['./variant-verification-grid.component.scss']
})

export class VariantVerificationGridComponent implements OnInit {
  private variantId: string;
  private designBaseId: string;
  public variantsVerificationRawData: VariantVerificationModel[];
  public variantsVerificationDisplayData: VariantVerificationModel[];
  public verificationData: SubcomponentVerificationModel[];
  public methodsData: InteractionEquationModel[];

  public formGroup: FormGroup;
  private unitsConverter = new UnitsConverter();

  public variantVerificationPageSize = 5;
  public skipForvariantsVerificationData = 0;
  public editedVariantVerification: VariantVerificationModel;
  public rowNumber: number;
  public variantVerificationGridView: GridDataResult;
  private variantVerificationOpenedRows: number = 0;
  public currentOpenRow: number;
  public isVariantVerificationGridInChangeMode = false;
  public canAddRowToVariantVerificationGrid = true;
  public isVariantVerificationArrayEmpty: any = true;
  public showRemoveDialog: boolean = false;
  private dataCopy: { verification: string, method: string };
  private removeData: any;
  public displayUnitF: string = 'kN';
  public displayUnitM: string = 'kNm';

  @Input() set VariantId(value: string) {
    this.variantId = value;
    this.loadVerificationData();
  }

  @Input() set DesignBaseId(value: string) {
    this.designBaseId = value;
    this.loadVerificationData();
  }


  constructor(private mainPageService: MainPageService, private router: Router, private zone: NgZone,
    private formBuilder: FormBuilder) { }

  ngOnInit() {
    this.loadData();
    this.mainPageService.deleteVariantVerificationSubject.subscribe((value) => {
      this.variantsVerificationRawData = this.variantsVerificationRawData.filter(x => x._id !== value);
      this.variantsVerificationDisplayData = this.variantsVerificationDisplayData.filter(x => x._id !== value);
    });
  }

  loadVerificationData(): void {
    if (this.designBaseId !== null && this.variantId !== null) {
      this.zone.run(() => {
        this.mainPageService.loadVariantVerifications(this.variantId, this.designBaseId).subscribe((response) => {
          this.variantsVerificationRawData = response;
          this.variantsVerificationDisplayData = Array.from(this.variantsVerificationRawData);
          this.changeDisplayedUnits();
        });
      });
    }
  }

  loadData(): void {
    this.mainPageService.loadAllSubcomponentsForVerification().subscribe((response) => {
      this.verificationData = response;
    });
    this.mainPageService.loadAllInteracionEquations().subscribe((response) => {
      this.methodsData = response;
    });
  }

  saveNewVariantVerification() {
    console.log(this.editedVariantVerification);
    this.mainPageService.addNewVariantVerificationIntoDb(
      JSON.stringify(this.variantsVerificationRawData[this.rowNumber])).subscribe((response) => {
        this.editedVariantVerification._id = response;
        this.variantsVerificationRawData[this.rowNumber] = this.editedVariantVerification;
      });
  }

  saveEditedVariantVerification() {
    console.log(this.variantsVerificationRawData[this.rowNumber]);
    this.mainPageService.updateVariantVerificationInDb(JSON.stringify(this.editedVariantVerification)).subscribe((response) => { });
  }

  deleteVariantVerification(variantVerification) {
    this.mainPageService.removeVariantVerification(variantVerification._id).subscribe((res) => { }, (error: any) => { });
    this.mainPageService.deleteVariantVerificationSubject.next(variantVerification._id);
  }

  public editHandlerForVariantVerificationData({ sender, rowIndex, dataItem }) {
    this.canAddRowToVariantVerificationGrid = false;

    this.dataCopy = {
      verification: this.variantsVerificationDisplayData[rowIndex].verificationId,
      method: this.variantsVerificationDisplayData[rowIndex].methodId
    };
    this.variantVerificationOpenedRows++;
    this.isVariantVerificationGridInChangeMode = true;
    this.currentOpenRow = rowIndex;
    this.formGroup = this.createFormGroupForVariantVerificationData(this.variantsVerificationDisplayData[rowIndex]);
    sender.editRow(rowIndex, this.formGroup);
  }

  public cancelHandlerForVariantVerificationData({ sender, rowIndex }) {
    if (this.isVariantVerificationGridInChangeMode) {
      this.variantVerificationOpenedRows--;
      sender.closeRow(rowIndex);
      if (this.variantVerificationOpenedRows === 0) {
        this.isVariantVerificationGridInChangeMode = false;
      }
      this.variantsVerificationDisplayData[rowIndex].verificationId = this.dataCopy.verification;
      this.variantsVerificationDisplayData[rowIndex].methodId = this.dataCopy.method;
      this.canAddRowToVariantVerificationGrid = true;
    } else {
      this.variantVerificationOpenedRows--;
      this.variantsVerificationDisplayData = this.variantsVerificationDisplayData.filter(
        item => item !== this.variantsVerificationDisplayData[rowIndex]
      );
      sender.closeRow(rowIndex);
      this.canAddRowToVariantVerificationGrid = true;
    }

  }

  public saveHandlerForVariantVerificationData({ sender, formGroup, rowIndex }) {
    this.rowNumber = rowIndex;
    if (this.isVariantVerificationGridInChangeMode) {
      if (
        this.variantsVerificationDisplayData[rowIndex].verificationId !== ''
        && this.variantsVerificationDisplayData[rowIndex].methodId !== ''
        && this.formGroup.valid
      ) {
        this.variantVerificationOpenedRows--;


        this.overwriteDataInGrid(rowIndex, formGroup);
        sender.closeRow(rowIndex);
        this.canAddRowToVariantVerificationGrid = true;
        if (this.variantVerificationOpenedRows === 0) {
          this.isVariantVerificationGridInChangeMode = false;
        }
        this.changeElementUnitsToSI(rowIndex);
        this.editedVariantVerification = this.variantsVerificationRawData[rowIndex];
        this.saveEditedVariantVerification();
      }
    } else {
      if (
        this.variantsVerificationDisplayData[rowIndex].verificationId !== ''
        && this.variantsVerificationDisplayData[rowIndex].methodId !== ''
        && this.formGroup.valid
      ) {
        this.variantVerificationOpenedRows--;


        this.overwriteDataInGrid(rowIndex, formGroup);
        sender.closeRow(rowIndex);
        this.canAddRowToVariantVerificationGrid = true;
        if (this.variantVerificationOpenedRows === 0) {
          this.isVariantVerificationGridInChangeMode = false;
        }
        this.changeElementUnitsToSI(rowIndex);
        this.editedVariantVerification = this.variantsVerificationRawData[rowIndex];
        this.saveNewVariantVerification();
      }

    }

  }

  public addHandlerForVariantVerificationData({ sender }) {
    this.variantVerificationOpenedRows++;
    this.variantsVerificationDisplayData.push(new VariantVerificationModel(this.variantId, this.designBaseId));
    this.canAddRowToVariantVerificationGrid = false;
    this.currentOpenRow = this.variantsVerificationDisplayData.length - 1;
    sender.editRow(
      this.variantsVerificationDisplayData.length - 1,
      this.formGroup = this.createFormGroupForVariantVerificationData(
        this.variantsVerificationDisplayData[this.variantsVerificationDisplayData.length - 1]
      )
    );
  }

  public removeHandler({ sender, dataItem }) {
    this.removeData = dataItem;
  }

  public removeFromVariantVerificationData() {
    let index;
    for (let i = 0; i < this.variantsVerificationDisplayData.length; i++) {
      if (this.variantsVerificationDisplayData[i]._id === this.removeData._id) {
        index = i;
      }
    }
    this.deleteVariantVerification(this.variantsVerificationDisplayData[index]);
  }

  public onUnitChange(unit) {
    if (unit === 'kN/kNm') {
      this.displayUnitF = 'kN';
      this.displayUnitM = 'kNm';
    } else if (unit === 'kN/kNcm') {
      this.displayUnitF = 'kN';
      this.displayUnitM = 'kNcm';
    } else if (unit === 'kip/kip-ft') {
      this.displayUnitF = 'kip';
      this.displayUnitM = 'kip-ft';
    }
    this.changeDisplayedUnits();
  }

  private changeDisplayedUnits() {
    let tempObject: VariantVerificationModel;
    for (let index = 0; index < this.variantsVerificationRawData.length; index++) {
      tempObject = {
        _id: this.variantsVerificationRawData[index]._id,
        variantId: this.variantsVerificationRawData[index].variantId,
        designBaseId: this.variantsVerificationRawData[index].designBaseId,
        verificationId: this.variantsVerificationRawData[index].verificationId,
        methodId: this.variantsVerificationRawData[index].methodId,
        Fx_p:  this.unitsConverter.convertFromSIToUnits(
          this.variantsVerificationRawData[index].Fx_p, this.displayUnitF, 4),
        Fx_m: this.unitsConverter.convertFromSIToUnits(
          this.variantsVerificationRawData[index].Fx_m, this.displayUnitF, 4),
        Fy_p: this.unitsConverter.convertFromSIToUnits(
          this.variantsVerificationRawData[index].Fy_p, this.displayUnitF, 4),
        Fy_m: this.unitsConverter.convertFromSIToUnits(
          this.variantsVerificationRawData[index].Fy_m, this.displayUnitF, 4),
        Fz_p: this.unitsConverter.convertFromSIToUnits(
          this.variantsVerificationRawData[index].Fz_p, this.displayUnitF, 4),
        Fz_m: this.unitsConverter.convertFromSIToUnits(
          this.variantsVerificationRawData[index].Fz_m, this.displayUnitF, 4),
        Mx_p: this.unitsConverter.convertFromSIToUnits(
          this.variantsVerificationRawData[index].Mx_p, this.displayUnitM, 4),
        Mx_m: this.unitsConverter.convertFromSIToUnits(
          this.variantsVerificationRawData[index].Mx_m, this.displayUnitM, 4),
        My_p: this.unitsConverter.convertFromSIToUnits(
          this.variantsVerificationRawData[index].My_p, this.displayUnitM, 4),
        My_m: this.unitsConverter.convertFromSIToUnits(
          this.variantsVerificationRawData[index].My_m, this.displayUnitM, 4),
        Mz_p: this.unitsConverter.convertFromSIToUnits(
          this.variantsVerificationRawData[index].Mz_p, this.displayUnitM, 4),
        Mz_m: this.unitsConverter.convertFromSIToUnits(
          this.variantsVerificationRawData[index].Mz_m, this.displayUnitM, 4),
        Vrd: this.variantsVerificationRawData[index].Vrd,
      };
      this.variantsVerificationDisplayData[index] = Object.assign( {}, tempObject);
    }
  }

  private changeElementUnitsToSI(index: number) {
    const tempObject = {
      _id: this.variantsVerificationDisplayData[index]._id,
      variantId: this.variantsVerificationDisplayData[index].variantId,
      designBaseId: this.variantsVerificationDisplayData[index].designBaseId,
      verificationId: this.variantsVerificationDisplayData[index].verificationId,
      methodId: this.variantsVerificationDisplayData[index].methodId,
      Fx_p:  this.unitsConverter.convertFromUnitsToSI(
        this.variantsVerificationDisplayData[index].Fx_p, this.displayUnitF),
      Fx_m: this.unitsConverter.convertFromUnitsToSI(
        this.variantsVerificationDisplayData[index].Fx_m, this.displayUnitF),
      Fy_p: this.unitsConverter.convertFromUnitsToSI(
        this.variantsVerificationDisplayData[index].Fy_p, this.displayUnitF),
      Fy_m: this.unitsConverter.convertFromUnitsToSI(
        this.variantsVerificationDisplayData[index].Fy_m, this.displayUnitF),
      Fz_p: this.unitsConverter.convertFromUnitsToSI(
        this.variantsVerificationDisplayData[index].Fz_p, this.displayUnitF),
      Fz_m: this.unitsConverter.convertFromUnitsToSI(
        this.variantsVerificationDisplayData[index].Fz_m, this.displayUnitF),
      Mx_p: this.unitsConverter.convertFromUnitsToSI(
        this.variantsVerificationDisplayData[index].Mx_p, this.displayUnitM),
      Mx_m: this.unitsConverter.convertFromUnitsToSI(
        this.variantsVerificationDisplayData[index].Mx_m, this.displayUnitM),
      My_p: this.unitsConverter.convertFromUnitsToSI(
        this.variantsVerificationDisplayData[index].My_p, this.displayUnitM),
      My_m: this.unitsConverter.convertFromUnitsToSI(
        this.variantsVerificationDisplayData[index].My_m, this.displayUnitM),
      Mz_p: this.unitsConverter.convertFromUnitsToSI(
        this.variantsVerificationDisplayData[index].Mz_p, this.displayUnitM),
      Mz_m: this.unitsConverter.convertFromUnitsToSI(
        this.variantsVerificationDisplayData[index].Mz_m, this.displayUnitM),
      Vrd: this.variantsVerificationDisplayData[index].Vrd,
    };
    this.variantsVerificationRawData[index] = Object.assign( {}, tempObject);
  }

  overwriteDataInGrid(rowIndex, formGroup) {
    this.variantsVerificationDisplayData[rowIndex].Fx_m = formGroup.value.Fx_m;
    this.variantsVerificationDisplayData[rowIndex].Fx_p = formGroup.value.Fx_p;
    this.variantsVerificationDisplayData[rowIndex].Fy_m = formGroup.value.Fy_m;
    this.variantsVerificationDisplayData[rowIndex].Fy_p = formGroup.value.Fy_p;
    this.variantsVerificationDisplayData[rowIndex].Fz_m = formGroup.value.Fz_m;
    this.variantsVerificationDisplayData[rowIndex].Fz_p = formGroup.value.Fz_p;
    this.variantsVerificationDisplayData[rowIndex].Mx_m = formGroup.value.Mx_m;
    this.variantsVerificationDisplayData[rowIndex].Mx_p = formGroup.value.Mx_p;
    this.variantsVerificationDisplayData[rowIndex].My_m = formGroup.value.My_m;
    this.variantsVerificationDisplayData[rowIndex].My_p = formGroup.value.My_p;
    this.variantsVerificationDisplayData[rowIndex].Mz_m = formGroup.value.Mz_m;
    this.variantsVerificationDisplayData[rowIndex].Mz_p = formGroup.value.Mz_p;
    this.variantsVerificationDisplayData[rowIndex].Vrd = formGroup.value.Vrd;
  }

  public createFormGroupForVariantVerificationData(dataItem: any): FormGroup {
    return this.formBuilder.group({
      _id: dataItem._id,
      variantId: dataItem.variantId,
      designBaseId: dataItem.designBaseId,
      verificationId: dataItem.verificationId,
      methodId: dataItem.methodId,
      Fx_p: new FormControl(dataItem.Fx_p, Validators.compose([Validators.required,
      Validators.pattern('^\\d+(?:\\.\\d{1,4})?$')])),
      Fx_m: new FormControl(dataItem.Fx_m, Validators.compose([Validators.required,
      Validators.pattern('^\\d+(?:\\.\\d{1,4})?$')])),
      Fy_p: new FormControl(dataItem.Fy_p, Validators.compose([Validators.required,
      Validators.pattern('^\\d+(?:\\.\\d{1,4})?$')])),
      Fy_m: new FormControl(dataItem.Fy_m, Validators.compose([Validators.required,
      Validators.pattern('^\\d+(?:\\.\\d{1,4})?$')])),
      Fz_p: new FormControl(dataItem.Fz_p, Validators.compose([Validators.required,
      Validators.pattern('^\\d+(?:\\.\\d{1,4})?$')])),
      Fz_m: new FormControl(dataItem.Fz_m, Validators.compose([Validators.required,
      Validators.pattern('^\\d+(?:\\.\\d{1,4})?$')])),
      Mx_p: new FormControl(dataItem.Mx_p, Validators.compose([Validators.required,
      Validators.pattern('^\\d+(?:\\.\\d{1,4})?$')])),
      Mx_m: new FormControl(dataItem.Mx_m, Validators.compose([Validators.required,
      Validators.pattern('^\\d+(?:\\.\\d{1,4})?$')])),
      My_p: new FormControl(dataItem.My_p, Validators.compose([Validators.required,
      Validators.pattern('^\\d+(?:\\.\\d{1,4})?$')])),
      My_m: new FormControl(dataItem.My_m, Validators.compose([Validators.required,
      Validators.pattern('^\\d+(?:\\.\\d{1,4})?$')])),
      Mz_p: new FormControl(dataItem.Mz_p, Validators.compose([Validators.required,
      Validators.pattern('^\\d+(?:\\.\\d{1,4})?$')])),
      Mz_m: new FormControl(dataItem.Mz_m, Validators.compose([Validators.required,
      Validators.pattern('^\\d+(?:\\.\\d{1,4})?$')])),
      Vrd: new FormControl(dataItem.Vrd, Validators.compose([Validators.required,
      Validators.pattern('^\\d+(?:\\.\\d{1,4})?$')])),
    });
  }
}