import { Component, EventEmitter, Input, OnInit, Output, ViewChild, ElementRef, AfterViewInit } from '@angular/core';
import { ItemChange } from '@progress/kendo-angular-charts/common/collection.service';
import { GridDataResult } from '@progress/kendo-angular-grid';
import {
  process,
  State,
  aggregateBy,
  AggregateResult,
  AggregateDescriptor,
} from "@progress/kendo-data-query";
import { UserNotificationService } from 'projects/compass-minerals/src/public-api';
import { sum } from 'ramda';
import { OpportunityRelease, OpportunityReleaseAgreementNote } from '../../models/opportunity-model';
import { OpportunityReleaseLineCalculatedPricing, OpportunityReleaseLineCalculatedPricingDto } from '../../models/releaselinedepotcostingdto.model';
import { OpportunityReleaseService } from '../../services/opportunity-release.service';
import $ from 'jquery';
import { ContentScrollEvent, GridComponent } from '@progress/kendo-angular-grid';

export interface IElementRef {
  element: Element,
  [key: string]: any
}

@Component({
  selector: 'app-releaseline-pricing-details',
  styles: [`
  >>> .k-grid, >>> .k-grid .k-button {font-size:12px;} 
  >>> .k-grid td, >>> .k-grid th {padding:0;} >>>
  app-releaseline-pricing-details .hide-scrollbar > * {
    margin-right: -7px;
}
`],
  templateUrl: './releaseline-pricing-details.component.html',
  styleUrls: ['./releaseline-pricing-details.component.scss'],

  template: `
  <app-grid-sync [gridDataChanged]="dataChange$ | async">
      <app-releaseline-pricing-details
          *ngFor="let gridDataSet of dataSet; last as isLast"
          [data]="gridDataSet"
          [hideScrollbar]="!isLast">
      </app-releaseline-pricing-details>
  </app-grid-sync>
`
})
export class ReleaselinePricingDetailsComponent implements OnInit,  AfterViewInit, IElementRef {
  releaseInfo:OpportunityRelease;
  @Input() agreementComments: OpportunityReleaseAgreementNote[];
  public linesInfo: OpportunityReleaseLineCalculatedPricing[];
  public deliveredLines : OpportunityReleaseLineCalculatedPricing[];
  public pickupLines : OpportunityReleaseLineCalculatedPricing[];
  @Input() releaseId: number;
  @Output() showAwardingBtn = new EventEmitter();
  @Input() data: any[];
  @Input() hideScrollbar: boolean = true;
  @Output() contentScroll: EventEmitter<ContentScrollEvent>; //The event we'll listen to
  @ViewChild(GridComponent, { static: true }) gridEl: GridComponent; //Our actual kendo grid reference
  public element: Element; //Part of IElementRef, so the sync functions have something to reference


  public gridData: GridDataResult;
  public gridSummaryData: GridDataResult;

  isDelivered: boolean = false;
  isPickup: boolean = false;
  public format = "c2";
  public percentFormat = "p";

  public state: State = {
    skip: 0,
    take: 5,
    filter: {
      logic: "and",
      filters: [],
    },
  };


  public total: AggregateResult;

  constructor(public opportunityReleaseService: OpportunityReleaseService,
    private notificationService: UserNotificationService) { }

    ngAfterViewInit(): void {
      this.contentScroll = this.gridEl.contentScroll; //use the kendo grid's native scroll event
  }

