import { Component, OnInit, ElementRef } from '@angular/core';
import { FormControl, FormGroup, Validators } from '@angular/forms';
import { ToastrService } from 'ngx-toastr';
import { LocationCodeService } from '../../../services/location.code.service';
import { TaxGroupService } from '../../../services/tax.group.service';
import { TaxSlabService } from '../../../services/tax.slab.service';
import { UomService } from '../../../services/uom.service';
import { AccountNameService } from '../../../services/account.name.service';
import { ItemService } from '../../../services/item.service';
import { LoginService } from '../../../services/login.service';
import { BsModalRef, BsModalService } from 'ngx-bootstrap';
import { AlertModalComponent } from '../../common/alert-modal/alert-modal.component';
import { NGXLogger } from 'ngx-logger';
import { ItemVariantService } from '../../../services/item.variant.service';
@Component({
  selector: 'app-new-variant',
  templateUrl: './new-variant.component.html',
  styleUrls: ['./new-variant.component.css']
})

export class NewVariantComponent implements OnInit {
  //defaultItemVariant
  defaultItemVarinat: any
  allItemVariants: any[];
  //IsInventory
  isInventory: boolean = false;
  //customer items
  customerItems: any[];

  //itemsToDisplayed
  variantLocationCodes: any[];
  salesAccounts: any[];
  costAccounts: any[];
  defaultCostAccount: any;
  inventoryAccounts: any[];
  inventoryItems: any[];
  defaultInventoryAccount: any;
  taxationTaxGroups: any[];
  taxationTaxSlabs: any[];
  uoms: any[];
  currentUser: any;
  // Form group
  itemsForm: FormGroup;

  // Variant fields
  selectedItemId: FormControl
  variantLocation: FormControl;
  variantName: FormControl;
  variantUnit: FormControl;
  variantIsAvailable: FormControl;
  variantIsDefault: FormControl;
  variantTaxType: FormControl;
  variantNonTaxableReason: FormControl;

  // Sales fields
  salesPrice: FormControl;
  salesDiscount: FormControl;
  salesPremium: FormControl;
  salesTaxInclusive: FormControl;
  salesAccount: FormControl;
  salesDescription: FormControl;

  // Cost fields
  costPurchaseInformation: FormControl;
  costPrice: FormControl;
  costTaxInclusive: FormControl;
  costAccount: FormControl;
  costDescription: FormControl;

  // Taxation fields
  taxationIntraStateTax: FormControl;
  taxationInterStateTax: FormControl;

  // Inventory fields
  inventoryAccount: FormControl;
  inventoryItem: FormControl;
  inventoryDeduction: FormControl;
  inventoryDeductionUnit: FormControl;
  inventoryReorderPoint: FormControl;
  //Modal popup
  bsModalRef: BsModalRef;
  //items to be updated
  itemDetailstoBeUpdated: any = {};
  catagoryItemsToBeUpdated: any = {};

  constructor(
    private toastr: ToastrService,
    private modalService: BsModalService,
    private locationCodeService: LocationCodeService,
    private taxGroupService: TaxGroupService,
    private taxSlabService: TaxSlabService,
    private uomService: UomService,
    private accountNameService: AccountNameService,
    private itemService: ItemService,
    private loginService: LoginService,
    private logger: NGXLogger,
    private el: ElementRef,
    private itemVariantService: ItemVariantService

  ) { }

