import { LaborStatusEnum, PayTypeEnum } from "../enums/enums";
import { Add, Divide, Subtract } from "../shared/math-operations";
import { TrUtils } from "../utils/tr-utils";


export class ROTotalsService {

    static GetTaxAmountFromGroup(item: any, taxGroupKey: string, taxCode: string, fallbackKey: string) {
        const groupedTaxes = item?.[taxGroupKey];
        if (Array.isArray(groupedTaxes)) {
            const matchedTaxes = groupedTaxes.filter((tax: any) => tax?.Code === taxCode);
            if (matchedTaxes.length !== 0) {
                return matchedTaxes.reduce((total: number, tax: any) => Add(total, tax?.Amt), 0);
            }
        }
        return TrUtils.SetValueToZeroIfNull(item?.[fallbackKey]);
    }

    static GetTotalsValue(OriRecordData: any, TaxCodes: any[], isWorkOrder: boolean, detailedInfo: boolean, withItems: boolean, isRoundable: boolean, EntitySettings: any) {

        let dupRecordData: any = TrUtils.Stringify(OriRecordData);
        let argRecordData: any = {};
        dupRecordData.Ops = this.CalculateLaborValues(dupRecordData.Ops, isWorkOrder, TrUtils.isTaxable(dupRecordData.Settings.Tax));
        dupRecordData.Parts = this.CalculatePartValues(dupRecordData.Parts, dupRecordData.Ops, isWorkOrder, TrUtils.isTaxable(dupRecordData.Settings.Tax));
        argRecordData = this.GetROTotalsData(argRecordData, dupRecordData, TaxCodes, withItems, detailedInfo, isWorkOrder, isRoundable, EntitySettings.DecimalsNumber);

        return argRecordData;
    }

    static CalculateLaborValues(opCodesList: any, isWorkOrder: boolean, isTaxable: boolean) {

        opCodesList = this.FilterValidLaborItems(opCodesList);
        opCodesList = this.ResetLaborValuesIfInvalid(opCodesList, isWorkOrder);
        opCodesList = this.GetOperationsDiscountPrice(opCodesList, isWorkOrder);
        opCodesList = this.GetOperationsAfterDiscount(opCodesList, isWorkOrder);
        opCodesList = this.GetOperationsAfterTax(opCodesList, isWorkOrder, isTaxable);

        return opCodesList;
    }

    static FilterValidLaborItems(opCodesList: any[]) {
        opCodesList = opCodesList.filter((Labor: any) => {
            return Labor.Sts !== LaborStatusEnum.Cancelled && Labor.Sts !== LaborStatusEnum.Declined;
        });
        return opCodesList;
    }

    static ResetLaborValuesIfInvalid(opCodesList: any, isWorkOrder: boolean) {
        opCodesList.forEach((Operation: any) => {
            Operation = this.ResetLaborValueIfInvalid(Operation, isWorkOrder);
        });
        return opCodesList;
    }

    static ResetLaborValueIfInvalid(Operation: any, isWorkOrder: boolean) {
        Operation.Perc = TrUtils.SetPercToStringIfNull(Operation.Perc);
        Operation.Disc = TrUtils.SetValueToZeroIfNull(Operation.Disc);
        Operation.Pr = TrUtils.SetValueToZeroIfNull(Operation.Pr);
        Operation.AssPr = TrUtils.SetValueToZeroIfNull(Operation.AssPr);
        Operation.ACGST = this.GetTaxAmountFromGroup(Operation, 'ATaxes', 'CGST', 'ACGST');
        Operation.ASGST = this.GetTaxAmountFromGroup(Operation, 'ATaxes', 'SGST', 'ASGST');
        Operation.AIGST = this.GetTaxAmountFromGroup(Operation, 'ATaxes', 'IGST', 'AIGST');
        Operation.CCGST = this.GetTaxAmountFromGroup(Operation, 'CTaxes', 'CGST', 'CCGST');
        Operation.CSGST = this.GetTaxAmountFromGroup(Operation, 'CTaxes', 'SGST', 'CSGST');
        Operation.CIGST = this.GetTaxAmountFromGroup(Operation, 'CTaxes', 'IGST', 'CIGST');
        Operation.NetAmt = TrUtils.SetValueToZeroIfNull(Operation.NetAmt);
        Operation.RecDisc = TrUtils.SetValueToZeroIfNull(Operation.RecDisc);

        if (!isWorkOrder) {
            Operation.EstPr = TrUtils.SetValueToZeroIfNull(Operation.EstPr);
            Operation.ECGST = this.GetTaxAmountFromGroup(Operation, 'ETaxes', 'CGST', 'ECGST');
            Operation.ESGST = this.GetTaxAmountFromGroup(Operation, 'ETaxes', 'SGST', 'ESGST');
            Operation.EIGST = this.GetTaxAmountFromGroup(Operation, 'ETaxes', 'IGST', 'EIGST');
        }
        return Operation;
    }

    static GetOperationsDiscountPrice(OperationsList: any, isWorkOrder: boolean) {
        OperationsList.forEach((Operation: any) => {
            if (isWorkOrder) {
                Operation.CustDiscountedPrice = Add(Operation.Disc, Operation.RecDisc);
            } else {
                if (Operation.Sts === LaborStatusEnum.New || Operation.Sts === LaborStatusEnum.WtngForAppr) {
                    Operation.CustDiscountedPrice = 0;
                } else {
                    Operation.CustDiscountedPrice = Add(Operation.Disc, Operation.RecDisc);
                }
            }
        });
        return OperationsList;
    }

    static GetOperationsAfterDiscount(OperationsList: any, isWorkOrder: boolean) {
        OperationsList.forEach((Operation: any) => {
            let CustAfterLaborDisc: number = 0;
            let InsAfterLaborDisc: number = 0;
            if (Operation.PBy === PayTypeEnum.Customer) {
                if (isWorkOrder) {
                    CustAfterLaborDisc = Operation.NetAmt;
                } else {
                    if (Operation.Sts === LaborStatusEnum.New || Operation.Sts === LaborStatusEnum.WtngForAppr) {
                        CustAfterLaborDisc = Operation.EstPr;
                    } else {
                        CustAfterLaborDisc = Operation.NetAmt;
                    }
                }
            } else {
                if (isWorkOrder) {
                    CustAfterLaborDisc = Operation.NetAmt;
                    InsAfterLaborDisc = Operation.AssPr;
                } else {
                    if (Operation.Sts === LaborStatusEnum.New || Operation.Sts === LaborStatusEnum.WtngForAppr) {
                        InsAfterLaborDisc = Operation.EstPr;
                    } else {
                        CustAfterLaborDisc = Operation.NetAmt;
                        InsAfterLaborDisc = Operation.AssPr;
                    }
                }
            }
            Operation.CustAfterLaborDisc = CustAfterLaborDisc;
            Operation.InsAfterLaborDisc = InsAfterLaborDisc;
        });
        return OperationsList;
    }

    static GetOperationsAfterTax(OperationsList: any, isWorkOrder: boolean, isTaxable: boolean) {
        OperationsList.forEach((Operation: any) => {
            if (!isTaxable) {
                Operation.CustAfterTax = Operation.CustAfterLaborDisc;
                Operation.InsAfterTax = Operation.InsAfterLaborDisc;
            } else {
                if (Operation.PBy === PayTypeEnum.Customer) {
                    if (isWorkOrder) {
                        Operation.CustAfterTax = Add(Operation.CustAfterLaborDisc, Operation.CCGST, Operation.CSGST, Operation.CIGST);
                    } else {
                        if (Operation.Sts !== LaborStatusEnum.New && Operation.Sts !== LaborStatusEnum.WtngForAppr) {
                            Operation.CustAfterTax = Add(Operation.CustAfterLaborDisc, Operation.CCGST, Operation.CSGST, Operation.CIGST);
                        } else {
                            Operation.CustAfterTax = Add(Operation.CustAfterLaborDisc, Operation.ECGST, Operation.ESGST, Operation.EIGST);
                        }
                    }
                    Operation.InsAfterTax = 0;
                } else {
                    if (isWorkOrder) {
                        Operation.CustAfterTax = Add(Operation.CustAfterLaborDisc, Operation.CCGST, Operation.CSGST, Operation.CIGST);
                        Operation.InsAfterTax = Add(Operation.InsAfterLaborDisc, Operation.ACGST, Operation.ASGST, Operation.AIGST);
                    } else {
                        if (Operation.Sts !== LaborStatusEnum.New && Operation.Sts !== LaborStatusEnum.WtngForAppr) {
                            Operation.CustAfterTax = Add(Operation.CustAfterLaborDisc, Operation.CCGST, Operation.CSGST, Operation.CIGST);
                            Operation.InsAfterTax = Add(Operation.InsAfterLaborDisc, Operation.ACGST, Operation.ASGST, Operation.AIGST);
                        } else {
                            Operation.CustAfterTax = 0;
                            Operation.InsAfterTax = Add(Operation.InsAfterLaborDisc, Operation.ECGST, Operation.ESGST, Operation.EIGST);
                        }
                    }
                }
            }
        });
        return OperationsList;
    }

