import {Component, ViewEncapsulation} from "@angular/core";
import {GridOptions} from "ag-grid/main";

import { ServiceObjectService } from '../../../services/service-object.service';
import { ServiceObject } from '../../../models/service-object';
import { EditorComponent } from '../../../helpers/editor.component';
import { RendererComponent } from '../../../helpers/renderer.component';
import { ServiceObjectCreateService } from '../../../services/service-object-create.service';
import { BooleanSelectListService } from '../../../services/boolean-select-list.service';
import { RegionSelectList } from '../../../models/region-select-list';
import { StateCommonSelectList } from '../../../models/state-common-select-list';
import { RoadSelectList } from '../../../models/road-select-list';
import { DepartmentAffiliationList } from '../../../models/department-affiliation-list';
import { BooleanSelectList } from '../../../models/boolean-select-list';
import { SettlementSelectList } from '../../../models/settlement-select-list';

import { routerTransition } from '../../../animations/router.animation';

// only import this if you are using the ag-Grid-Enterprise

@Component({
    selector: 'service-object',
    templateUrl: 'service-object.component.html',
    styleUrls: ['service-object.scss'],
    encapsulation: ViewEncapsulation.None,
})
export class ServiceObjectComponent {

    public showGrid: boolean;
    public rowData: any[];
    public rowCount: string;
    public regions: RegionSelectList[];
    public states: StateCommonSelectList[];
    public departmentAffiliation: DepartmentAffiliationList[];
    public settlements: SettlementSelectList[];
    public roads: RoadSelectList[];
    public boolean: BooleanSelectList[];
    public isLoading: boolean = false;
    public isBootstrapping: boolean = true;
    public isSelected: boolean = true;
    private columnDefs: any[];
    private gridOptions: GridOptions;

    constructor(
        protected service: ServiceObjectService,
        private dataService: ServiceObjectCreateService,
        private booleanService: BooleanSelectListService
    ) {
        this.gridOptions = <GridOptions>{};
      this.gridOptions.enableSorting = true;
      this.showGrid = true;
      this.gridOptions.rowModelType = 'virtual';
      this.booleanService.getModels().then((models) => this.boolean = models);
      this.dataService.getModels().then(models => {
        this.regions = models.regionSelectListDsM as RegionSelectList[];
        this.states = models.stateCommonSelectListDsM as StateCommonSelectList[];
        this.departmentAffiliation = models.departmentAffiliationListDsM as DepartmentAffiliationList[];
        this.settlements = models.settlementSelectListDsM as SettlementSelectList[];
        this.roads = models.roadSelectListDsM as RoadSelectList[];
      }).then(() => {
            this.createColumnDefs();
            this.isBootstrapping = false;
      });
      this.service.getData().then((data) => {
          if (data.length){
            this.rowData = data;
          } else {
            this.rowData = [new ServiceObject];
          }
      }).then(() => {
          this.gridOptions.api.setDatasource(this.setRowData(this.rowData));
          this.gridOptions.api.refreshVirtualPageCache();
      });
    }
    setRowData(allOfTheData) {
      let dataSource = {
          rowCount: null, // behave as infinite scroll
          getRows: function (params) {
              console.log('asking for ' + params.startRow + ' to ' + params.endRow);
              // At this point in your code, you would call the server, using $http if in AngularJS.
              // To make the demo look real, wait for 500ms before returning
              // take a slice of the total rows
              let rowsThisPage = allOfTheData.slice(params.startRow, params.endRow);
              // if on or after the last page, work out the last row.
              let lastRow = -1;
              if (allOfTheData.length <= params.endRow) {
                  lastRow = allOfTheData.length;
              }
              // call the success callback
              params.successCallback(rowsThisPage, lastRow);
          }
      };
      return dataSource;

  }
  onDeleteConfirm(event): void {
    if (window.confirm('Вы уверены что хотите удалить??')) {
      event.confirm.resolve();
    } else {
      event.confirm.reject();
    }
  }
  public addNewRow() {
        this.rowData.unshift(new ServiceObject());
        this.gridOptions.api.setDatasource(this.setRowData(this.rowData));
        this.gridOptions.api.refreshVirtualPageCache();
  }