  ngOnInit(): void {
    this.loadReleaseDetails();
    this.loadReleaseLinesPricingInfo();
    

  }
  public loadReleaseLinesPricingInfo() {
    this.opportunityReleaseService.getOpportunityReleaseLinesPricings(this.releaseId).subscribe(x => {
      if (x) {
        this.linesInfo = x;
        this.deliveredLines = this.linesInfo.filter(y=>y.isDelivered);
        this.pickupLines = this.linesInfo.filter(y=>(!y.isDelivered));
        this.linesInfo.forEach((item, idx) => {
          if(item.isDelivered){
            this.isDelivered=true;
          }else{
            this.isPickup=true;
          }
        });
        this.gridData = process(this.linesInfo, this.state);
        ///load summary data;
        let summaryRow = new OpportunityReleaseLineCalculatedPricing();
        summaryRow.gsp = 0;
        summaryRow.gsP_Change = 0.0;
        summaryRow.margin = 0;
        let summaryData = [summaryRow];
        this.gridSummaryData = process(summaryData, this.state);

        /// setup the margin values for input fields.
        this.ongspChange(null);
        /// calculate the avg for remaining fields.
        this.calculateAvg();

      }
    });
    
  }

  
  public selectionChanged(){
    if(this.isDelivered && this.isPickup){
      this.gridData = process(this.linesInfo, this.state);
    }else if(this.isDelivered){
      this.gridData = process(this.deliveredLines, this.state);
    }else if(this.isPickup){
      this.gridData = process(this.pickupLines, this.state);
    }else{
      this.gridData = process([], this.state);
    }
    
        ///load summary data;
        let summaryRow = new OpportunityReleaseLineCalculatedPricing();
        summaryRow.gsp = 0;
        summaryRow.gsP_Change = 0.0;
        summaryRow.margin = 0;
        let summaryData = [summaryRow];
        this.gridSummaryData = process(summaryData, this.state);

        /// setup the margin values for input fields.
        this.ongspChange(null);
        /// calculate the avg for remaining fields.
        this.calculateAvg();
  }
  
  public loadReleaseDetails() {
    this.opportunityReleaseService.getRelease(this.releaseId).subscribe(x => {
      if (x) {
        this.releaseInfo = x;
        console.log(this.releaseInfo);
        
          }
    });
  }
  public saveData() {
    var payload = new OpportunityReleaseLineCalculatedPricingDto();
    payload.releaseId = this.releaseId;
    payload.opportunityReleaseLineCalculatedPricingItems = this.linesInfo;
    this.opportunityReleaseService.lockOpportunityReleaseLinesPricings(payload).subscribe(x => {
      if (x) {
        this.showAwardingBtn.emit();
        this.notificationService.success("Pricing details saved successfullly.");
      }
    });
  }

