import {
  Component,
  OnInit,
  NgZone
} from '@angular/core';
import { MainPageService } from './../../../main-page.service';
import { Subject } from 'rxjs';
import { PipeMaterialConditionModel } from '../../../../models/dictionaries/pipe-material-condition.model';
import { FormBuilder, FormControl, Validators, FormGroup } from '@angular/forms';
import { BasicDictionaryModel } from '../../../../models/dictionaries/basic-dictionary.model';

@Component({
  selector: 'app-pipe-material-managment',
  templateUrl: './pipe-material-managment.component.html',
  styleUrls: ['./pipe-material-managment.component.scss']
})

export class PipeMaterialManagmentComponent implements OnInit {
  public pipeMaterialData: any;
  public isPipeMaterialNew: boolean = false;
  public stateSubject: Subject<any> = new Subject();
  public pipeMaterialConditionsGridData: PipeMaterialConditionModel[] = [];
  public pipeMaterialTypesArray: BasicDictionaryModel[] = [];
  public editedConditionData: PipeMaterialConditionModel;
  public canAddRowToConditionGrid = true;
  private conditionsOpenedGridRows: number = 0;
  public isConditionsGridInChangeMode = false;
  public currentOpenRow: number;
  public formGroup: FormGroup;
  public rowNumber: number;
  private removeData: any;

  constructor(private mainPageService: MainPageService, private formBuilder: FormBuilder) { }

  public ngOnInit(): void {
    this.pipeMaterialConditionsGridData = [];
    this.mainPageService.deletePipeMaterialConditionSubject.subscribe((value) => {
      this.pipeMaterialConditionsGridData = this.pipeMaterialConditionsGridData.filter(x => x._id !== value);
    });
  }

  loadData(): void {
    this.mainPageService.loadPipeMaterialConditions(this.pipeMaterialData.id).subscribe((response) => {
      this.pipeMaterialConditionsGridData = response;
    });
    this.mainPageService.loadAllPipeMaterialTypes().subscribe((response) => {
      this.pipeMaterialTypesArray = response;
    })
  }

  public showManagmentPage(sender, isNew?) {
    this.pipeMaterialData = sender;
    if (isNew) {
      this.isPipeMaterialNew = isNew;
    }
    this.loadData();
  }

  save(): void {
    // this.mainPageService.mysubject.next(this.pipeMaterialData._id);
    this.mainPageService.updatePipeMaterialInDb(JSON.stringify(this.pipeMaterialData)).subscribe(() => { });
    if (this.isPipeMaterialNew) {
      this.isPipeMaterialNew = false;
    }
  }

  returnHandler() {
    if (this.isPipeMaterialNew) {
      this.mainPageService.removePipeMaterial(this.pipeMaterialData._id).subscribe(() => { });
      this.mainPageService.deletePipeMaterialSubject.next(this.pipeMaterialData._id);
      this.pipeMaterialData = null;
    }
    this.stateSubject.next(this.pipeMaterialData);
    this.pipeMaterialData = null;
  }

  public editHandlerForConditionData({ sender, rowIndex }) {
    this.canAddRowToConditionGrid = false;

    this.conditionsOpenedGridRows++;
    this.isConditionsGridInChangeMode = true;
    this.currentOpenRow = rowIndex;
    this.formGroup = this.createFormGroupForConditionsData(this.pipeMaterialConditionsGridData[rowIndex]);
    sender.editRow(rowIndex, this.formGroup);
  }

  public cancelHandlerForConditionData({ sender, rowIndex }) {
    if (this.isConditionsGridInChangeMode) {
      this.conditionsOpenedGridRows--;
      sender.closeRow(rowIndex);
      if (this.conditionsOpenedGridRows === 0) {
        this.isConditionsGridInChangeMode = false;
      }
      this.canAddRowToConditionGrid = true;
    } else {
      this.conditionsOpenedGridRows--;
      this.pipeMaterialConditionsGridData = this.pipeMaterialConditionsGridData.filter(
        item => item !== this.pipeMaterialConditionsGridData[rowIndex]
      );
      sender.closeRow(rowIndex);
      this.canAddRowToConditionGrid = true;
    }

  }