  scalePrice() {
    if (this.costPrice.valid && (this.costPrice.dirty === true || this.costPrice.touched === true)) {
      const num = Number(this.costPrice.value).toFixed(2);
      const numArray = num.split('.');
      this.itemsForm.patchValue({
        costPrice: numArray[0].slice(0, 9) + '.' + numArray[1].slice(0, 2)
      });
    }

    if (this.salesPrice.valid && (this.salesPrice.dirty === true || this.salesPrice.touched === true)) {
      const num = Math.floor(this.salesPrice.value);
      this.itemsForm.patchValue({
        salesPrice: num
      });
    }

    if (this.salesDiscount.valid && (this.salesDiscount.dirty === true || this.salesDiscount.touched === true)) {
      const num = Math.floor(this.salesDiscount.value);
      this.itemsForm.patchValue({
        salesDiscount: num
      });
    }

    if (this.salesPremium.valid && (this.salesPremium.dirty === true || this.salesPremium.touched === true)) {
      const num = Math.floor(this.salesPremium.value);
      this.itemsForm.patchValue({
        salesPremium: num
      });
    }

    if (this.inventoryDeduction.valid && (this.inventoryDeduction.dirty === true || this.inventoryDeduction.touched === true)) {
      const num = Number(this.inventoryDeduction.value).toFixed(2);
      const numArray = num.split('.');
      this.itemsForm.patchValue({
        inventoryDeduction: numArray[0].slice(0, 9) + '.' + numArray[1].slice(0, 2)
      });
    }
  }


  private setDefaultVariantValues() {
    this.itemsForm.patchValue({
      // Variant fields default value
      selectedItemId: '',
      variantLocation: '',
      variantName: '',
      variantUnit: '',
      variantIsAvailable: false,
      variantIsDefault: false,
      variantTaxType: 'taxable',
      variantNonTaxableReason: ''
    });
  }

  private setDefaultSalesValues() {
    this.itemsForm.patchValue({
      // Sales fields default value
      salesPrice: '',
      salesDiscount: '',
      salesPremium: '',
      salesTaxInclusive: true,
      salesAccount: '',
      salesDescription: ''
    });
  }


  private setDefaultCostValues() {
    if (this.costAccounts) {
      for (const account of this.costAccounts) {
        if (account.account_name === 'Cost of Goods Sold') {
          this.defaultCostAccount = account.account_name_id;
        }
      }
    }
    // Cost fields default value
    this.itemsForm.patchValue({
      costPurchaseInformation: false,
      costPrice: '',
      costTaxInclusive: true,
      costAccount: this.defaultCostAccount,
      costDescription: ''
    });
  }

  private setDefaultTaxationValues() {
    this.itemsForm.patchValue({
      // Taxation fields default value
      taxationIntraStateTax: '',
      taxationInterStateTax: ''
    });
  }

  private setDefaultInventoryValues() {
    if (this.inventoryAccounts) {
      for (const account of this.inventoryAccounts) {
        if (account.account_name === 'Inventory Asset') {
          this.defaultInventoryAccount = account.account_name_id;
        }
      }
    }

    this.itemsForm.patchValue({
      // Inventory fields default value
      inventoryAccount: this.defaultInventoryAccount,
      inventoryItem: '',
      inventoryDeduction: '',
      inventoryDeductionUnit: '',
      inventoryReorderPoint: ''
    });
  }

  private setDefaultValues() {
    this.setDefaultVariantValues();
    this.setDefaultSalesValues();
    this.setDefaultCostValues();
    this.setDefaultTaxationValues();
    this.setDefaultInventoryValues();
  }

  private createVariantControls() {
    // Variant controls initialization
    this.selectedItemId = new FormControl();
    this.variantLocation = new FormControl();
    this.variantName = new FormControl();
    this.variantUnit = new FormControl();
    this.variantIsAvailable = new FormControl();
    this.variantIsDefault = new FormControl();
    this.variantTaxType = new FormControl();
    this.variantNonTaxableReason = new FormControl();
  }

  private createSalesControls() {
    // Sales controls initialization
    this.salesPrice = new FormControl();
    this.salesDiscount = new FormControl();
    this.salesPremium = new FormControl();
    this.salesTaxInclusive = new FormControl();
    this.salesAccount = new FormControl();
    this.salesDescription = new FormControl();
  }

  private createCostControls() {
    // Cost controls initialization
    this.costPurchaseInformation = new FormControl();
    this.costPrice = new FormControl();
    this.costTaxInclusive = new FormControl();
    this.costAccount = new FormControl();
    this.costDescription = new FormControl();
  }

  private createTaxationControls() {
    // Taxation controls initialization
    this.taxationIntraStateTax = new FormControl();
    this.taxationInterStateTax = new FormControl();
  }