  ///change events of data.
  public ongspChange(value: string): void {
    if(!isNaN(parseInt(value))){
      let gspSum = 0;
      this.gridData.data.forEach(item => {
        if (!isNaN(parseInt(item.gsp))) {
          gspSum += parseInt(item.gsp);
  
          if(item.lYGSP && item.gsp){
            item.gsP_Change=(((item.gsp-item.lYGSP)/item.lYGSP)*100)
          }else{
            item.gsP_Change=0;
          }
          item.margin = parseFloat(item.gsp)-parseFloat(item.totalCost);
        }
      });
      let summaryRecord = this.gridSummaryData.data[0];
      summaryRecord.gsp = (gspSum / this.gridData.data.length);
      ///calculate gsp % change
      let gsppercSum = 0;
      this.gridData.data.forEach(item => {
        if (!isNaN(parseInt(item.gsP_Change))) {
          gsppercSum += parseInt(item.gsP_Change);
        }
      });
      
      summaryRecord.gsP_Change = (gsppercSum / this.gridData.data.length);
      ///calculate margin
      let marginSum = 0;
      this.gridData.data.forEach(item => {
        if (!isNaN(parseInt(item.margin))) {
          marginSum += parseInt(item.margin);
        }
      });
      
      summaryRecord.margin = (marginSum / this.gridData.data.length);
    }
  }
  public ongspPerctChange(value: string): void {
    let sumVal =0;
    if(!isNaN(parseInt(value))){
      this.gridData.data.forEach(item => {
        if (!isNaN(parseInt(item.gsP_Change))) {
          if(item.lYGSP && item.gsP_Change){
            item.gsp=(((item.gsP_Change*item.lYGSP)/100)+item.lYGSP);
            sumVal+= parseFloat(item.gsp);
            item.margin = parseFloat(item.gsp)-parseFloat(item.totalCost);
          }
          if(item.lYGSP && item.gsp){
            item.gsP_Change=(((item.gsp-item.lYGSP)/item.lYGSP)*100)
          }
        }
      });
      let summaryRecord = this.gridSummaryData.data[0];
      summaryRecord.gsp = (sumVal / this.gridData.data.length);
      ///calculate gsp % change
      let gsppercSum = 0;
      this.gridData.data.forEach(item => {
        if (!isNaN(parseInt(item.gsP_Change))) {
          gsppercSum += parseInt(item.gsP_Change);
        }
      });
      
      summaryRecord.gsP_Change = (gsppercSum / this.gridData.data.length);
      ///calculate margin
      let marginSum = 0;
      this.gridData.data.forEach(item => {
        if (!isNaN(parseInt(item.margin))) {
          marginSum += parseInt(item.margin);
        }
      });
      
      summaryRecord.margin = (marginSum / this.gridData.data.length);
    }
  }
  public onmarginChange(value: string): void {
    let sumVal =0;
    if(!isNaN(parseInt(value))){
      this.gridData.data.forEach(item => {
        if (!isNaN(parseInt(item.margin))) {
          if(item.margin){
            item.gsp= parseInt(item.margin)+parseInt(item.totalCost);
            sumVal+= parseFloat(item.gsp);
          }    
          if(item.lYGSP && item.gsp){
            item.gsP_Change=(((item.gsp-item.lYGSP)/item.lYGSP)*100)
          } 
        }
      });

      let summaryRecord = this.gridSummaryData.data[0];
      summaryRecord.gsp = (sumVal / this.gridData.data.length);
      ///calculate gsp % change
      let gsppercSum = 0;
      this.gridData.data.forEach(item => {
        if (!isNaN(parseInt(item.gsP_Change))) {
          gsppercSum += parseInt(item.gsP_Change);
        }
      });
      
      summaryRecord.gsP_Change = (gsppercSum / this.gridData.data.length);
      ///calculate margin
      let marginSum = 0;
      this.gridData.data.forEach(item => {
        if (!isNaN(parseInt(item.margin))) {
          marginSum += parseInt(item.margin);
        }
      });
      
      summaryRecord.margin = (marginSum / this.gridData.data.length);
    }
  }


  ///Summary Events
  public ongspSumChange(value: string): void {
    this.gridData.data.forEach(item => {
      item.gsp = value;
      if(item.lygsp && item.gsp){
        item.gsP_Change=(((item.gsp-item.lygsp)/item.lygsp)*100)
      }else{
        item.gsP_Change=0;
      }
      item.margin = item.gsp-item.totalCost;
    });
    let summaryRecord = this.gridSummaryData.data[0];
    if(summaryRecord.lygsp && summaryRecord.gsp){
      summaryRecord.gsP_Change=(((summaryRecord.gsp-summaryRecord.lygsp)/summaryRecord.lygsp)*100)
    }else{
      summaryRecord.gsP_Change=0;
    }
    summaryRecord.margin = summaryRecord.gsp-summaryRecord.totalCost;
  }