  public saveHandlerForconditionData({ sender, formGroup, rowIndex }) {
    this.rowNumber = rowIndex;
    if (this.isConditionsGridInChangeMode) {
      if (this.formGroup.valid
      ) {
        this.conditionsOpenedGridRows--;

        this.overwriteDataInGrid(rowIndex, formGroup);
        sender.closeRow(rowIndex);
        this.canAddRowToConditionGrid = true;
        if (this.conditionsOpenedGridRows === 0) {
          this.isConditionsGridInChangeMode = false;
        }
        this.editedConditionData = this.pipeMaterialConditionsGridData[rowIndex];
        this.saveEditedConditions();
      }
    } else {
      if (this.formGroup.valid
      ) {
        this.conditionsOpenedGridRows--;


        this.overwriteDataInGrid(rowIndex, formGroup);
        sender.closeRow(rowIndex);
        this.canAddRowToConditionGrid = true;
        if (this.conditionsOpenedGridRows === 0) {
          this.isConditionsGridInChangeMode = false;
        }
        this.editedConditionData = this.pipeMaterialConditionsGridData[rowIndex];
        this.saveNewCondition();
      }

    }

  }

  public addHandlerForConditionData({ sender }) {
    this.conditionsOpenedGridRows++;
    this.pipeMaterialConditionsGridData.push(new PipeMaterialConditionModel(null, null, this.pipeMaterialData.id));
    this.canAddRowToConditionGrid = false;
    this.currentOpenRow = this.pipeMaterialConditionsGridData.length - 1;
    sender.editRow(
      this.pipeMaterialConditionsGridData.length - 1,
      this.formGroup = this.createFormGroupForConditionsData(
        this.pipeMaterialConditionsGridData[this.pipeMaterialConditionsGridData.length - 1]
      )
    );
  }

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

  public createFormGroupForConditionsData(dataItem: any): FormGroup {
    return this.formBuilder.group({
      _id: dataItem._id,
      id: dataItem.id,
      pipeMaterialId: dataItem.pipeMaterialId,
      expansionCoefficient: new FormControl(dataItem.expansionCoefficient, Validators.compose([Validators.required,
      Validators.pattern('^\\d+(?:\\.\\d{1,7})?$')])),
      temperature: new FormControl(dataItem.temperature, Validators.compose([Validators.required,
      Validators.pattern('^\\d+')])),
      elasticityCoeficient: new FormControl(dataItem.elasticityCoeficient, Validators.compose([Validators.required,
      Validators.pattern('^\\d+(?:\\.\\d{1,1})?$')])),
      maxYealdStrength: new FormControl(dataItem.maxYealdStrength, Validators.compose([Validators.required,
      Validators.pattern('^\\d+(?:\\.\\d{1,1})?$')])),
      safetyFactor: new FormControl(dataItem.safetyFactor, Validators.compose([Validators.required,
      Validators.pattern('^\\d+(?:\\.\\d{1,1})?$')])),
      standard: new FormControl(dataItem.standard),
    });
  }

  overwriteDataInGrid(rowIndex, formGroup) {
    this.pipeMaterialConditionsGridData[rowIndex].expansionCoefficient = formGroup.value.expansionCoefficient;
    this.pipeMaterialConditionsGridData[rowIndex].temperature = formGroup.value.temperature;
    this.pipeMaterialConditionsGridData[rowIndex].elasticityCoeficient = formGroup.value.elasticityCoeficient;
    this.pipeMaterialConditionsGridData[rowIndex].maxYealdStrength = formGroup.value.maxYealdStrength;
    this.pipeMaterialConditionsGridData[rowIndex].safetyFactor = formGroup.value.safetyFactor;
    this.pipeMaterialConditionsGridData[rowIndex].standard = formGroup.value.standard;
  }

  saveNewCondition() {
    console.log(this.editedConditionData);
    this.mainPageService.addNewPipeMaterialConditionIntoDb(
      JSON.stringify(this.pipeMaterialConditionsGridData[this.rowNumber])).subscribe((response) => {
        this.editedConditionData._id = response._id;
        this.editedConditionData.id = response.id;
        this.pipeMaterialConditionsGridData[this.rowNumber] = this.editedConditionData;
      });
  }

  saveEditedConditions() {
    console.log(this.pipeMaterialConditionsGridData[this.rowNumber]);
    this.mainPageService.updatePipeMaterialConditionInDb(JSON.stringify(this.editedConditionData)).subscribe(() => { });
  }

  public removeCondition() {
    let index;
    for (let i = 0; i < this.pipeMaterialConditionsGridData.length; i++) {
      if (this.pipeMaterialConditionsGridData[i]._id === this.removeData._id) {
        index = i;
      }
    }
    this.deletePipeMaterialCondition(this.pipeMaterialConditionsGridData[index]);
  }

  deletePipeMaterialCondition(condition) {
    this.mainPageService.removePipeMaterialCondition(condition._id).subscribe(() => { }, () => { });
    this.mainPageService.deletePipeMaterialConditionSubject.next(condition._id);
  }

  savePipeMaterialHandler(valid) {
    if (valid) {
      this.save();
    }
  }

}