  private createInventoryControls() {
    // Inventory controls initialization
    this.inventoryAccount = new FormControl();
    this.inventoryItem = new FormControl();
    this.inventoryDeduction = new FormControl();
    this.inventoryDeductionUnit = new FormControl();
    this.inventoryReorderPoint = new FormControl();
  }
  /*
  @purpose: to create the new form controls of each sections i.e items and item variants
  */
  createControls() {
    this.createVariantControls();
    this.createSalesControls();
    this.createCostControls();
    this.createTaxationControls();
    this.createInventoryControls();
  }



  setVariantValidations() {
    // Variant controls validation
    this.itemsForm.controls.selectedItemId.setValidators([Validators.required])
    this.itemsForm.controls.selectedItemId.updateValueAndValidity();
    this.itemsForm.controls.variantLocation.setValidators([Validators.required]);
    this.itemsForm.controls.variantLocation.updateValueAndValidity();

    this.itemsForm.controls.variantName.setValidators([Validators.required, Validators.pattern(/^[0-9]\d*(\.\d+)?$/)]);
    this.itemsForm.controls.variantName.updateValueAndValidity();

    this.itemsForm.controls.variantUnit.setValidators([Validators.required]);
    this.itemsForm.controls.variantUnit.updateValueAndValidity();

    this.itemsForm.controls.variantNonTaxableReason.setValidators([Validators.required]);
    this.itemsForm.controls.variantNonTaxableReason.updateValueAndValidity();

  }

  private setSalesValidations() {
    // Sales controls validation
    this.itemsForm.controls.salesPrice.setValidators([Validators.required, Validators.pattern(/^[0-9]\d*(\.\d+)?$/)]);
    this.itemsForm.controls.salesPrice.updateValueAndValidity();

    this.itemsForm.controls.salesDiscount.setValidators([Validators.required, Validators.pattern(/^[0-9]\d*(\.\d+)?$/)]);
    this.itemsForm.controls.salesDiscount.updateValueAndValidity();

    this.itemsForm.controls.salesPremium.setValidators([Validators.required, Validators.pattern(/^[0-9]\d*(\.\d+)?$/)]);
    this.itemsForm.controls.salesPremium.updateValueAndValidity();

    this.itemsForm.controls.salesAccount.setValidators([Validators.required]);
    this.itemsForm.controls.salesAccount.updateValueAndValidity();

  }

  private setCostValidations() {
    // Cost controls validation
    this.itemsForm.controls.costPrice.setValidators([Validators.required, Validators.pattern(/^[0-9]\d*(\.\d+)?$/)]);
    this.itemsForm.controls.costPrice.updateValueAndValidity();

    this.itemsForm.controls.costAccount.setValidators([Validators.required]);
    this.itemsForm.controls.costAccount.updateValueAndValidity();
  }

  private removeCostValidations() {
    // Remove cost controls validation
    this.itemsForm.controls.costPrice.clearValidators();
    this.itemsForm.controls.costPrice.updateValueAndValidity();
    this.itemsForm.controls.costAccount.clearValidators();
    this.itemsForm.controls.costAccount.updateValueAndValidity();
  }

  private clearCostValidations() {
    // Cost controls validation reset
    this.itemsForm.controls.costPrice.markAsPristine();
    this.itemsForm.controls.costPrice.markAsUntouched();
    this.itemsForm.controls.costAccount.markAsPristine();
    this.itemsForm.controls.costAccount.markAsUntouched();
  }

  private setTaxationValidations() {
    // Taxation controls validation
    this.itemsForm.controls.taxationIntraStateTax.setValidators([Validators.required]);
    this.itemsForm.controls.taxationIntraStateTax.updateValueAndValidity();

    this.itemsForm.controls.taxationInterStateTax.setValidators([Validators.required]);
    this.itemsForm.controls.taxationInterStateTax.updateValueAndValidity();

  }