    static CalculatePartValues(PartsList: any, LaborList: any, isWorkOrder: boolean, isTaxable: boolean) {

        PartsList = this.FilterValidPartItems(PartsList);

        PartsList = this.ResetPartValuesIfInvalid(PartsList, isWorkOrder);

        PartsList = this.GetPartsDiscountPrice(PartsList, LaborList, isWorkOrder);

        PartsList = this.GetPartsAfterDiscount(PartsList, LaborList, isWorkOrder);

        PartsList = this.GetPartsAfterTax(PartsList, LaborList, isWorkOrder, isTaxable);

        PartsList = this.GetPartsPerItemAfterTax(PartsList);

        return PartsList;
    }

    static FilterValidPartItems(PartsList: any[]) {
        PartsList = PartsList.filter((Part: any) => {
            if (TrUtils.IsNull(Part.CollId)) {
                return Part;
            } else {
                return Part.Sts !== LaborStatusEnum.Cancelled && Part.Sts !== LaborStatusEnum.Declined;
            }
        });
        return PartsList;
    }

    static ResetPartValuesIfInvalid(PartsList: any, isWorkOrder: boolean) {
        PartsList.forEach((Part: any) => {
            Part = this.ResetPartValueIfInvalid(Part, isWorkOrder);
        });
        return PartsList;
    }

    static ResetPartValueIfInvalid(Part: any, isWorkOrder: boolean) {
        Part.Perc = TrUtils.SetPercToStringIfNull(Part.Perc);
        Part.Disc = TrUtils.SetValueToZeroIfNull(Part.Disc);
        Part.UnPr = TrUtils.SetValueToZeroIfNull(Part.UnPr);
        Part.AssPr = TrUtils.SetValueToZeroIfNull(Part.AssPr);
        Part.ACGST = this.GetTaxAmountFromGroup(Part, 'ATaxes', 'CGST', 'ACGST');
        Part.ASGST = this.GetTaxAmountFromGroup(Part, 'ATaxes', 'SGST', 'ASGST');
        Part.AIGST = this.GetTaxAmountFromGroup(Part, 'ATaxes', 'IGST', 'AIGST');
        Part.CCGST = this.GetTaxAmountFromGroup(Part, 'CTaxes', 'CGST', 'CCGST');
        Part.CSGST = this.GetTaxAmountFromGroup(Part, 'CTaxes', 'SGST', 'CSGST');
        Part.CIGST = this.GetTaxAmountFromGroup(Part, 'CTaxes', 'IGST', 'CIGST');
        Part.UnAmt = TrUtils.SetValueToZeroIfNull(Part.UnAmt);
        Part.AssAmt = TrUtils.SetValueToZeroIfNull(Part.AssAmt);
        Part.NetAmt = TrUtils.SetValueToZeroIfNull(Part.NetAmt);
        Part.RecDisc = TrUtils.SetValueToZeroIfNull(Part.RecDisc);
        if (!isWorkOrder) {
            Part.EstPr = TrUtils.SetValueToZeroIfNull(Part.EstPr);
            Part.ECGST = this.GetTaxAmountFromGroup(Part, 'ETaxes', 'CGST', 'ECGST');
            Part.ESGST = this.GetTaxAmountFromGroup(Part, 'ETaxes', 'SGST', 'ESGST');
            Part.EIGST = this.GetTaxAmountFromGroup(Part, 'ETaxes', 'IGST', 'EIGST');
            Part.EstAmt = TrUtils.SetValueToZeroIfNull(Part.EstAmt);
        }
        return Part;
    }

    static GetPartsDiscountPrice(PartsList: any, LaborList: any, isWorkOrder: boolean) {
        PartsList.forEach((Part: any) => {
            if (TrUtils.IsNull(Part.CollId)) {
                if (isWorkOrder) {
                    Part.CustDiscountedPrice = Add(Part.Disc, Part.RecDisc);
                } else {
                    let LaborSts: string = this.GetPartParentStatus(Part, LaborList);
                    if (LaborSts === LaborStatusEnum.New || LaborSts === LaborStatusEnum.WtngForAppr) {
                        Part.CustDiscountedPrice = 0;
                    } else {
                        Part.CustDiscountedPrice = Add(Part.Disc, Part.RecDisc);
                    }
                }
            } else {
                if (isWorkOrder) {
                    Part.CustDiscountedPrice = Add(Part.Disc, Part.RecDisc);
                } else {
                    if (Part.Sts === LaborStatusEnum.New || Part.Sts === LaborStatusEnum.WtngForAppr) {
                        Part.CustDiscountedPrice = 0;
                    } else {
                        Part.CustDiscountedPrice = Add(Part.Disc, Part.RecDisc);
                    }
                }
            }
        });
        return PartsList;
    }

    static GetPartParentStatus(Part: any, LaborList: any) {
        if (!TrUtils.IsNull(Part.OpId)) {
            let index: number = LaborList.findIndex((Labor: any) => {
                return Labor._id === Part.OpId;
            });
            return LaborList[index].Sts;
        } else {
            return Part.Sts;
        }

    }

    static GetPartsAfterDiscount(PartsList: any, LaborList: any, isWorkOrder: boolean) {
        PartsList.forEach((Part: any) => {
            if (TrUtils.IsNull(Part.CollId)) {
                let CustAfterPartDisc: number = 0;
                let InsAfterPartDisc: number = 0;
                if (isWorkOrder) {
                    CustAfterPartDisc = Part.NetAmt;
                    if (TrUtils.IsNull(Part.OpId)) {
                        InsAfterPartDisc = Part.AssAmt;
                    }
                } else {
                    let LaborSts: string = this.GetPartParentStatus(Part, LaborList);
                    if (LaborSts === LaborStatusEnum.New || LaborSts === LaborStatusEnum.WtngForAppr) {
                        CustAfterPartDisc = Part.EstAmt;
                    } else {
                        CustAfterPartDisc = Part.NetAmt;
                        if (TrUtils.IsNull(Part.OpId)) {
                            InsAfterPartDisc = Part.AssAmt;
                        }
                    }
                }
                Part.CustAfterPartDisc = CustAfterPartDisc;
                Part.InsAfterPartDisc = InsAfterPartDisc;
            } else {
                let CustAfterPartDisc: number = 0;
                let InsAfterPartDisc: number = 0;
                if (Part.PBy === PayTypeEnum.Customer) {
                    if (isWorkOrder) {
                        CustAfterPartDisc = Part.NetAmt;
                    } else {
                        if (Part.Sts === LaborStatusEnum.New || Part.Sts === LaborStatusEnum.WtngForAppr) {
                            CustAfterPartDisc = Part.EstAmt;
                        } else {
                            CustAfterPartDisc = Part.NetAmt;
                        }
                    }
                } else {
                    if (isWorkOrder) {
                        CustAfterPartDisc = Part.NetAmt;
                        InsAfterPartDisc = Part.AssAmt;
                    } else {
                        if (Part.Sts === LaborStatusEnum.New || Part.Sts === LaborStatusEnum.WtngForAppr) {
                            InsAfterPartDisc = Part.EstAmt;
                        } else {
                            CustAfterPartDisc = Part.NetAmt;
                            InsAfterPartDisc = Part.AssAmt;
                        }
                    }
                }
                Part.CustAfterPartDisc = CustAfterPartDisc;
                Part.InsAfterPartDisc = InsAfterPartDisc;
            }
        });
        return PartsList;
    }

    static GetPartsAfterTax(PartsList: any, LaborList: any, isWorkOrder: boolean, isTaxable: boolean) {
        PartsList.forEach((Part: any) => {
            if (!isTaxable) {
                Part.CustAfterTax = Part.CustAfterPartDisc;
                Part.InsAfterTax = Part.InsAfterPartDisc;
            } else {
                if (TrUtils.IsNull(Part.CollId)) {
                    if (isWorkOrder) {
                        Part.CustAfterTax = Add(Part.CustAfterPartDisc, Part.CCGST, Part.CSGST, Part.CIGST);
                        if (TrUtils.IsNull(Part.OpId)) {
                            Part.InsAfterTax = Add(Part.InsAfterPartDisc, Part.ACGST, Part.ASGST, Part.AIGST);
                        }
                    } else {
                        let LaborSts: string = this.GetPartParentStatus(Part, LaborList);
                        if (LaborSts === LaborStatusEnum.New || LaborSts === LaborStatusEnum.WtngForAppr) {
                            Part.CustAfterTax = Add(Part.CustAfterPartDisc, Part.ECGST, Part.ESGST, Part.EIGST);
                        } else {
                            Part.CustAfterTax = Add(Part.CustAfterPartDisc, Part.CCGST, Part.CSGST, Part.CIGST);
                            if (TrUtils.IsNull(Part.OpId)) {
                                Part.InsAfterTax = Add(Part.InsAfterPartDisc, Part.ACGST, Part.ASGST, Part.AIGST);
                            }
                        }
                    }
                    // Part.InsAfterTax = 0;

                } else {
                    if (Part.PBy === PayTypeEnum.Customer) {
                        if (isWorkOrder) {
                            Part.CustAfterTax = Add(Part.CustAfterPartDisc, Part.CCGST, Part.CSGST, Part.CIGST);
                        } else {
                            if (Part.Sts !== LaborStatusEnum.New && Part.Sts !== LaborStatusEnum.WtngForAppr) {
                                Part.CustAfterTax = Add(Part.CustAfterPartDisc, Part.CCGST, Part.CSGST, Part.CIGST);
                            } else {
                                Part.CustAfterTax = Add(Part.CustAfterPartDisc, Part.ECGST, Part.ESGST, Part.EIGST);
                            }
                        }
                        Part.InsAfterTax = 0;
                    } else {
                        if (isWorkOrder) {
                            Part.CustAfterTax = Add(Part.CustAfterPartDisc, Part.CCGST, Part.CSGST, Part.CIGST);
                            Part.InsAfterTax = Add(Part.InsAfterPartDisc, Part.ACGST, Part.ASGST, Part.AIGST);
                        } else {
                            if (Part.Sts !== LaborStatusEnum.New && Part.Sts !== LaborStatusEnum.WtngForAppr) {
                                Part.CustAfterTax = Add(Part.CustAfterPartDisc, Part.CCGST, Part.CSGST, Part.CIGST);
                                Part.InsAfterTax = Add(Part.InsAfterPartDisc, Part.ACGST, Part.ASGST, Part.AIGST);
                            } else {
                                Part.CustAfterTax = 0;
                                Part.InsAfterTax = Add(Part.InsAfterPartDisc, Part.ECGST, Part.ESGST, Part.EIGST);
                            }
                        }
                    }
                }
            }
        });
        return PartsList;
    }