  public ongspPerctSumChange(value: string): void {
    this.gridData.data.forEach(item => {
      if (!isNaN(parseInt(item.lYGSP))) {
        if(item.lYGSP){
          item.gsP_Change=value;
          item.gsp=(((item.gsP_Change*item.lYGSP)/100)+item.lYGSP)
          item.margin = item.gsp-item.totalCost;
        }
      }
    });
    let summaryRecord = this.gridSummaryData.data[0];
    if(summaryRecord.lygsp && summaryRecord.gsP_Change){
      summaryRecord.gsp=(((summaryRecord.gsP_Change*summaryRecord.lYGSP)/100)+summaryRecord.lYGSP)
    }else{
      summaryRecord.gsp=0;
    }
    summaryRecord.margin = summaryRecord.gsp-summaryRecord.totalCost;
  }
  public onmarginSumChange(value: string): void {   
    this.gridData.data.forEach(item => {
      item.margin=value;
      item.gsp= item.margin+item.totalCost;
      if(item.lygsp){
        item.gsP_Change=(((item.gsp-item.lygsp)/item.lygsp)*100)
      }     
    });
    let summaryRecord = this.gridSummaryData.data[0];
    summaryRecord.gsp = summaryRecord.margin+summaryRecord.lygsp;   
    if(summaryRecord.lygsp){
      summaryRecord.gsP_Change=(((summaryRecord.gsp-summaryRecord.lygsp)/summaryRecord.lygsp)*100)
    }
  }

  ///calculate the avg for all columns onload
  public calculateAvg(){
    let totalSum = 0;
    let earlyFillSum=0;
    let reserveSum=0;
    let lyAwardSum=0;
    let lyAwardPriceSum=0;
    let lyAwardmarginSum=0;
    let lyGSPSum=0;
    let dCostSum=0;
    let fCostSum=0;
    let fSurSum=0;
    let tFreightSum=0;
    let tcostSum=0;
    let cogsSum=0;
    this.gridData.data.forEach(item => {
      if (!isNaN(parseInt(item.total))) {
        totalSum += item.total;
      }
      if (!isNaN(parseInt(item.earlyFill))) {
        earlyFillSum += item.earlyFill;
      }
      if (!isNaN(parseInt(item.reserve))) {
        reserveSum += item.reserve;
      }

      if (!isNaN(parseInt(item.lyAwardTo))) {
        lyAwardSum += item.lyAwardTo;
      }
      if (!isNaN(parseInt(item.lyAwardPrice))) {
        lyAwardPriceSum += item.lyAwardPrice;
      }
      if (!isNaN(parseInt(item.lyAwardMargin))) {
        lyAwardmarginSum += item.lyAwardMargin;
      }
      if (!isNaN(parseInt(item.lygsp))) {
        lyGSPSum += item.lygsp;
      }

      if (!isNaN(parseInt(item.depotCost))) {
        dCostSum += item.depotCost;
      }
      if (!isNaN(parseInt(item.freightCost))) {
        fCostSum += item.freightCost;
      }
      if (!isNaN(parseInt(item.fuelSurcharge))) {
        fSurSum += item.fuelSurcharge;
      }

      if (!isNaN(parseInt(item.totalFreight))) {
        tFreightSum += item.totalFreight;
      }
      if (!isNaN(parseInt(item.cogs))) {
        cogsSum += item.cogs;
      }
      if (!isNaN(parseInt(item.totalCost))) {
        tcostSum += item.totalCost;
      }
    });

    let summaryRecord = this.gridSummaryData.data[0];
    summaryRecord.total = totalSum;
    summaryRecord.earlyFill = earlyFillSum;
    summaryRecord.reserve = reserveSum;
    summaryRecord.lyAwardTo = (lyAwardSum / this.gridData.data.length)
    summaryRecord.lyAwardPrice = (lyAwardPriceSum/ this.gridData.data.length)
    summaryRecord.lyAwardMargin = (lyAwardmarginSum / this.gridData.data.length)
    summaryRecord.lygsp = (lyGSPSum / this.gridData.data.length)

    summaryRecord.depotCost = (dCostSum / this.gridData.data.length)
    summaryRecord.freightCost = (fCostSum / this.gridData.data.length)
    summaryRecord.fuelSurcharge = (fSurSum / this.gridData.data.length)
    
    summaryRecord.totalFreight = (tFreightSum/ this.gridData.data.length)
    summaryRecord.totalCost = (tcostSum/ this.gridData.data.length)
    summaryRecord.cogs = (cogsSum / this.gridData.data.length)
  }
}