  private clearTaxationValidations() {
    // Taxation controls validation reset
    this.itemsForm.controls.taxationIntraStateTax.markAsPristine();
    this.itemsForm.controls.taxationIntraStateTax.markAsUntouched();
    this.itemsForm.controls.taxationInterStateTax.markAsPristine();
    this.itemsForm.controls.taxationInterStateTax.markAsUntouched();
  }

  private removeTaxationValidations() {
    // Remove taxation fields validation
    this.itemsForm.controls.taxationIntraStateTax.clearValidators();
    this.itemsForm.controls.taxationIntraStateTax.updateValueAndValidity();
    this.itemsForm.controls.taxationInterStateTax.clearValidators();
    this.itemsForm.controls.taxationInterStateTax.updateValueAndValidity();
  }


  private removeInventoryValidations() {
    // Remove sales fields validation
    this.itemsForm.controls.inventoryItem.clearValidators();
    this.itemsForm.controls.inventoryItem.updateValueAndValidity();

    this.itemsForm.controls.inventoryDeduction.clearValidators();
    this.itemsForm.controls.inventoryDeduction.updateValueAndValidity();

    this.itemsForm.controls.inventoryDeductionUnit.clearValidators();
    this.itemsForm.controls.inventoryDeductionUnit.updateValueAndValidity();

    this.itemsForm.controls.inventoryReorderPoint.clearValidators();
    this.itemsForm.controls.inventoryReorderPoint.updateValueAndValidity();
  }

  private setInventoryValidations() {
    // Inventory controls validation
    this.itemsForm.controls.inventoryItem.setValidators([Validators.required]);
    this.itemsForm.controls.inventoryItem.updateValueAndValidity();

    this.itemsForm.controls.inventoryDeduction.setValidators([Validators.required, Validators.pattern(/^[0-9]\d*(\.\d+)?$/)]);
    this.itemsForm.controls.inventoryDeduction.updateValueAndValidity();

    this.itemsForm.controls.inventoryDeductionUnit.setValidators([Validators.required]);
    this.itemsForm.controls.inventoryDeductionUnit.updateValueAndValidity();

    this.itemsForm.controls.inventoryReorderPoint.setValidators([Validators.pattern(/^[0-9]*$/), Validators.max(32767)]);
    this.itemsForm.controls.inventoryReorderPoint.updateValueAndValidity();

  }
  /*
  @usage: to set the validations of each section
  */
  private setValidations() {
    // Controls validation
    this.setVariantValidations();
    this.setSalesValidations();
    this.setCostValidations();
    this.setTaxationValidations();
    this.setInventoryValidations();
  }
  /*
      @usage: called when reset is required
      @purpose: set the default state and values
    */
  resetFormValues() {
    this.setDefaultValues();
    this.itemsForm.reset(this.itemsForm.value);

  }
  /*
      @purpose: Rest the items form.
    */
  onReset() {
    this.resetFormValues();
    this.toastr.success('Form reset successfully.');
  }