    static GetPartsPerItemAfterTax(PartsList: any) {
        PartsList.forEach((Part: any) => {
            Part.CustAfterTaxPerItem = Divide(Part.CustAfterTax, Part.Qty);
            Part.InsAfterTaxPerItem = Divide(Part.InsAfterTax, Part.Qty);
        });
        return PartsList;
    }

    static GetROTotalsData(argRecordData: any, dupRecordData: any, TaxCodes: any, withItems: boolean, detailedInfo: any, isWorkOrder: boolean, isRoundable: boolean, DecimalsNumber: number) {

        dupRecordData = this.ResetDiscountValuesIfInvalid(dupRecordData);
        argRecordData = this.SetMainDiscountValues(argRecordData, dupRecordData, detailedInfo);
        argRecordData = this.GetFinalCustomerTotalsData(argRecordData, dupRecordData, isWorkOrder, detailedInfo, isRoundable, DecimalsNumber);
        argRecordData = this.GetFinalInsuranceTotalsData(argRecordData, dupRecordData, detailedInfo, isWorkOrder, DecimalsNumber);
        if (detailedInfo) {
            argRecordData = this.GetDetailedTotalsData(argRecordData, dupRecordData, TaxCodes, isWorkOrder, DecimalsNumber);
        }
        if (withItems) {
            argRecordData.Ops = dupRecordData.Ops;
            argRecordData.Parts = dupRecordData.Parts;
            argRecordData.Colli = dupRecordData.Colli;
        }
        return argRecordData;
    }

    static ResetDiscountValuesIfInvalid(dupRecordData: any) {
        dupRecordData.LPerc = TrUtils.SetPercToStringIfNull(dupRecordData.LPerc);
        dupRecordData.PPerc = TrUtils.SetPercToStringIfNull(dupRecordData.PPerc);
        dupRecordData.Perc = TrUtils.SetPercToStringIfNull(dupRecordData.Perc);
        dupRecordData.LDisc = TrUtils.SetValueToZeroIfNull(dupRecordData.LDisc);
        dupRecordData.PDisc = TrUtils.SetValueToZeroIfNull(dupRecordData.PDisc);
        dupRecordData.Disc = TrUtils.SetValueToZeroIfNull(dupRecordData.Disc);
        return dupRecordData;
    }

    static SetMainDiscountValues(argRecordData: any, dupRecordData: any, detailedInfo: boolean) {
        argRecordData.LDisc = dupRecordData.LDisc;
        argRecordData.LPerc = dupRecordData.LPerc;
        argRecordData.PDisc = dupRecordData.PDisc;
        argRecordData.PPerc = dupRecordData.PPerc;
        argRecordData.Disc = dupRecordData.Disc;
        argRecordData.Perc = dupRecordData.Perc;
        if (detailedInfo) {
            argRecordData.FixedLDisc = dupRecordData.LDisc;
            argRecordData.FixedPDisc = dupRecordData.PDisc;
            argRecordData.FixedDisc = dupRecordData.Disc;
        }
        return argRecordData;
    }

    static GetFinalCustomerTotalsData(argRecordData: any, dupRecordData: any, isWorkOrder: boolean, detailedInfo: boolean, isRoundable: boolean, DecimalsNumber: number) {
        let CustomerAfterDiscTotals: number = this.GetCustSubTotal(dupRecordData.Ops, dupRecordData.Parts);
        let CustLaborTaxTotal = this.GetCustLaborTaxTotal(dupRecordData.Ops, TrUtils.isTaxable(dupRecordData.Settings.Tax), isWorkOrder);
        let CustPartTaxTotal = this.GetCustPartsTaxTotal(dupRecordData.Ops, dupRecordData.Parts, TrUtils.isTaxable(dupRecordData.Settings.Tax), isWorkOrder);
        let CustLaborDiscTotal: any = this.GetCustLaborDiscountedTotal(dupRecordData.Ops, TrUtils.isTaxable(dupRecordData.Settings.Tax), dupRecordData);
        let CustPartsDiscTotal: any = this.GetCustPartDiscountedTotal(dupRecordData.Parts, TrUtils.isTaxable(dupRecordData.Settings.Tax), dupRecordData);
        let CustLaborTotalAfterDisc: any = this.GetCustLaborTotalAfterDiscount(dupRecordData.Ops);
        let CustPartsTotalAfterDisc: any = this.GetCustPartsTotalAfterDiscount(dupRecordData.Parts);
        argRecordData.STotal = Add(CustLaborDiscTotal, CustPartsDiscTotal, CustLaborTotalAfterDisc, CustPartsTotalAfterDisc)
        argRecordData.CustLaborTotalBeforeDisc = Add(argRecordData.CustLaborTotalAfterDisc
            , argRecordData.CustLaborDiscTotal);
        argRecordData.CustPartsTotalBeforeDisc = Add(argRecordData.CustPartsTotalAfterDisc
            , argRecordData.CustPartsDiscTotal);
        argRecordData.SubTotal = TrUtils.FixedTo(CustomerAfterDiscTotals, DecimalsNumber);
        let CustTotal: any = this.GetCustomerTotalBasedOnTaxType(dupRecordData, CustLaborTaxTotal, CustPartTaxTotal, dupRecordData.Ops, dupRecordData.Parts, TrUtils.isTaxable(dupRecordData.Settings.Tax));
        argRecordData.TaxTotal = Add(CustLaborTaxTotal, CustPartTaxTotal);
        if (detailedInfo) {
            argRecordData.FixedSubTotal = TrUtils.FixedTo(CustomerAfterDiscTotals, DecimalsNumber);
            argRecordData.FixedTotal = TrUtils.FixedTo(CustTotal, DecimalsNumber);
        }

        if (isRoundable) {
            argRecordData.Round = Subtract(Math.round(CustTotal), CustTotal);
            argRecordData.Total = Math.round(CustTotal);
        } else {
            argRecordData.Total = TrUtils.FixedTo(CustTotal, DecimalsNumber);
        }



        return argRecordData;
    }

    static GetCustSubTotal(LaborList: any, PartsList: any) {
        let LaborTotalAfterDisc: any = this.GetCustLaborTotalAfterDiscount(LaborList);
        let PartsTotalAfterDisc: any = this.GetCustPartsTotalAfterDiscount(PartsList);
        return Add(LaborTotalAfterDisc, PartsTotalAfterDisc);
    }

    static GetCustLaborTotalAfterDiscount(LaborList: any) {
        let LaborTotalAfterDisc: any = 0;
        LaborList.forEach((Labor: any) => {
            LaborTotalAfterDisc = Add(LaborTotalAfterDisc, Labor.CustAfterLaborDisc);
        });
        return LaborTotalAfterDisc;
    }

    static GetCustPartsTotalAfterDiscount(PartsList: any) {
        let PartsTotalAfterDisc: any = 0;
        PartsList.forEach((Part: any) => {
            PartsTotalAfterDisc = Add(PartsTotalAfterDisc, Part.CustAfterPartDisc);
        });
        return PartsTotalAfterDisc;
    }