  private createColumnDefs() {
    this.columnDefs = [
      {
        headerName: '#',
        width: 30,
        checkboxSelection: true,
        suppressSorting: true,
        suppressMenu: true,
        pinned: true
      },
      {
        headerName: 'ID',
        field: 'serviceObjectId',
      },
      {
        headerName: 'Назва дороги',
        field: 'roadId',
        editable: true,
        cellEditorFramework: EditorComponent,
        cellRendererFramework: RendererComponent,
        cellEditorParams: {
          data: this.roads,
          valueCol: 'roadId',
          labelCol: 'name'
        }
      },
      {
        headerName: 'Область',
        field: 'regionId',
        editable: true,
        cellEditorFramework: EditorComponent,
        cellRendererFramework: RendererComponent,
        cellEditorParams: {
          data: this.regions,
          valueCol: 'regionId',
          labelCol: 'name'
        }
      },
      {
        headerName: 'Місцезнаходження, км+ справа',
        field: 'locationRight',
        editable: true,
      },
      {
        headerName: 'Місцезнаходження, км+ зліва',
        field: 'locationLeft',
        editable: true,
      }
    ];
  }

    private onCellClicked($event) {
        console.log('onCellClicked: ' + $event.rowIndex + ' ' + $event.colDef.field);
    }

    private onCellValueChanged($event) {
        if ($event.oldValue !== $event.newValue) {
            let data = JSON.stringify($event.data);
            let id = $event.data.serviceObjectId;
            let result = null;
            if (id) {
                this.isLoading = true;
                result = this.service.update(id, data).then(() => this.isLoading = false);
            } else {
                // Protection of posting new row being already sent.
                if (this.isLoading) {
                    return ;
                }
                this.isLoading = true;
                result = this.service.create(data).then((serviceObject) => {
                    this.rowData[$event.node.rowIndex] = serviceObject;
                    this.gridOptions.api.setDatasource(this.setRowData(this.rowData));
                    this.gridOptions.api.refreshVirtualPageCache();
                    this.isLoading = false;
                });
            }
        }
    }

    private deleteRows() {
        let rows = this.gridOptions.api.getSelectedNodes();
        if (!rows.length) {
            return ;
        }
        rows.forEach(element => {
            let id = element.data.serviceObjectId;
            if (id) {
                this.isLoading = true;
                this.service.delete(id).then(() => this.isLoading = false);
            }
        });
        // Sort in order to protect array from reindexing (remove rear elements first)
        let sorted = rows.sort((a, b) => {
                if (a > b) {
                    return -1;
                } else {
                    return 1;
                }
            });
        sorted.forEach(item => {
            this.rowData.splice(item.rowIndex, 1);
        });
        this.gridOptions.api.setDatasource(this.setRowData(this.rowData));
        this.gridOptions.api.refreshVirtualPageCache();
    }

    private onCellDoubleClicked($event) {
        console.log('onCellDoubleClicked: ' + $event.rowIndex + ' ' + $event.colDef.field);
    }

    private onCellContextMenu($event) {
        console.log('onCellContextMenu: ' + $event.rowIndex + ' ' + $event.colDef.field);
    }

    private onCellFocused($event) {
        console.log('onCellFocused: (' + $event.rowIndex + ',' + $event.colIndex + ')');
    }

    private onRowSelected($event) {
        // taking out, as when we 'select all', it prints to much to the console!!
        // console.log('onRowSelected: ' + $event.node.data.name);
    }

    private onSelectionChanged() {
        console.log('selectionChanged');
    }

    private onBeforeFilterChanged() {
        console.log('beforeFilterChanged');
    }

    private onAfterFilterChanged() {
        console.log('afterFilterChanged');
    }

    private onFilterModified() {
        console.log('onFilterModified');
    }

    private onBeforeSortChanged() {
        console.log('onBeforeSortChanged');
    }

    private onAfterSortChanged() {
        console.log('onAfterSortChanged');
    }

    private onVirtualRowRemoved($event) {
        // because this event gets fired LOTS of times, we don't print it to the
        // console. if you want to see it, just uncomment out this line
        // console.log('onVirtualRowRemoved: ' + $event.rowIndex);
    }

    private onRowClicked($event) {
        console.log('onRowClicked: ' + $event.node.data.name);
    }

    public onQuickFilterChanged($event) {
        this.gridOptions.api.setQuickFilter($event.target.value);
    }

    // here we use one generic event to handle all the column type events.
    // the method just prints the event name
    private onColumnEvent($event) {
        console.log('onColumnEvent: ' + $event);
    }
}
ServiceObject