  /*
@usage: to submit the form
@purpose: to create the new items into the db
*/
  onSubmit() {
    this.checkVariantExists();
    this.setSalesValidations();
    this.setTaxationValidations();
    this.setVariantValidations();

    if (this.isInventory) {
      this.setInventoryValidations();
    } else {
      this.removeInventoryValidations();
    }

    if (this.itemsForm.controls.costPurchaseInformation.value === false) {
      this.removeCostValidations();
    }

    if (this.itemsForm.value.variantTaxType === 'taxable') {
      this.itemsForm.controls.variantNonTaxableReason.clearValidators();
      this.itemsForm.controls.variantNonTaxableReason.updateValueAndValidity();
    } else {
      this.removeTaxationValidations();
    }
    // To show the alert modal before creating new items
    if (this.itemsForm.valid) {
      this.bsModalRef = this.modalService.show(AlertModalComponent, {
        backdrop: 'static',
        keyboard: false,
        animated: true,
        ignoreBackdropClick: true,
        initialState: {
          title: 'Alert',
          data: 'Are you sure you want to save Item Variant?',
          buttonText: 'Cancel',
          deleteBtn: 'Sure'
        }
      });
      this.bsModalRef.content.event.subscribe(modelResult => {
        {
          if(modelResult){
            const itemVariantDetails: any = {};

          // Inventory details
          if (this.isInventory) {
            itemVariantDetails.inventory_account = this.inventoryAccount.value;
            itemVariantDetails.inventory_item = this.inventoryItem.value.toString().trim();
            itemVariantDetails.deduction = this.inventoryDeduction.value.toString().trim();
            itemVariantDetails.deduction_unit = this.inventoryDeductionUnit.value.toString().trim();
            if (this.inventoryReorderPoint.value) {
              itemVariantDetails.reorder_point = this.inventoryReorderPoint.value.toString().trim();
            }
          }

          // Variant details
          itemVariantDetails.location_code_id = this.variantLocation.value.toString().trim();
          itemVariantDetails.variant = this.variantName.value.toString().trim();
          itemVariantDetails.variant_unit = this.variantUnit.value.toString().trim();
          itemVariantDetails.is_available = this.variantIsAvailable.value;
          itemVariantDetails.is_default = this.variantIsDefault.value;
          itemVariantDetails.taxable = this.variantTaxType.value.toString().trim() === 'taxable' ? true : false;
          if (itemVariantDetails.taxable === false) {
            itemVariantDetails.reason = this.variantNonTaxableReason.value.toString().trim();
          }

          // Sales details
          itemVariantDetails.sales_price = this.salesPrice.value.toString().trim();
          itemVariantDetails.discount_price = this.salesDiscount.value.toString().trim();
          itemVariantDetails.premium_price = this.salesPremium.value.toString().trim();
          itemVariantDetails.sp_tax_inclusive = this.salesTaxInclusive.value;
          itemVariantDetails.sales_account = this.salesAccount.value.toString().trim();
          itemVariantDetails.description = this.salesDescription.value.toString().trim();
          if (itemVariantDetails.taxable === true) {
            itemVariantDetails.intra_state_tax = this.taxationIntraStateTax.value.toString().trim();
            itemVariantDetails.inter_state_tax = this.taxationInterStateTax.value.toString().trim();
          }


          // Cost Deatils
          itemVariantDetails.purchase_information = this.costPurchaseInformation.value;
          if (itemVariantDetails.purchase_information === true) {
            itemVariantDetails.cost_price = this.costPrice.value.toString().trim();
            itemVariantDetails.cp_tax_inclusive = this.costTaxInclusive.value;
            itemVariantDetails.cost_account = this.costAccount.value.toString().trim();
            itemVariantDetails.cost_description = this.costDescription.value.toString().trim();
          }
          itemVariantDetails.item_id = this.selectedItemId.value;
          //  const itemWithVariantDetails = { item_variant: itemVariantDetails };
          //logging the post operation
          this.logger.debug('Forms values to be added into itemVariant table');
          this.itemVariantService.addItem_Variant(itemVariantDetails).subscribe(
            response => {
              // tslint:disable-next-line: no-string-literal
              const data: any = response as any[];
              if (data.status === 'success') {
                this.toastr.success('Item Variant saved successfully.');
                this.resetFormValues();
              } else {
                this.toastr.error('Internal server error.');
              }
            },
            error => {
              this.logger.error(error);
            }
          );
          }
        }
      });
    } else {
      this.triggerValidations();
      this.focusOnError();
    }
    this.setCostValidations();
    this.setTaxationValidations();
    this.setVariantValidations();
  }


  private focusOnError() {
    try {
      const firstInvalidControl: HTMLElement = this.el.nativeElement.querySelector(
        'form .ng-invalid,form .error-control'
      );
      firstInvalidControl.focus();
    } catch {

    }
  }

  private triggerVariantValidations() {
    // Trigger variant fields validation
    this.itemsForm.controls.selectedItemId.markAllAsTouched();
    this.itemsForm.controls.variantLocation.markAsTouched();
    this.itemsForm.controls.variantName.markAsTouched();
    this.itemsForm.controls.variantUnit.markAsTouched();
    this.itemsForm.controls.variantNonTaxableReason.markAsTouched();
  }