    static GetCustLaborTaxTotal(opCodesList: any, IsTaxable: boolean, isWorkOrder: boolean) {
        let TotalTaxAmt: any = 0;
        if (IsTaxable) {
            opCodesList.forEach((Labor: any) => {
                if (isWorkOrder) {
                    // if (Labor.PBy === PayTypeEnum.Customer) {
                    if ((Labor.PBy === PayTypeEnum.Customer || Labor.PBy === PayTypeEnum.Shared)) {
                        TotalTaxAmt = Add(TotalTaxAmt, Labor.CCGST, Labor.CSGST, Labor.CIGST);
                    }
                    // }else{
                    //     TotalTaxAmt = Add(TotalTaxAmt , Labor.ACGST , Labor.ASGST , Labor.AIGST);
                    // }
                } else {
                    if (Labor.Sts !== LaborStatusEnum.New && Labor.Sts !== LaborStatusEnum.WtngForAppr) {
                        TotalTaxAmt = Add(TotalTaxAmt, Labor.CCGST, Labor.CSGST, Labor.CIGST);
                    } else {
                        if (Labor.PBy === PayTypeEnum.Customer) {
                            TotalTaxAmt = Add(TotalTaxAmt, Labor.ECGST, Labor.ESGST, Labor.EIGST);
                        }
                    }
                }
            });
        }
        return TotalTaxAmt;
    }

    static GetCustPartsTaxTotal(OpsList: any, PartsList: any, IsTaxable: boolean, isWorkOrder: boolean) {
        let TotalTaxAmt: any = 0;
        if (IsTaxable) {
            PartsList.forEach((Part: any) => {
                if (!TrUtils.IsNull(Part.CollId)) {
                    if (isWorkOrder) {
                        if ((Part.PBy === PayTypeEnum.Customer || Part.PBy === PayTypeEnum.Shared)) {
                            TotalTaxAmt = Add(TotalTaxAmt, Part.CCGST, Part.CSGST, Part.CIGST);
                        }
                    } else {
                        if (Part.Sts !== LaborStatusEnum.New && Part.Sts !== LaborStatusEnum.WtngForAppr) {
                            TotalTaxAmt = Add(TotalTaxAmt, Part.CCGST, Part.CSGST, Part.CIGST);
                        } else {
                            if (Part.PBy === PayTypeEnum.Customer) {
                                TotalTaxAmt = Add(TotalTaxAmt, Part.ECGST, Part.ESGST, Part.EIGST);
                            }
                        }
                    }
                } else {
                    if (isWorkOrder) {
                        // if (Part.PBy === PayTypeEnum.Customer) {
                        if ((Part.PBy === PayTypeEnum.Customer || Part.PBy === PayTypeEnum.Shared)) {
                            TotalTaxAmt = Add(TotalTaxAmt, Part.CCGST, Part.CSGST, Part.CIGST);
                        }
                        // }else{
                        //         TotalTaxAmt = Add(TotalTaxAmt , Part.ACGST , Part.ASGST , Part.AIGST);
                        //     }
                    } else {
                        let Index: any = OpsList.findIndex((labor: any) => {
                            return labor._id === Part.OpId;
                        });
                        if (Index !== -1) {
                            if (OpsList[Index].Sts !== LaborStatusEnum.New && OpsList[Index].Sts !== LaborStatusEnum.WtngForAppr) {
                                TotalTaxAmt = Add(TotalTaxAmt, Part.CCGST, Part.CSGST, Part.CIGST);
                            } else {
                                TotalTaxAmt = Add(TotalTaxAmt, Part.ECGST, Part.ESGST, Part.EIGST);
                            }
                        } else {
                            TotalTaxAmt = Add(TotalTaxAmt, Part.CCGST, Part.CSGST, Part.CIGST);
                        }
                    }
                }
            });
        }
        return TotalTaxAmt;
    }

    static GetCustomerTotalBasedOnTaxType(dupRecordData: any, LaborTaxAmount: number, PartsTaxAmount: number, LaborList: any, PartsList: any, IsTaxable: boolean) {

        let SubTotalWithTax: any = 0;
        let LaborTotalAfterDisc: any = this.GetCustLaborTotalAfterDiscount(LaborList);
        let PartsTotalAfterDisc: any = this.GetCustPartsTotalAfterDiscount(PartsList);

        if (IsTaxable) {
            SubTotalWithTax = Add(LaborTotalAfterDisc, PartsTotalAfterDisc, LaborTaxAmount, PartsTaxAmount);
        } else {
            SubTotalWithTax = Add(LaborTotalAfterDisc, PartsTotalAfterDisc);
        }

        return SubTotalWithTax;
    }

    static GetFinalInsuranceTotalsData(argRecordData: any, dupRecordData: any, detailedInfo: boolean, isWorkOrder: boolean, DecimalsNumber: number) {
        let InsuranceAfterDiscTotals: number = this.GetInsSubTotal(dupRecordData.Ops, dupRecordData.Parts);

        let InsLaborTaxTotal = this.GetInsLaborTaxTotal(dupRecordData.Ops, TrUtils.isTaxable(dupRecordData.Settings.Tax), isWorkOrder);

        let InsPartTaxTotal = this.GetInsPartsTaxTotal(dupRecordData.Parts, TrUtils.isTaxable(dupRecordData.Settings.Tax), isWorkOrder);

        let InsTotal: any = this.GetInsuranceTotalBasedOnTaxType(InsuranceAfterDiscTotals, InsLaborTaxTotal, InsPartTaxTotal,
            TrUtils.isTaxable(dupRecordData.Settings.Tax));

        argRecordData.InsTaxTotal = Add(InsLaborTaxTotal, InsPartTaxTotal);
        argRecordData.InsTotal = TrUtils.FixedTo(InsTotal, DecimalsNumber);

        if (detailedInfo) {
            argRecordData.FixedInsTotal = TrUtils.FixedTo(InsTotal, DecimalsNumber);
        }

        return argRecordData;
    }

    static GetInsSubTotal(LaborList: any, PartsList: any) {
        let LaborTotalAfterDisc: any = this.GetInsLaborTotalAfterDiscount(LaborList);
        let PartsTotalAfterDisc: any = this.GetInsPartsTotalAfterDiscount(PartsList);
        return Add(LaborTotalAfterDisc, PartsTotalAfterDisc);
    }

    static GetInsLaborTotalAfterDiscount(LaborList: any) {
        let LaborTotalAfterDisc: any = 0;
        LaborList.forEach((Labor: any) => {
            LaborTotalAfterDisc = Add(LaborTotalAfterDisc, Labor.InsAfterLaborDisc);
        });
        return LaborTotalAfterDisc;
    }

    static GetInsPartsTotalAfterDiscount(PartsList: any) {
        let PartsTotalAfterDisc: any = 0;
        PartsList.forEach((Part: any) => {
            PartsTotalAfterDisc = Add(PartsTotalAfterDisc, Part.InsAfterPartDisc);
        });
        return PartsTotalAfterDisc;
    }

    static GetInsLaborTaxTotal(opCodesList: any, IsTaxable: boolean, isWorkOrder: boolean) {
        let TotalTaxAmt: any = 0;
        if (IsTaxable) {
            opCodesList.forEach((Labor: any) => {
                if (isWorkOrder) {
                    if ((Labor.PBy === PayTypeEnum.Insurance || Labor.PBy === PayTypeEnum.Shared)) {
                        TotalTaxAmt = Add(TotalTaxAmt, Labor.ACGST, Labor.ASGST, Labor.AIGST);
                    }
                } else {
                    if (Labor.Sts !== LaborStatusEnum.New && Labor.Sts !== LaborStatusEnum.WtngForAppr) {
                        TotalTaxAmt = Add(TotalTaxAmt, Labor.ACGST, Labor.ASGST, Labor.AIGST);
                    } else {
                        if (Labor.PBy === PayTypeEnum.Insurance || Labor.PBy === PayTypeEnum.Shared) {
                            TotalTaxAmt = Add(TotalTaxAmt, Labor.ECGST, Labor.ESGST, Labor.EIGST);
                        }
                    }
                }
            });
        }
        return TotalTaxAmt;
    }

    static GetInsPartsTaxTotal(PartsList: any, IsTaxable: boolean, isWorkOrder: boolean) {
        let TotalTaxAmt: any = 0;
        if (IsTaxable) {
            PartsList.forEach((Part: any) => {
                if (!TrUtils.IsNull(Part.CollId) || Part.PBy === PayTypeEnum.Insurance || Part.PBy === PayTypeEnum.Shared) {
                    if (isWorkOrder) {
                        if ((Part.PBy === PayTypeEnum.Insurance || Part.PBy === PayTypeEnum.Shared)) {
                            TotalTaxAmt = Add(TotalTaxAmt, Part.ACGST, Part.ASGST, Part.AIGST);
                        }
                    } else {
                        if (Part.Sts !== LaborStatusEnum.New && Part.Sts !== LaborStatusEnum.WtngForAppr) {
                            TotalTaxAmt = Add(TotalTaxAmt, Part.ACGST, Part.ASGST, Part.AIGST);
                        } else {
                            if (Part.PBy === PayTypeEnum.Insurance || Part.PBy === PayTypeEnum.Shared) {
                                TotalTaxAmt = Add(TotalTaxAmt, Part.ECGST, Part.ESGST, Part.EIGST);
                            }
                        }
                    }
                }
            });
        }
        return TotalTaxAmt;
    }

    static GetInsuranceTotalBasedOnTaxType(SubTotal: number, LaborTaxAmount: number, PartsTaxAmount: number, IsTaxable: boolean) {
        let InsTotal: any = 0;
        if (IsTaxable) {
            InsTotal = Add(SubTotal, LaborTaxAmount, PartsTaxAmount);
        } else {
            InsTotal = (SubTotal);
        }
        return InsTotal;
    }

