import {
  Component,
  OnInit,
  NgZone
} from '@angular/core';
import { MainPageService } from './../../../main-page.service';
import { Subject } from 'rxjs';
import { FormBuilder, FormControl, Validators, FormGroup } from '@angular/forms';
import { PiperingBossThreadedRodModel } from '../../../../models/parts/pipering-boss-threade-rod.model';

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

export class PiperingBossesManagementComponent implements OnInit {
  public piperingBossData: any;
  public isPiperingBossNew: boolean = false;
  public stateSubject: Subject<any> = new Subject();
  public piperingBossThreadedRodsGridData: PiperingBossThreadedRodModel[];
  public editedThreadedRodData: PiperingBossThreadedRodModel;
  public canAddRowToThreadedRodsGrid = true;
  private threadedRodsOpenedGridRows: number = 0;
  public isThreadedRodsGridInChangeMode = false;
  public currentOpenRow: number;
  public formGroup: FormGroup;
  public rowNumber: number;
  private removeData: PiperingBossThreadedRodModel;
  public threadedRodsData: any[] = [];

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

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

  loadData(): void {
    this.mainPageService.loadPiperingBossThreadedRods(this.piperingBossData.id).subscribe((response) => {
      this.piperingBossThreadedRodsGridData = response;
    });
    this.mainPageService.loadAllThreadedRods().subscribe((response) => {
      this.threadedRodsData = response;
    })
  }

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

  save(): void {
    this.mainPageService.updatePiperingBossInDb(JSON.stringify(this.piperingBossData)).subscribe(() => { });
    if (this.isPiperingBossNew) {
      this.isPiperingBossNew = false;
    }
  }

  returnHandler() {
    if (this.isPiperingBossNew) {
      this.mainPageService.removePiperingBoss(this.piperingBossData._id).subscribe(() => { });
      this.mainPageService.deletePipeSubject.next(this.piperingBossData._id);
      this.piperingBossData = null;
    }
    this.stateSubject.next(this.piperingBossData);
    this.piperingBossData = null;
  }

  public editHandlerForThreadedRodData({ sender, rowIndex }) {
    this.canAddRowToThreadedRodsGrid = false;

    this.threadedRodsOpenedGridRows++;
    this.isThreadedRodsGridInChangeMode = true;
    this.currentOpenRow = rowIndex;
    this.formGroup = this.createFormGroupForThreadedRodData(this.piperingBossThreadedRodsGridData[rowIndex]);
    sender.editRow(rowIndex, this.formGroup);
  }

  public cancelHandlerForThreadedRodData({ sender, rowIndex }) {
    if (this.isThreadedRodsGridInChangeMode) {
      this.threadedRodsOpenedGridRows--;
      sender.closeRow(rowIndex);
      if (this.threadedRodsOpenedGridRows === 0) {
        this.isThreadedRodsGridInChangeMode = false;
      }
      this.canAddRowToThreadedRodsGrid = true;
    } else {
      this.threadedRodsOpenedGridRows--;
      this.piperingBossThreadedRodsGridData = this.piperingBossThreadedRodsGridData.filter(
        item => item !== this.piperingBossThreadedRodsGridData[rowIndex]
      );
      sender.closeRow(rowIndex);
      this.canAddRowToThreadedRodsGrid = true;
    }

  }

  public saveHandlerForThreadedRodData({ sender, formGroup, rowIndex }) {
    this.rowNumber = rowIndex;
    if (this.isThreadedRodsGridInChangeMode) {
      if (this.formGroup.valid
      ) {
        this.threadedRodsOpenedGridRows--;

        this.overwriteDataInGrid(rowIndex, formGroup);
        sender.closeRow(rowIndex);
        this.canAddRowToThreadedRodsGrid = true;
        if (this.threadedRodsOpenedGridRows === 0) {
          this.isThreadedRodsGridInChangeMode = false;
        }
        this.editedThreadedRodData = this.piperingBossThreadedRodsGridData[rowIndex];
        this.saveEditedThreadedRod();
      }
    } else {
      if (this.formGroup.valid
      ) {
        this.threadedRodsOpenedGridRows--;


        this.overwriteDataInGrid(rowIndex, formGroup);
        sender.closeRow(rowIndex);
        this.canAddRowToThreadedRodsGrid = true;
        if (this.threadedRodsOpenedGridRows === 0) {
          this.isThreadedRodsGridInChangeMode = false;
        }
        this.editedThreadedRodData = this.piperingBossThreadedRodsGridData[rowIndex];
        this.saveNewThreadedRod();
      }
    }
  }

  public addHandlerForThreadedRodData({ sender }) {
    this.threadedRodsOpenedGridRows++;
    this.piperingBossThreadedRodsGridData.push(new PiperingBossThreadedRodModel());
    this.piperingBossThreadedRodsGridData[this.piperingBossThreadedRodsGridData.length - 1].piperingBossId = this.piperingBossData.id;
    this.canAddRowToThreadedRodsGrid = false;
    this.currentOpenRow = this.piperingBossThreadedRodsGridData.length - 1;
    sender.editRow(
      this.piperingBossThreadedRodsGridData.length - 1,
      this.formGroup = this.createFormGroupForThreadedRodData(
        this.piperingBossThreadedRodsGridData[this.piperingBossThreadedRodsGridData.length - 1]
      )
    );
  }

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

  public createFormGroupForThreadedRodData(dataItem: PiperingBossThreadedRodModel): FormGroup {
    return this.formBuilder.group({
      _id: dataItem._id,
      id: dataItem.id,
      piperingBossId: dataItem.piperingBossId,
      threadedRodId: dataItem.threadedRodId,
      depth: new FormControl(dataItem.depth, Validators.compose([
        Validators.pattern('^\\d+(?:\\.\\d{1,1})?$')]))
    });
  }

  overwriteDataInGrid(rowIndex, formGroup) {
    // this.piperingBossThreadedRodsGridData[rowIndex].threadedRodId = formGroup.value.threadedRodId;
    this.piperingBossThreadedRodsGridData[rowIndex].threadedRodName = 
      this.threadedRodsData.find(x => x.id == this.piperingBossThreadedRodsGridData[rowIndex].threadedRodId).name;
    this.piperingBossThreadedRodsGridData[rowIndex].depth = formGroup.value.depth;
  }

  saveNewThreadedRod() {
    console.log(this.editedThreadedRodData);
    this.mainPageService.addNewPiperingBossThreadedRodIntoDb(
      JSON.stringify(this.piperingBossThreadedRodsGridData[this.rowNumber])).subscribe((response) => {
        this.editedThreadedRodData._id = response._id;
        this.editedThreadedRodData.id = response.id;
        this.piperingBossThreadedRodsGridData[this.rowNumber] = this.editedThreadedRodData;
      });
  }

  saveEditedThreadedRod() {
    console.log(this.piperingBossThreadedRodsGridData[this.rowNumber]);
    this.mainPageService.updatePiperingBossThreadedRodInDb(JSON.stringify(this.editedThreadedRodData)).subscribe(() => { });
  }

  public removeSize() {
    let index;
    for (let i = 0; i < this.piperingBossThreadedRodsGridData.length; i++) {
      if (this.piperingBossThreadedRodsGridData[i]._id === this.removeData._id) {
        index = i;
      }
    }
    this.deleteThreadedRod(this.piperingBossThreadedRodsGridData[index]);
  }

  deleteThreadedRod(threadedRod) {
    this.mainPageService.removePipeSize(threadedRod._id).subscribe(() => { }, () => { });
    this.mainPageService.deletePiperingBossThreadedRodSubject.next(threadedRod._id);
  }
}