  private triggerSalesValidations() {
    // Trigger sales fields validation
    this.itemsForm.controls.salesPrice.markAsTouched();
    this.itemsForm.controls.salesDiscount.markAsTouched();
    this.itemsForm.controls.salesPremium.markAsTouched();
    this.itemsForm.controls.salesAccount.markAsTouched();
  }

  private triggerCostValidations() {
    // Trigger cost fields validation
    this.itemsForm.controls.costPrice.markAsTouched();
    this.itemsForm.controls.costAccount.markAsTouched();
  }

  private triggerTaxationValidations() {
    // Trigger taxation fields validation
    this.itemsForm.controls.taxationIntraStateTax.markAsTouched();
    this.itemsForm.controls.taxationInterStateTax.markAsTouched();
  }

  private triggerInventoryValidations() {
    // Trigger inventory fields validation
    this.itemsForm.controls.inventoryItem.markAsTouched();
    this.itemsForm.controls.inventoryDeduction.markAsTouched();
    this.itemsForm.controls.inventoryDeductionUnit.markAsTouched();
    this.itemsForm.controls.inventoryReorderPoint.markAsTouched();
  }
  /*
  @purpose: to set validations for items and item variants
  */
  private triggerValidations() {
    this.triggerVariantValidations();
    this.triggerSalesValidations();
    this.triggerCostValidations();
    this.triggerTaxationValidations();
    this.triggerInventoryValidations();
  }

  checkVariantExists() {
    const variant = this.itemsForm.get('variantName').value;
    const unit =  this.itemsForm.get('variantUnit').value;
    const location = this.itemsForm.get('variantLocation').value;
    const existingVariant = this.allItemVariants.find((itemVariant) => variant === itemVariant.variant && unit === itemVariant.variant_unit && location === itemVariant.location_code_id);
    if(existingVariant) {
      this.bsModalRef = this.modalService.show(AlertModalComponent, {
        backdrop: 'static',
        keyboard: false,
        animated: true,
        ignoreBackdropClick: true,
        initialState: {
          data:  variant + ' ' + this.uoms.find((uom) => uom.uom_id === unit).uom_code + ' variant is already exists.',
          infoPopup: true
        }
      });
      this.itemsForm.controls.variantName.setValue(null);
      this.itemsForm.controls.variantUnit.setValue(null);
      this.itemsForm.controls.variantName.markAsUntouched();
      this.itemsForm.controls.variantUnit.markAsUntouched();
      this.itemsForm.controls.variantName.markAsPristine();
      this.itemsForm.controls.variantUnit.markAsPristine();
    }
  }
  selectVariantTaxType() {
    if (this.itemsForm.value.variantTaxType === 'taxable') {
      this.setDefaultTaxationValues();
      this.itemsForm.controls.variantNonTaxableReason.markAsUntouched();
      this.itemsForm.controls.variantNonTaxableReason.markAsPristine();
    } else {
      this.itemsForm.patchValue({
        variantNonTaxableReason: ''
      });
      this.clearTaxationValidations();
    }
  }