    static GetDetailedTotalsData(argRecordData: any, dupRecordData: any, TaxCodes: any, isWorkOrder: boolean, DecimalsNumber: number) {
        argRecordData.InsLaborDiscTotal = 0;
        argRecordData.InsPartsDiscTotal = 0;

        argRecordData.InsLaborTotalAfterDisc = this.GetInsLaborTotalAfterDiscount(dupRecordData.Ops);
        argRecordData.InsPartsTotalAfterDisc = this.GetInsPartsTotalAfterDiscount(dupRecordData.Parts);

        argRecordData.InsLaborTotalBeforeDisc = Add(argRecordData.InsLaborTotalAfterDisc
            , argRecordData.InsLaborDiscTotal);
        argRecordData.InsPartsTotalBeforeDisc = Add(argRecordData.InsPartsTotalAfterDisc
            , argRecordData.InsPartsDiscTotal);

        argRecordData.InsLaborITax = this.GetInsLaborTaxTotal(dupRecordData.Ops, TrUtils.isTaxable(dupRecordData.Settings.Tax), isWorkOrder);
        argRecordData.InsLaborCGST = this.GetInsLaborCGSTTaxTotal(dupRecordData.Ops, TrUtils.isTaxable(dupRecordData.Settings.Tax), isWorkOrder);
        argRecordData.InsLaborIGST = this.GetInsLaborIGSTTaxTotal(dupRecordData.Ops, TrUtils.isTaxable(dupRecordData.Settings.Tax), isWorkOrder);
        argRecordData.InsLaborSGST = this.GetInsLaborSGSTTaxTotal(dupRecordData.Ops, TrUtils.isTaxable(dupRecordData.Settings.Tax), isWorkOrder);

        argRecordData.InsPartITax = this.GetInsPartsTaxTotal(dupRecordData.Parts, TrUtils.isTaxable(dupRecordData.Settings.Tax), isWorkOrder);
        argRecordData.InsPartCGST = this.GetInsPartCGSTTaxTotal(dupRecordData.Parts, TrUtils.isTaxable(dupRecordData.Settings.Tax), isWorkOrder);
        argRecordData.InsPartIGST = this.GetInsPartIGSTTaxTotal(dupRecordData.Parts, TrUtils.isTaxable(dupRecordData.Settings.Tax), isWorkOrder);
        argRecordData.InsPartSGST = this.GetInsPartSGSTTaxTotal(dupRecordData.Parts, TrUtils.isTaxable(dupRecordData.Settings.Tax), isWorkOrder);

        argRecordData.InsLaborTotalAfterTax = Add(argRecordData.InsLaborTotalAfterDisc,
            argRecordData.InsLaborITax);
        argRecordData.InsPartsTotalAfterTax = Add(argRecordData.InsPartsTotalAfterDisc,
            argRecordData.InsPartITax);

        argRecordData.CustLaborDiscTotal = this.GetCustLaborDiscountedTotal(dupRecordData.Ops, TrUtils.isTaxable(dupRecordData.Settings.Tax), dupRecordData);
        argRecordData.CustPartsDiscTotal = this.GetCustPartDiscountedTotal(dupRecordData.Parts, TrUtils.isTaxable(dupRecordData.Settings.Tax), dupRecordData);

        argRecordData.CustLaborTotalAfterDisc = this.GetCustLaborTotalAfterDiscount(dupRecordData.Ops);
        argRecordData.CustPartsTotalAfterDisc = this.GetCustPartsTotalAfterDiscount(dupRecordData.Parts);

        argRecordData.CustLaborTotalBeforeDisc = Add(argRecordData.CustLaborTotalAfterDisc
            , argRecordData.CustLaborDiscTotal);
        argRecordData.CustPartsTotalBeforeDisc = Add(argRecordData.CustPartsTotalAfterDisc
            , argRecordData.CustPartsDiscTotal);

        argRecordData.CustLaborITax = this.GetCustLaborTaxTotal(dupRecordData.Ops, TrUtils.isTaxable(dupRecordData.Settings.Tax), isWorkOrder);
        argRecordData.CustLaborSGST = this.GetCustLaborSGSTTaxTotal(dupRecordData.Ops, TrUtils.isTaxable(dupRecordData.Settings.Tax), isWorkOrder);
        argRecordData.CustLaborCGST = this.GetCustLaborCGSTTaxTotal(dupRecordData.Ops, TrUtils.isTaxable(dupRecordData.Settings.Tax), isWorkOrder);
        argRecordData.CustLaborIGST = this.GetCustLaborIGSTTaxTotal(dupRecordData.Ops, TrUtils.isTaxable(dupRecordData.Settings.Tax), isWorkOrder);

        argRecordData.CustPartITax = this.GetCustPartsTaxTotal(dupRecordData.Ops, dupRecordData.Parts, TrUtils.isTaxable(dupRecordData.Settings.Tax), isWorkOrder);
        argRecordData.CustPartCGST = this.GetCustPartCGSTTaxTotal(dupRecordData.Ops, dupRecordData.Parts, TrUtils.isTaxable(dupRecordData.Settings.Tax), isWorkOrder);
        argRecordData.CustPartIGST = this.GetCustPartIGSTTaxTotal(dupRecordData.Ops, dupRecordData.Parts, TrUtils.isTaxable(dupRecordData.Settings.Tax), isWorkOrder);
        argRecordData.CustPartSGST = this.GetCustPartSGSTTaxTotal(dupRecordData.Ops, dupRecordData.Parts, TrUtils.isTaxable(dupRecordData.Settings.Tax), isWorkOrder);


        argRecordData.CustLaborLDiscAmount = this.GetLaborLDiscAmount(argRecordData.CustLaborTotalAfterDisc, argRecordData.LDisc);
        argRecordData.CustPartsPDiscAmount = this.GetPartsPDiscAmount(argRecordData.CustPartsTotalAfterDisc, argRecordData.PDisc);

        argRecordData.CustLaborAfterLDisc = argRecordData.CustLaborTotalAfterDisc;
        argRecordData.CustPartsAfterPDisc = argRecordData.CustPartsTotalAfterDisc;

        argRecordData.CustLaborAfterTax = Add(argRecordData.CustLaborITax, argRecordData.CustLaborAfterLDisc);
        argRecordData.CustPartAfterTax = Add(argRecordData.CustPartITax, argRecordData.CustPartsAfterPDisc);

        argRecordData.CustTaxGroupData = this.GetCustPartsTaxGrouping(dupRecordData.Parts, TaxCodes, isWorkOrder, DecimalsNumber);
        argRecordData.InsTaxGroupData = this.GetInsPartsTaxGrouping(dupRecordData.Parts, TaxCodes, DecimalsNumber);

        argRecordData.CustTotalRoundedBy = argRecordData.Round;
        argRecordData.InsTotalRoundedBy = TrUtils.FixedTo(Subtract(Math.round(argRecordData.InsTotal), argRecordData.InsTotal), DecimalsNumber);

        argRecordData.CustRoundedTotal = argRecordData.Total;
        argRecordData.InsRoundedTotal = Math.round(argRecordData.InsTotal);

        for (var key in argRecordData) {
            if (key !== 'Total' && key !== 'InsTotal' && key !== 'SubTotal' &&
                key !== 'LDisc' && key !== 'LPerc' && key !== 'PDisc' &&
                key !== 'PPerc' && key !== 'Disc' && key !== 'Perc' && key !== 'Tax'
                && typeof argRecordData[key] === 'number') {
                argRecordData[key] = TrUtils.FixPriceValue(argRecordData[key], DecimalsNumber);
            }
        }

        return argRecordData;
    }

    static GetCustLaborDiscountedTotal(LaborList: any, isTaxable: boolean, finalTotalsData: any) {
        let LaborDiscountedTotal: any = 0;
        let overallLaborDisc: number = 0;
        if (!isTaxable) {
            overallLaborDisc = TrUtils.SetValueToZeroIfNull(finalTotalsData.LDisc)
        }
        LaborList.forEach((Labor: any) => {
            LaborDiscountedTotal = Add(LaborDiscountedTotal, Labor.CustDiscountedPrice);
        });
        return Add(LaborDiscountedTotal, overallLaborDisc);
    }

    static GetCustPartDiscountedTotal(PartsList: any, isTaxable: boolean, finalTotalsData: any) {
        let PartsDiscountedTotal: any = 0;
        let overallPartDisc: number = 0;
        if (!isTaxable) {
            overallPartDisc = TrUtils.SetValueToZeroIfNull(finalTotalsData.PDisc)
        }
        PartsList.forEach((Part: any) => {
            PartsDiscountedTotal = Add(PartsDiscountedTotal, Part.CustDiscountedPrice);
        });
        return Add(PartsDiscountedTotal, overallPartDisc);
    }

    static GetCustLaborCGSTTaxTotal(opCodesList: any, IsTaxable: boolean, isWorkOrder: boolean) {
        let TotalTaxAmt: any = 0;
        if (IsTaxable) {
            opCodesList.forEach((Labor: any) => {
                if (isWorkOrder) {
                    TotalTaxAmt = Add(TotalTaxAmt, Labor.CCGST);
                } else {
                    if (Labor.Sts !== LaborStatusEnum.New && Labor.Sts !== LaborStatusEnum.WtngForAppr) {
                        TotalTaxAmt = Add(TotalTaxAmt, Labor.CCGST);
                    } else {
                        if (Labor.PBy === PayTypeEnum.Customer) {
                            TotalTaxAmt = Add(TotalTaxAmt, Labor.ECGST);
                        }
                    }
                }
            });
        }
        return TotalTaxAmt;
    }

    static GetCustLaborIGSTTaxTotal(opCodesList: any, IsTaxable: boolean, isWorkOrder: boolean) {
        let TotalTaxAmt: any = 0;
        if (IsTaxable) {
            opCodesList.forEach((Labor: any) => {
                if (isWorkOrder) {
                    TotalTaxAmt = Add(TotalTaxAmt, Labor.CIGST);
                } else {
                    if (Labor.Sts !== LaborStatusEnum.New && Labor.Sts !== LaborStatusEnum.WtngForAppr) {
                        TotalTaxAmt = Add(TotalTaxAmt, Labor.CIGST);
                    } else {
                        if (Labor.PBy === PayTypeEnum.Customer) {
                            TotalTaxAmt = Add(TotalTaxAmt, Labor.EIGST);
                        }
                    }
                }
            });
        }
        return TotalTaxAmt;
    }

    static GetCustLaborSGSTTaxTotal(opCodesList: any, IsTaxable: boolean, isWorkOrder: boolean) {
        let TotalTaxAmt: any = 0;
        if (IsTaxable) {
            opCodesList.forEach((Labor: any) => {
                if (isWorkOrder) {
                    TotalTaxAmt = Add(TotalTaxAmt, Labor.CSGST);
                } else {
                    if (Labor.Sts !== LaborStatusEnum.New && Labor.Sts !== LaborStatusEnum.WtngForAppr) {
                        TotalTaxAmt = Add(TotalTaxAmt, Labor.CSGST);
                    } else {
                        if (Labor.PBy === PayTypeEnum.Customer) {
                            TotalTaxAmt = Add(TotalTaxAmt, Labor.ESGST);
                        }
                    }
                }
            });
        }
        return TotalTaxAmt;
    }

    static GetCustPartCGSTTaxTotal(OpsList: any, PartsList: any, IsTaxable: boolean, isWorkOrder: boolean) {
        let TotalTaxAmt: any = 0;
        if (IsTaxable) {
            PartsList.forEach((Part: any) => {
                if (!TrUtils.IsNull(Part.CollId)) {
                    if (isWorkOrder) {
                        TotalTaxAmt = Add(TotalTaxAmt, Part.CCGST);
                    } else {
                        if (Part.Sts !== LaborStatusEnum.New && Part.Sts !== LaborStatusEnum.WtngForAppr) {
                            TotalTaxAmt = Add(TotalTaxAmt, Part.CCGST);
                        } else {
                            if (Part.PBy === PayTypeEnum.Customer) {
                                TotalTaxAmt = Add(TotalTaxAmt, Part.ECGST);
                            }
                        }
                    }
                } else {
                    if (isWorkOrder) {
                        TotalTaxAmt = Add(TotalTaxAmt, Part.CCGST);
                    } else {
                        let Index: any = OpsList.findIndex((labor: any) => {
                            return labor._id === Part.OpId;
                        });
                        if (Index !== -1) {
                            if (OpsList[Index].Sts !== LaborStatusEnum.New && OpsList[Index].Sts !== LaborStatusEnum.WtngForAppr) {
                                TotalTaxAmt = Add(TotalTaxAmt, Part.CCGST);
                            } else {
                                TotalTaxAmt = Add(TotalTaxAmt, Part.ECGST);
                            }
                        } else {
                            TotalTaxAmt = Add(TotalTaxAmt, Part.CCGST);
                        }
                    }
                }
            });
        }
        return TotalTaxAmt;
    }

    static GetCustPartIGSTTaxTotal(OpsList: any, PartsList: any, IsTaxable: boolean, isWorkOrder: boolean) {
        let TotalTaxAmt: any = 0;
        if (IsTaxable) {
            PartsList.forEach((Part: any) => {
                if (!TrUtils.IsNull(Part.CollId)) {
                    if (isWorkOrder) {
                        TotalTaxAmt = Add(TotalTaxAmt, Part.CIGST);
                    } else {
                        if (Part.Sts !== LaborStatusEnum.New && Part.Sts !== LaborStatusEnum.WtngForAppr) {
                            TotalTaxAmt = Add(TotalTaxAmt, Part.CIGST);
                        } else {
                            if (Part.PBy === PayTypeEnum.Customer) {
                                TotalTaxAmt = Add(TotalTaxAmt, Part.EIGST);
                            }
                        }
                    }
                } else {
                    if (isWorkOrder) {
                        TotalTaxAmt = Add(TotalTaxAmt, Part.CIGST);
                    } else {
                        let Index: any = OpsList.findIndex((labor: any) => {
                            return labor._id === Part.OpId;
                        });
                        if (Index !== -1) {
                            if (OpsList[Index].Sts !== LaborStatusEnum.New && OpsList[Index].Sts !== LaborStatusEnum.WtngForAppr) {
                                TotalTaxAmt = Add(TotalTaxAmt, Part.CIGST);
                            } else {
                                TotalTaxAmt = Add(TotalTaxAmt, Part.EIGST);
                            }
                        } else {
                            TotalTaxAmt = Add(TotalTaxAmt, Part.CIGST);
                        }
                    }
                }
            });
        }
        return TotalTaxAmt;
    }

    static GetCustPartSGSTTaxTotal(OpsList: any, PartsList: any, IsTaxable: boolean, isWorkOrder: boolean) {
        let TotalTaxAmt: any = 0;
        if (IsTaxable) {
            PartsList.forEach((Part: any) => {
                if (!TrUtils.IsNull(Part.CollId)) {
                    if (isWorkOrder) {
                        TotalTaxAmt = Add(TotalTaxAmt, Part.CSGST);
                    } else {
                        if (Part.Sts !== LaborStatusEnum.New && Part.Sts !== LaborStatusEnum.WtngForAppr) {
                            TotalTaxAmt = Add(TotalTaxAmt, Part.CSGST);
                        } else {
                            if (Part.PBy === PayTypeEnum.Customer) {
                                TotalTaxAmt = Add(TotalTaxAmt, Part.ESGST);
                            }
                        }
                    }
                } else {
                    if (isWorkOrder) {
                        TotalTaxAmt = Add(TotalTaxAmt, Part.CSGST);
                    } else {
                        let Index: any = OpsList.findIndex((labor: any) => {
                            return labor._id === Part.OpId;
                        });
                        if (Index !== -1) {
                            if (OpsList[Index].Sts !== LaborStatusEnum.New && OpsList[Index].Sts !== LaborStatusEnum.WtngForAppr) {
                                TotalTaxAmt = Add(TotalTaxAmt, Part.CSGST);
                            } else {
                                TotalTaxAmt = Add(TotalTaxAmt, Part.ESGST);
                            }
                        } else {
                            TotalTaxAmt = Add(TotalTaxAmt, Part.CSGST);
                        }
                    }
                }
            });
        }
        return TotalTaxAmt;
    }

    static GetInsLaborCGSTTaxTotal(opCodesList: any, IsTaxable: boolean, isWorkOrder: boolean) {
        let TotalTaxAmt: any = 0;
        if (IsTaxable) {
            opCodesList.forEach((Labor: any) => {
                if (isWorkOrder) {
                    TotalTaxAmt = Add(TotalTaxAmt, Labor.ACGST);
                } else {
                    if (Labor.Sts !== LaborStatusEnum.New && Labor.Sts !== LaborStatusEnum.WtngForAppr) {
                        TotalTaxAmt = Add(TotalTaxAmt, Labor.ACGST);
                    } else {
                        if (Labor.PBy === PayTypeEnum.Insurance || Labor.PBy === PayTypeEnum.Shared) {
                            TotalTaxAmt = Add(TotalTaxAmt, Labor.ECGST);
                        }
                    }
                }
            });
        }
        return TotalTaxAmt;
    }

    static GetInsLaborIGSTTaxTotal(opCodesList: any, IsTaxable: boolean, isWorkOrder: boolean) {
        let TotalTaxAmt: any = 0;
        if (IsTaxable) {
            opCodesList.forEach((Labor: any) => {
                if (isWorkOrder) {
                    TotalTaxAmt = Add(TotalTaxAmt, Labor.AIGST);
                } else {
                    if (Labor.Sts !== LaborStatusEnum.New && Labor.Sts !== LaborStatusEnum.WtngForAppr) {
                        TotalTaxAmt = Add(TotalTaxAmt, Labor.AIGST);
                    } else {
                        if (Labor.PBy === PayTypeEnum.Insurance || Labor.PBy === PayTypeEnum.Shared) {
                            TotalTaxAmt = Add(TotalTaxAmt, Labor.EIGST);
                        }
                    }
                }
            });
        }
        return TotalTaxAmt;
    }