  selectCostPurchaseInformation() {
    if (this.itemsForm.controls.costPurchaseInformation.value === true) {
      this.setDefaultCostValues();
    } else {
      this.clearCostValidations();
    }
  }
  //To get the selected item
  itemChanged(id) {
    this.setDefaultValues();
    this.itemsForm.patchValue({
      // Variant fields default value
      selectedItemId: id,
      variantLocation: '',
      variantName: '',
      variantUnit: '',
      variantIsAvailable: false,
      variantIsDefault: false,
      variantTaxType: 'taxable',
      variantNonTaxableReason: ''
    });
    this.isInventory = this.customerItems.find(item => item.item_id === id).is_inventory;
    this.itemVariantService.getItemVariantOfSelectedItem(id).subscribe(
      result => {
        this.allItemVariants = result['data'] as any[];
        for (const itemVariant of this.allItemVariants) {
          if (itemVariant.is_default === true) {
            this.defaultItemVarinat = JSON.parse(JSON.stringify(itemVariant));
          }
        }
        if (!this.defaultItemVarinat) {
          this.defaultItemVarinat = JSON.parse(JSON.stringify(this.allItemVariants[0]));
        }
      });
    //  this.setDefaultValues();
    // this.resetFormValues();
  }
  onClone() {

    if (this.defaultItemVarinat.taxable) {
      this.itemsForm.patchValue({
        variantTaxType: 'taxable',
      });
    }
    this.itemsForm.patchValue({
      // Variant fields default value

      variantLocation: this.defaultItemVarinat.location_code_id,
      variantName: this.defaultItemVarinat.variant,
      variantUnit: this.defaultItemVarinat.variant_unit,
      variantIsAvailable: this.defaultItemVarinat.is_available,
      variantIsDefault: this.defaultItemVarinat.is_default,
      variantNonTaxableReason: this.defaultItemVarinat.reason,
      salesPrice: this.defaultItemVarinat.sales_price,
      salesDiscount: this.defaultItemVarinat.discount_price,
      salesPremium: this.defaultItemVarinat.premium_price,
      salesTaxInclusive: this.defaultItemVarinat.sp_tax_inclusive,
      salesAccount: this.defaultItemVarinat.sales_account,
      salesDescription: this.defaultItemVarinat.description,
      costPurchaseInformation: false,
      costPrice: this.defaultItemVarinat.cost_price,
      costTaxInclusive: this.defaultItemVarinat.cp_tax_inclusive,
      costAccount: this.defaultItemVarinat.cost_account,
      costDescription: this.defaultItemVarinat.cost_description,
      taxationIntraStateTax: this.defaultItemVarinat.intra_state_tax,
      taxationInterStateTax: this.defaultItemVarinat.inter_state_tax,
      inventoryAccount: this.defaultItemVarinat.inventory_account,
      inventoryItem: this.defaultItemVarinat.inventory_item,
      inventoryDeduction: this.defaultItemVarinat.deduction,
      inventoryDeductionUnit: this.defaultItemVarinat.deduction_unit,
      inventoryReorderPoint: this.defaultItemVarinat.reorder_point
    });

  }
  isDefaultVariant() {
    let defVarOfLocation = this.allItemVariants.find((variant) => variant.is_default === true && variant.location_code_id === this.itemsForm.get('variantLocation').value)
    if (this.itemsForm.controls.variantIsDefault.value && defVarOfLocation) {
      this.bsModalRef = this.modalService.show(AlertModalComponent, {
        backdrop: 'static',
        keyboard: false,
        animated: true,
        ignoreBackdropClick: true,
        initialState: {
          title: 'Alert',
          data: defVarOfLocation.variant + ' ' + this.uoms.find((uom) => uom.uom_id === defVarOfLocation.variant_unit).uom_code + ' variant is already marked as default for this location. Are you sure to proceed',
          buttonText: 'Cancel',
          deleteBtn: 'OK',
        }
      });
      let alertConfirm: boolean;
      this.bsModalRef.content.event.subscribe(res => {
        alertConfirm = res;
        if (alertConfirm) {
          this.itemsForm.controls.variantIsDefault.setValue(true);
        }
        else {
          this.itemsForm.controls.variantIsDefault.setValue(false);
        }

      });
    }

  }