    static GetInsLaborSGSTTaxTotal(opCodesList: any, IsTaxable: boolean, isWorkOrder: boolean) {
        let TotalTaxAmt: any = 0;
        if (IsTaxable) {
            opCodesList.forEach((Labor: any) => {
                if (isWorkOrder) {
                    TotalTaxAmt = Add(TotalTaxAmt, Labor.ASGST);
                } else {
                    if (Labor.Sts !== LaborStatusEnum.New && Labor.Sts !== LaborStatusEnum.WtngForAppr) {
                        TotalTaxAmt = Add(TotalTaxAmt, Labor.ASGST);
                    } else {
                        if (Labor.PBy === PayTypeEnum.Insurance || Labor.PBy === PayTypeEnum.Shared) {
                            TotalTaxAmt = Add(TotalTaxAmt, Labor.ESGST);
                        }
                    }
                }
            });
        }
        return TotalTaxAmt;
    }

    static GetInsPartCGSTTaxTotal(PartsList: any, IsTaxable: boolean, isWorkOrder: boolean) {
        let TotalTaxAmt: any = 0;
        if (IsTaxable) {
            PartsList.forEach((Part: any) => {
                if (!TrUtils.IsNull(Part.CollId) || Part.PBy === PayTypeEnum.Insurance || Part.PBy === PayTypeEnum.Shared) {
                    if (isWorkOrder) {
                        TotalTaxAmt = Add(TotalTaxAmt, Part.ACGST);
                    } else {
                        if (Part.Sts !== LaborStatusEnum.New && Part.Sts !== LaborStatusEnum.WtngForAppr) {
                            TotalTaxAmt = Add(TotalTaxAmt, Part.ACGST);
                        } else {
                            if (Part.PBy === PayTypeEnum.Insurance || Part.PBy === PayTypeEnum.Shared) {
                                TotalTaxAmt = Add(TotalTaxAmt, Part.ECGST);
                            }
                        }
                    }
                }
            });
        }
        return TotalTaxAmt;
    }

    static GetInsPartIGSTTaxTotal(PartsList: any, IsTaxable: boolean, isWorkOrder: boolean) {
        let TotalTaxAmt: any = 0;
        if (IsTaxable) {
            PartsList.forEach((Part: any) => {
                if (!TrUtils.IsNull(Part.CollId) || Part.PBy === PayTypeEnum.Insurance || Part.PBy === PayTypeEnum.Shared) {
                    if (isWorkOrder) {
                        TotalTaxAmt = Add(TotalTaxAmt, Part.AIGST);
                    } else {
                        if (Part.Sts !== LaborStatusEnum.New && Part.Sts !== LaborStatusEnum.WtngForAppr) {
                            TotalTaxAmt = Add(TotalTaxAmt, Part.AIGST);
                        } else {
                            if (Part.PBy === PayTypeEnum.Insurance || Part.PBy === PayTypeEnum.Shared) {
                                TotalTaxAmt = Add(TotalTaxAmt, Part.EIGST);
                            }
                        }
                    }
                }
            });
        }
        return TotalTaxAmt;
    }

    static GetInsPartSGSTTaxTotal(PartsList: any, IsTaxable: boolean, isWorkOrder: boolean) {
        let TotalTaxAmt: any = 0;
        if (IsTaxable) {
            PartsList.forEach((Part: any) => {
                if (!TrUtils.IsNull(Part.CollId) || Part.PBy === PayTypeEnum.Insurance || Part.PBy === PayTypeEnum.Shared) {
                    if (isWorkOrder) {
                        TotalTaxAmt = Add(TotalTaxAmt, Part.ASGST);
                    } else {
                        if (Part.Sts !== LaborStatusEnum.New && Part.Sts !== LaborStatusEnum.WtngForAppr) {
                            TotalTaxAmt = Add(TotalTaxAmt, Part.ASGST);
                        } else {
                            if (Part.PBy === PayTypeEnum.Insurance || Part.PBy === PayTypeEnum.Shared) {
                                TotalTaxAmt = Add(TotalTaxAmt, Part.ESGST);
                            }
                        }
                    }
                }
            });
        }
        return TotalTaxAmt;
    }

    static GetLaborLDiscAmount(LaborTotalAfterDisc: any, LDisc: any) {
        let LaborLDiscAmt: any = 0;

        if (!TrUtils.IsZero(LaborTotalAfterDisc)) {
            LaborLDiscAmt = LDisc;
        }
        return LaborLDiscAmt;
    }

    static GetPartsPDiscAmount(PartsTotalAfterDisc: any, PDisc: any) {
        let PartsPDiscAmt: any = 0;

        if (!TrUtils.IsZero(PartsTotalAfterDisc)) {
            PartsPDiscAmt = PDisc;
        }

        return PartsPDiscAmt;
    }

    static GetCustPartsTaxGrouping(PartsList: any, TaxCodes: any, isWorkOrder: boolean, DecimalsNumber: number) {
        let FilteredPartsList = this.GetCustParts(PartsList);
        return this.GetCustTaxGroupingForPartsByHSN(FilteredPartsList, TaxCodes, isWorkOrder, DecimalsNumber);
    }

    static GetCustParts(PartsList: any) {
        let FilteredPartsList: any[] = PartsList.filter((Part: any) => {
            return Part.PBy === PayTypeEnum.Customer || Part.PBy === PayTypeEnum.Shared;
        });
        return FilteredPartsList;
    }

    static GetCustTaxGroupingForPartsByHSN(Parts: any, TaxCodes: any, isWorkOrder: boolean, DecimalsNumber: number) {
        Parts = this.GetCombinedTaxPercentage(Parts, TaxCodes);
        Parts = this.ResetPartsHSNIfInvalid(Parts);

        let FinalMatchedParts: any[] = this.ComparePartsByHSN(Parts, TaxCodes);

        return this.GetCustTaxGroupingInfoByHSN(FinalMatchedParts, TaxCodes, isWorkOrder, DecimalsNumber);
    }

    static GetCustTaxGroupingInfoByHSN(FinalMatchedParts: any, TaxCodes: any, isWorkOrder: boolean, DecimalsNumber: number) {
        let HSNTaxInfo: any[] = [];
        FinalMatchedParts.forEach((MatchedPart: any) => {
            let TaxInfo: any = {};
            let TaxOnAmount: any = 0;
            let TaxAmount: any = 0;
            let CGSTAmt: any = 0;
            let SGSTAmt: any = 0;
            let IGSTAmt: any = 0;
            let HSN: any = MatchedPart[0].HSN;
            TaxInfo.CombinedTaxPercentage = MatchedPart[0].CombinedTaxPercentage;
            MatchedPart.forEach((argMatchedGSTPart: any) => {
                TaxOnAmount = Add(TaxOnAmount, TrUtils.FixedTo(argMatchedGSTPart.CustAfterPartDisc, DecimalsNumber));
                if (isWorkOrder) {
                    CGSTAmt = Add(CGSTAmt, TrUtils.FixedTo(argMatchedGSTPart.CCGST, DecimalsNumber));
                    IGSTAmt = Add(IGSTAmt, TrUtils.FixedTo(argMatchedGSTPart.CIGST, DecimalsNumber));
                    SGSTAmt = Add(SGSTAmt, TrUtils.FixedTo(argMatchedGSTPart.CSGST, DecimalsNumber));
                } else {
                    if (argMatchedGSTPart.Sts !== LaborStatusEnum.New && argMatchedGSTPart.Sts !== LaborStatusEnum.WtngForAppr) {
                        CGSTAmt = Add(CGSTAmt, TrUtils.FixedTo(argMatchedGSTPart.CCGST, DecimalsNumber));
                        IGSTAmt = Add(IGSTAmt, TrUtils.FixedTo(argMatchedGSTPart.CIGST, DecimalsNumber));
                        SGSTAmt = Add(SGSTAmt, TrUtils.FixedTo(argMatchedGSTPart.CSGST, DecimalsNumber));
                    } else {
                        if (argMatchedGSTPart.PBy === PayTypeEnum.Customer) {
                            CGSTAmt = Add(CGSTAmt, TrUtils.FixedTo(argMatchedGSTPart.ECGST, DecimalsNumber));
                            IGSTAmt = Add(IGSTAmt, TrUtils.FixedTo(argMatchedGSTPart.EIGST, DecimalsNumber));
                            SGSTAmt = Add(SGSTAmt, TrUtils.FixedTo(argMatchedGSTPart.ESGST, DecimalsNumber));
                        }
                    }
                }
            });
            TaxAmount = Add(CGSTAmt, SGSTAmt, IGSTAmt);
            TaxInfo.HSN = HSN;
            TaxInfo.TotalTaxableAmount = TrUtils.FixPriceValue(TaxOnAmount, DecimalsNumber);
            TaxInfo.CGSTAmt = TrUtils.FixPriceValue(CGSTAmt, DecimalsNumber);
            TaxInfo.SGSTAmt = TrUtils.FixPriceValue(SGSTAmt, DecimalsNumber);
            TaxInfo.IGSTAmt = TrUtils.FixPriceValue(IGSTAmt, DecimalsNumber);
            TaxInfo.TotalTaxAmount = TrUtils.FixPriceValue(TaxAmount, DecimalsNumber);
            TaxInfo.PartsCount = MatchedPart.length;
            let GSTValues: any[] = this.GetGSTValueBasedOnTaxCode(MatchedPart[0], TaxCodes);
           console.log("GSTValues: ", GSTValues);
            TaxInfo.CGST = GSTValues[0];
            TaxInfo.SGST = GSTValues[1];
            TaxInfo.IGST = GSTValues[2];
            if (TaxOnAmount !== 0) {
                HSNTaxInfo.push(TaxInfo);
            }
        });
        return HSNTaxInfo;
    }

    static GetInsPartsTaxGrouping(PartsList: any, TaxCodes: any, DecimalsNumber: number) {
        let FilteredPartsList = this.GetInsParts(PartsList);
        return this.GetInsTaxGroupingForPartsByHSN(FilteredPartsList, TaxCodes, DecimalsNumber);
    }

    static GetInsParts(PartsList: any) {
        let FilteredPartsList: any[] = PartsList.filter((Part: any) => {
            return Part.PBy === PayTypeEnum.Insurance || Part.PBy === PayTypeEnum.Shared;
        });
        return FilteredPartsList;
    }

    static GetInsTaxGroupingForPartsByHSN(Parts: any, TaxCodes: any, DecimalsNumber: number) {
        Parts = this.GetCombinedTaxPercentage(Parts, TaxCodes);
        Parts = this.ResetPartsHSNIfInvalid(Parts);

        let FinalMatchedParts: any[] = this.ComparePartsByHSN(Parts, TaxCodes);

        return this.GetInsTaxGroupingInfoByHSN(FinalMatchedParts, TaxCodes, DecimalsNumber);
    }

    static GetInsTaxGroupingInfoByHSN(FinalMatchedParts: any, TaxCodes: any, DecimalsNumber: number) {
        let HSNTaxInfo: any[] = [];
        FinalMatchedParts.forEach((MatchedPart: any) => {
            let TaxInfo: any = {};
            let TaxOnAmount: any = 0;
            let TaxAmount: any = 0;
            let CGSTAmt: any = 0;
            let SGSTAmt: any = 0;
            let IGSTAmt: any = 0;
            let HSN: any = MatchedPart[0].HSN;
            TaxInfo.CombinedTaxPercentage = MatchedPart[0].CombinedTaxPercentage;
            MatchedPart.forEach((argMatchedGSTPart: any) => {
                TaxOnAmount = Add(TaxOnAmount, TrUtils.FixedTo(argMatchedGSTPart.InsAfterPartDisc, DecimalsNumber));
                if (argMatchedGSTPart.PBy === PayTypeEnum.Insurance || argMatchedGSTPart.PBy === PayTypeEnum.Shared) {
                    if (argMatchedGSTPart.Sts !== LaborStatusEnum.New && argMatchedGSTPart.Sts !== LaborStatusEnum.WtngForAppr) {
                        CGSTAmt = Add(CGSTAmt, TrUtils.FixedTo(argMatchedGSTPart.ACGST, DecimalsNumber));
                        IGSTAmt = Add(IGSTAmt, TrUtils.FixedTo(argMatchedGSTPart.AIGST, DecimalsNumber));
                        SGSTAmt = Add(SGSTAmt, TrUtils.FixedTo(argMatchedGSTPart.ASGST, DecimalsNumber));
                    } else {
                        CGSTAmt = Add(CGSTAmt, TrUtils.FixedTo(argMatchedGSTPart.ECGST, DecimalsNumber));
                        IGSTAmt = Add(IGSTAmt, TrUtils.FixedTo(argMatchedGSTPart.EIGST, DecimalsNumber));
                        SGSTAmt = Add(SGSTAmt, TrUtils.FixedTo(argMatchedGSTPart.ESGST, DecimalsNumber));
                    }
                }
            });
            TaxAmount = Add(CGSTAmt, SGSTAmt, IGSTAmt);
            TaxInfo.HSN = HSN;
            TaxInfo.TotalTaxableAmount = TrUtils.FixPriceValue(TaxOnAmount, DecimalsNumber);
            TaxInfo.CGSTAmt = TrUtils.FixPriceValue(CGSTAmt, DecimalsNumber);
            TaxInfo.SGSTAmt = TrUtils.FixPriceValue(SGSTAmt, DecimalsNumber);
            TaxInfo.IGSTAmt = TrUtils.FixPriceValue(IGSTAmt, DecimalsNumber);
            TaxInfo.TotalTaxAmount = TrUtils.FixPriceValue(TaxAmount, DecimalsNumber);
            TaxInfo.PartsCount = MatchedPart.length;
            let GSTValues: any[] = this.GetGSTValueBasedOnTaxCode(MatchedPart[0], TaxCodes);
            TaxInfo.CGST = GSTValues[0];
            TaxInfo.SGST = GSTValues[1];
            TaxInfo.IGST = GSTValues[2];
            if (TaxOnAmount !== 0) {
                HSNTaxInfo.push(TaxInfo);
            }
        });
        return HSNTaxInfo;
    }

    static GetGSTValueBasedOnTaxCode(item: any, TaxCodes: any) {
        let CGST: number = 0;
        let SGST: number = 0;
        let IGST: number = 0;
        const taxGroupKeys: string[] = ['Taxes', 'CTaxes', 'ATaxes', 'ETaxes'];

        for (const taxGroupKey of taxGroupKeys) {
            const groupedTaxes = item?.[taxGroupKey];
            if (!Array.isArray(groupedTaxes) || groupedTaxes.length === 0) {
                continue;
            }

            CGST = groupedTaxes
                .filter((tax: any) => tax?.Code === 'CGST')
                .reduce((total: number, tax: any) => Add(total, tax?.Rate), 0);
            SGST = groupedTaxes
                .filter((tax: any) => tax?.Code === 'SGST')
                .reduce((total: number, tax: any) => Add(total, tax?.Rate), 0);
            IGST = groupedTaxes
                .filter((tax: any) => tax?.Code === 'IGST')
                .reduce((total: number, tax: any) => Add(total, tax?.Rate), 0);

            if (!TrUtils.IsZero(Add(CGST, SGST, IGST))) {
                return [CGST, SGST, IGST];
            }
        }

        const TCode = item?.TCode;
        if (TrUtils.IsNull(TCode)) {
            return [CGST, SGST, IGST];
        }
        let TCodeIndex: any = TaxCodes.findIndex((TaxCode: any) => {
            return TaxCode._id === Number(TCode);
        });
        if (TCodeIndex !== -1) {
            if (TaxCodes[TCodeIndex].Type === 'Intra') {
                return [TaxCodes[TCodeIndex].CGST, TaxCodes[TCodeIndex].SGST, 0];
            } else {
                return [0, 0, TaxCodes[TCodeIndex].IGST];
            }
        } else {
            return [CGST, SGST, IGST];
        }
    }

    static GetCombinedTaxPercentage(Parts: any, TaxCodes: any) {
        Parts.forEach((Part: any) => {
            let GSTValues: any[] = this.GetGSTValueBasedOnTaxCode(Part, TaxCodes);
            let CGST = GSTValues[0];
            let SGST = GSTValues[1];
            let IGST = GSTValues[2];

            Part.CombinedTaxPercentage = Add(CGST, SGST, IGST);
        });
        return Parts;
    }

    static ResetPartsHSNIfInvalid(Parts: any) {
        Parts.forEach((Part: any) => {
            if (TrUtils.IsNull(Part.HSN)) {
                Part.HSN = '';
            }
        });
        return Parts;
    }

    static ComparePartsByHSN(Parts: any, TaxCodes: any) {
        let FinalMatchedParts: any[] = [];
        Parts.forEach((Part: any) => {
            let MatchedPartsBasedOnHSN = Parts.filter((argPart: any) => {
                let PartFound: boolean = false;
                FinalMatchedParts.forEach((FinalArgParts: any) => {
                    let PartIndex: any = FinalArgParts.findIndex((FinalArgPart: any) => {
                        return FinalArgPart._id === argPart._id;
                    });
                    if (PartIndex !== -1) {
                        PartFound = true;
                    }
                });

                let argGSTValues: any[] = this.GetGSTValueBasedOnTaxCode(argPart, TaxCodes);
                let argCGST = argGSTValues[0];
                let argSGST = argGSTValues[1];
                let argIGST = argGSTValues[2];

                let partGSTValues: any[] = this.GetGSTValueBasedOnTaxCode(Part, TaxCodes);
                let partCGST = partGSTValues[0];
                let partSGST = partGSTValues[1];
                let partIGST = partGSTValues[2];

                return (argPart.HSN === Part.HSN) && (!PartFound) &&
                    (argCGST === partCGST) && (argIGST === partIGST) &&
                    (argSGST === partSGST);
            });
            if (MatchedPartsBasedOnHSN.length !== 0) {
                FinalMatchedParts.push(MatchedPartsBasedOnHSN);
            }
        });
        return FinalMatchedParts;
    }

}