  ngOnInit(): void {
    this.createControls();
    this.createGroup();
    //binding all the items
    this.itemService.getAllCustomerItems().subscribe(
      result => {
        this.customerItems = result['data'] as any[];
        for (const item of this.customerItems) {
          item.item_name = item.item_name + '--' + item.title;
        }
      });
    // Binding location code
    this.locationCodeService.getAllLocation_Codes().subscribe(
      locationCodes => {
        // tslint:disable-next-line: no-string-literal
        this.variantLocationCodes = locationCodes['data'] as any[];
        for (const item of this.variantLocationCodes) {
          item.location_name = item.location_name + '--' + item.location_state;
        }
      });

    // Binding cost accounts
    this.accountNameService.getAllAccountNamesByHeadAccountName('Expense').subscribe(
      costAccounts => {
        // tslint:disable-next-line: no-string-literal
        this.costAccounts = costAccounts['data'] as any[];
      });

    // Binding tax group
    this.taxGroupService.getAllTax_Groups().subscribe(
      taxGroups => {
        // tslint:disable-next-line: no-string-literal
        this.taxationTaxGroups = taxGroups['data'] as any[];
      });

    // Binding tax slab(Inter Tax-IGST)
    this.taxationTaxSlabs = [];
    this.taxSlabService.getAllTaxSlabsByType('IGST').subscribe(
      taxSlabs => {
        // tslint:disable-next-line: no-string-literal
        this.taxationTaxSlabs = taxSlabs['data'] as any[];
      });

    // Binding tax slab(Inter Tax-Non Taxable)
    this.taxSlabService.getAllTaxSlabsByType('Non Taxable').subscribe(
      taxSlabs => {
        // tslint:disable-next-line: no-string-literal
        this.taxationTaxSlabs = this.taxationTaxSlabs.concat(taxSlabs['data'] as any[]);
      });

    // Binding UOM
    this.uomService.getAllUoms().subscribe(
      uoms => {
        // tslint:disable-next-line: no-string-literal
        this.uoms = uoms['data'] as any[];
      });


    // Binding sales accounts
    this.accountNameService.getAllAccountNamesByHeadAccountName('Income').subscribe(
      salesAccounts => {
        // tslint:disable-next-line: no-string-literal
        this.salesAccounts = salesAccounts['data'] as any[];
      });

    // Binding inventory accounts
    this.accountNameService.getAllAccount_Names().subscribe(
      inventoryAccounts => {
        // tslint:disable-next-line: no-string-literal
        this.inventoryAccounts = inventoryAccounts['data'] as any[];
      });

    this.itemService.getAllItems().subscribe(
      inventoryItems => {
        // tslint:disable-next-line: no-string-literal
        this.inventoryItems = inventoryItems['data'] as any[];
        //  this.inventoryItems.unshift({ item_id: -1, item_name: 'Same Item' });
      });

    // Get logged-in user
    this.currentUser = this.loginService.getCurrentUser();
    this.setDefaultValues();
    this.setValidations();

  }
  lessThanOrEqualTo(value1: string, value2: string) {
    if (value2 === '') {
      return false;
    }
    const number1: number = Number(value1);
    const number2: number = Number(value2);
    return number1 > number2;
  }
  /*
  @usage: Create all the fields mapping
  */
  createGroup() {
    this.itemsForm = new FormGroup({

      // Variant fields:
      selectedItemId: this.selectedItemId,
      variantLocation: this.variantLocation,
      variantName: this.variantName,
      variantUnit: this.variantUnit,
      variantIsAvailable: this.variantIsAvailable,
      variantIsDefault: this.variantIsDefault,
      variantTaxType: this.variantTaxType,
      variantNonTaxableReason: this.variantNonTaxableReason,

      // Sales fields
      salesPrice: this.salesPrice,
      salesDiscount: this.salesDiscount,
      salesPremium: this.salesPremium,
      salesTaxInclusive: this.salesTaxInclusive,
      salesAccount: this.salesAccount,
      salesDescription: this.salesDescription,

      // Cost fields
      costPurchaseInformation: this.costPurchaseInformation,
      costPrice: this.costPrice,
      costTaxInclusive: this.costTaxInclusive,
      costAccount: this.costAccount,
      costDescription: this.costDescription,

      // Taxation fields
      taxationIntraStateTax: this.taxationIntraStateTax,
      taxationInterStateTax: this.taxationInterStateTax,

      // Inventory fields
      inventoryAccount: this.inventoryAccount,
      inventoryItem: this.inventoryItem,
      inventoryDeduction: this.inventoryDeduction,
      inventoryDeductionUnit: this.inventoryDeductionUnit,
      inventoryReorderPoint: this.inventoryReorderPoint
    });
  }


}