import { ROTypeEnum } from '../../enums/code-enums';
import { InvoiceStatusEnum, PayTypeEnum } from '../../enums/enums';
import { Add, Divide, Multiply, Subtract } from '../../shared/math-operations';
import { PrintSharedService } from '../../shared/shared-print.service';
import { MyDate } from '../../utils/my-date';
import { TrUtils } from '../../utils/tr-utils';
import { InvoiceTotalsService } from './invoice-total.service';

export function GetInvoicePrintInfo(OriginalInvoiceData: any, OriginalEntityData: any, image: any,
    IncludeGST: boolean, ConsolidateGST: boolean, TaxCodes: any, IsProforma: boolean, PartsPrint: boolean, LaborPrint: boolean) {

    let ForInsurance: boolean = !TrUtils.IsNull(OriginalInvoiceData.BillTo) && !TrUtils.IsNull(OriginalInvoiceData.BillTo.Ins_Id);

    let InvoicePrintData: any = {};

    let argInvoiceData = TrUtils.Stringify(OriginalInvoiceData);

    if (!IncludeGST) {
        if (argInvoiceData.Settings.Tax === 'TI') {
            argInvoiceData.Settings.Tax = 'NO';
        }
    }

    InvoicePrintData.IsProforma = IsProforma;

    InvoicePrintData.Settings = TrUtils.Stringify(argInvoiceData.Settings);
    InvoicePrintData.SType = TrUtils.Stringify(argInvoiceData.SType);

    let SType: any

    if (!TrUtils.IsNull(argInvoiceData.SType)) {
        SType = argInvoiceData.SType
    }

    InvoicePrintData = GetPrintConditionsBasedOnInput(InvoicePrintData, IncludeGST, ConsolidateGST, ForInsurance,
        SType, argInvoiceData, IsProforma, PartsPrint, LaborPrint);

    InvoicePrintData.Entity = PrintSharedService.GetFormattedEntityDataForPrint(OriginalEntityData, "Invoice", OriginalInvoiceData);

    InvoicePrintData = PrintSharedService.GetEntityHeaderStyles(InvoicePrintData, OriginalEntityData, image);

    InvoicePrintData = GetInvoiceOtherDetailsForPrint(InvoicePrintData, argInvoiceData);

    let IsTaxable: boolean = (IncludeGST && TrUtils.isTaxable(argInvoiceData.Settings.Tax)) ? true : false;

    let finalTotalsData: any = InvoiceTotalsService.GetTotalsValue(argInvoiceData.Ops, argInvoiceData.Items, IsTaxable,
        true, argInvoiceData.LDisc, argInvoiceData.LPerc, argInvoiceData.PDisc, argInvoiceData.PPerc,
        argInvoiceData.Disc, argInvoiceData.Perc, TaxCodes, true, argInvoiceData.Settings, argInvoiceData.Adjust, InvoicePrintData.Entity.Round, InvoicePrintData.Entity);

    if (ConsolidateGST) {
        finalTotalsData.CustLaborTotalBeforeDisc = finalTotalsData.CustLaborAfterTax;
        finalTotalsData.CustPartsTotalBeforeDisc = finalTotalsData.CustPartAfterTax;
    }

    InvoicePrintData = TrUtils.ConcatObjects(InvoicePrintData, finalTotalsData);

    InvoicePrintData.Ops = GetLaborPrintInfo(InvoicePrintData.Ops, ConsolidateGST, TaxCodes, OriginalEntityData.Entity.Settings?.Acc?.LTot, InvoicePrintData.Entity.DecimalsNumber);

    InvoicePrintData.Items = GetItemsPrintInfo(InvoicePrintData.Items, ConsolidateGST, TaxCodes, OriginalEntityData.Entity.Settings?.Acc?.LTot, InvoicePrintData.Entity.DecimalsNumber);

    argInvoiceData = ReverseItemsForInvoicePrint(argInvoiceData);

    InvoicePrintData.PrintInfo = PrepareFormatForInvoicePrint(InvoicePrintData, ROTypeEnum.Invoice, argInvoiceData.Sts);

    InvoicePrintData = GetFormattedProductDataForPrint(argInvoiceData, InvoicePrintData);

    InvoicePrintData = GetBillNameForInvoicePrint(argInvoiceData, InvoicePrintData);

    let PaymentData = GetPaymentsTotal(argInvoiceData.Credits, argInvoiceData.Payments, argInvoiceData.Total, argInvoiceData.Sts, InvoicePrintData.Entity.DecimalsNumber);
    // if (argInvoiceData.Settings.DiscLvl !== 'REC') {
    //     InvoicePrintData.FixedDisc = null;
    // }
    InvoicePrintData.Due = PaymentData.Due;
    InvoicePrintData.Paid = argInvoiceData.Receipt ? argInvoiceData.Total : PaymentData.Paid;
    if (!TrUtils.IsNull(PaymentData.Sts)) {
        InvoicePrintData.Sts = PaymentData.Sts;
    }
    InvoicePrintData.Consolidate = ConsolidateGST;
    InvoicePrintData.ShowDiscountColumn = false;
    if (!ForInsurance && !ConsolidateGST) {
        if (PrintSharedService.CheckItemIndexWithDisc(InvoicePrintData) !== -1) {
            // InvoicePrintData.ShowDiscountColumn = (InvoicePrintData.Settings.DiscLvl === 'ITM' || InvoicePrintData.Settings.DiscLvl === 'RECITM') ? true : false;
            InvoicePrintData.ShowDiscountColumn = true;
        }
    }
    if (OriginalInvoiceData.Type === '1') {
        InvoicePrintData.From = 'Sales';
    }

    if (OriginalInvoiceData.isCountersale) {
        InvoicePrintData.From = 'Countersale';
    }

    if (TrUtils.IsNull(OriginalInvoiceData.BL)) {
        OriginalInvoiceData.BL = {};
    }

    InvoicePrintData.BL = TrUtils.Stringify(OriginalInvoiceData.BL);
    OriginalInvoiceData.BL.RefNo = OriginalInvoiceData.RefNo;
    // console.log('InvoicePrintData', InvoicePrintData);

    return InvoicePrintData;
}

export function GetPrintConditionsBasedOnInput(InvoicePrintData: any, IncludeGST: boolean, ConsolidateGST: boolean,
    ForInsurance: boolean, SType: any, OriginalInvoiceData: any, IsProforma: boolean, PartsPrint: boolean, LaborPrint: boolean) {

    InvoicePrintData.ForInsurance = ForInsurance;
    InvoicePrintData.For = ForInsurance ? PayTypeEnum.Insurance : PayTypeEnum.Customer;
    InvoicePrintData.IncludeGST = IncludeGST;
    InvoicePrintData.ConsolidateGST = ConsolidateGST;

    InvoicePrintData.ShowAccParts = true;

    InvoicePrintData.ShowIGST = (TrUtils.IsNull(SType) || (SType === 'Intra')) ? false : true;

    InvoicePrintData.ShowTaxColumn = (IncludeGST && !ConsolidateGST) ? true : false;
    // InvoicePrintData.ShowDiscountColumn = (!ForInsurance && !ConsolidateGST) ? true : false;

    InvoicePrintData = GetInvoiceTypeHeading(InvoicePrintData, OriginalInvoiceData, IncludeGST, ConsolidateGST, IsProforma, PartsPrint, LaborPrint);

    InvoicePrintData.PrDate = TrUtils.IsNull(OriginalInvoiceData.PrDate) ? '' : MyDate.ConvertUTCDateToReadable(OriginalInvoiceData.PrDate);

    return InvoicePrintData;
}

export function GetInvoiceTypeHeading(InvoicePrintData: any, OriginalInvoiceData: any, IncludeGST: boolean,
    ConsolidateGST: boolean, IsProforma: boolean, PartsPrint: boolean, LaborPrint: boolean) {
    // console.log(IsProforma,PartsPrint,LaborPrint);
    if (OriginalInvoiceData.CheckParts) {
        InvoicePrintData.HeaderName = "Spares Issue";
    } else if (OriginalInvoiceData.isCountersale) {
        InvoicePrintData.HeaderName = 'Counter Sale Invoice';
    } else if (IsProforma) {
        // InvoicePrintData.HeaderName = 'PRO-FORMA INVOICE';
        if (PartsPrint && !LaborPrint) {
            InvoicePrintData.HeaderName = 'PRO-FORMA INVOICE (PARTS)';
        } else if (LaborPrint && !PartsPrint) {
            InvoicePrintData.HeaderName = 'PRO-FORMA INVOICE (LABOR)';
        } else {
            InvoicePrintData.HeaderName = 'PRO-FORMA INVOICE';
        }
    } else {
        if (OriginalInvoiceData.Type === 'Sales') {
            // if (IncludeGST && !ConsolidateGST) {
            //     InvoicePrintData.HeaderName = 'Parts Tax Invoice';
            // } else {
            //     InvoicePrintData.HeaderName = 'Parts Invoice';
            // }
            InvoicePrintData.PrintType = 'PARTS ORDER';
            if (InvoicePrintData.Settings.Tax === 'BS' || ConsolidateGST) {
                InvoicePrintData.HeaderName = 'BILL OF SUPPLY';
            } else {
                if (InvoicePrintData.Settings.Tax === 'TI') {
                    InvoicePrintData.HeaderName = 'PARTS TAX INVOICE';
                } else {
                    InvoicePrintData.HeaderName = 'PARTS INVOICE';
                }
            }
        } else {
            // if (IncludeGST && !ConsolidateGST) {
            //     InvoicePrintData.HeaderName = 'Tax Invoice';
            // } else {
            //     InvoicePrintData.HeaderName = 'Invoice';
            // }

            if (InvoicePrintData.Settings.Tax === 'BS') {
                // InvoicePrintData.HeaderName = 'BILL OF SUPPLY';
                if (PartsPrint && !LaborPrint) {
                    InvoicePrintData.HeaderName = 'BILL OF SUPPLY (PARTS)';
                } else if (LaborPrint && !PartsPrint) {
                    InvoicePrintData.HeaderName = 'BILL OF SUPPLY (LABOR)';
                } else {
                    InvoicePrintData.HeaderName = 'BILL OF SUPPLY';
                }
            } else {
                if (InvoicePrintData.Settings.Tax === 'TI') {
                    if (OriginalInvoiceData.Receipt) {
                        InvoicePrintData.HeaderName = 'TAX SALES RECEIPT';
                    } else {
                        if (PartsPrint && !LaborPrint) {
                            InvoicePrintData.HeaderName = 'TAX INVOICE (PARTS)';
                        } else if (LaborPrint && !PartsPrint) {
                            InvoicePrintData.HeaderName = 'TAX INVOICE (LABOR)';
                        } else {
                            InvoicePrintData.HeaderName = 'TAX INVOICE';
                        }

                    }

                } else {
                    if (OriginalInvoiceData.Receipt) {
                        InvoicePrintData.HeaderName = 'SALES RECEIPT';

                    } else {
                        // InvoicePrintData.HeaderName = 'INVOICE';
                        if (PartsPrint && !LaborPrint) {
                            InvoicePrintData.HeaderName = 'INVOICE (PARTS)';
                        } else if (LaborPrint && !PartsPrint) {
                            InvoicePrintData.HeaderName = 'INVOICE (LABOR)';
                        } else {
                            InvoicePrintData.HeaderName = 'INVOICE';
                        }
                    }
                }
            }
        }
    }
    return InvoicePrintData;
}

export function GetInvoiceOtherDetailsForPrint(InvoicePrintData: any, argInvoiceData: any) {
    InvoicePrintData.Type = argInvoiceData.isCountersale ? 'SalesReceipt' : argInvoiceData.CheckParts ? 'Work Order' : 'Invoice';
    InvoicePrintData._id = argInvoiceData.Code;
    InvoicePrintData.ROCode = argInvoiceData.OrdCode;
    InvoicePrintData.ROCode = argInvoiceData.OrdCode;
    InvoicePrintData.TypeName = argInvoiceData.TypeName;
    InvoicePrintData.Sts = argInvoiceData.Sts;
    InvoicePrintData.AdmNo = argInvoiceData.AdmNo;
    InvoicePrintData.CrDate = MyDate.ConvertUTCDateToReadable(argInvoiceData.CrDate);
    return InvoicePrintData;
}

export function GetTaxAmountFromTaxes(item: any, taxCode: string) {
    const taxes = Array.isArray(item?.Taxes) ? item.Taxes : [];
    const matchedTaxes = taxes.filter((tax: any) => tax?.Code === taxCode);
    if (matchedTaxes.length !== 0) {
        return matchedTaxes.reduce((total: number, tax: any) => Add(total, tax?.Amt), 0);
    }
    return 0;
}

export function GetTaxRateFromTaxes(item: any, taxCode: string) {
    const taxes = Array.isArray(item?.Taxes) ? item.Taxes : [];
    const matchedTaxes = taxes.filter((tax: any) => tax?.Code === taxCode);
    if (matchedTaxes.length !== 0) {
        return matchedTaxes.reduce((total: number, tax: any) => Add(total, tax?.Rate), 0);
    }
    return 0;
}

export function GetTCodeFromTaxes(item: any) {
    const taxes = Array.isArray(item?.Taxes) ? item.Taxes : [];
    const matchedTax = taxes.find((tax: any) => !TrUtils.IsNull(tax?.TaxCodeId));
    if (!TrUtils.IsNull(matchedTax?.TaxCodeId)) {
        return matchedTax.TaxCodeId;
    }
    return item?.TCode;
}

export function GetLaborPrintInfo(LaborList: any, Consolidate: boolean, TaxCodes: any, LineTotal: string, DecimalsNumber: number) {
    console.log('LaborList', LaborList);
    LaborList.forEach((Labor: any) => {
        Labor.HSN = Labor.SAC;
        if (TrUtils.IsNull(Labor.Qty)) {
            Labor.Qty = 1;
        }
        if (Consolidate) {
            Labor.UnPr = TrUtils.FixedTo(Labor.AfterLaborTax, DecimalsNumber);
            Labor.Pr = TrUtils.FixedTo(Labor.AfterLaborTax, DecimalsNumber);
        } else {
            Labor.UnPr = TrUtils.FixPriceValue(Labor.Pr, DecimalsNumber);
            Labor.Pr = TrUtils.FixPriceValue(Labor.Pr, DecimalsNumber);
        }
        if (!TrUtils.IsEmpty(Labor.Perc)) {
            Labor.DiscPerc = Labor.Perc;
        } else {
            Labor.DiscPerc = Labor.Perc;
            if (!TrUtils.IsZero(Number(Labor.UnPr))) {
                Labor.DiscPerc = Divide(Multiply(100, Labor.Disc), Labor.UnPr);
            } else {
                Labor.DiscPerc = 0;
            }
        }
        Labor.TCode = GetTCodeFromTaxes(Labor);
        Labor.CGSTAmt = TrUtils.FixPriceValue(GetTaxAmountFromTaxes(Labor, 'CGST'), DecimalsNumber);
        Labor.SGSTAmt = TrUtils.FixPriceValue(GetTaxAmountFromTaxes(Labor, 'SGST'), DecimalsNumber);
        Labor.IGSTAmt = TrUtils.FixPriceValue(GetTaxAmountFromTaxes(Labor, 'IGST'), DecimalsNumber);
        Labor.QtyAndUoM = Labor.Qty.toString();
        Labor.CGSTPerc = GetTaxRateFromTaxes(Labor, 'CGST');
        Labor.SGSTPerc = GetTaxRateFromTaxes(Labor, 'SGST');
        Labor.IGSTPerc = GetTaxRateFromTaxes(Labor, 'IGST');
        Labor.TaxName = getTaxName(Labor.TCode, TaxCodes);
        if (LineTotal === 'AT') {
            Labor.LineTotal = TrUtils.FixPriceValue(Labor.AfterLaborTax, DecimalsNumber);
        } else {
            Labor.LineTotal = TrUtils.FixPriceValue(Subtract(Labor.Amt, Labor.Disc), DecimalsNumber);
        }
    });
    return LaborList;
}

export function GetItemsPrintInfo(Items: any, Consolidate: boolean, TaxCodes: any, LineTotal: string, DecimalsNumber: number) {
    Items.forEach((Item: any) => {
        if (Consolidate) {
            let AfterDiscForEach = Divide(Item.AfterPartDisc, Item.Qty);
            let CTaxAmtPerItem = Divide(GetTaxAmountFromTaxes(Item, 'CGST'), Item.Qty);
            let STaxAmtPerItem = Divide(GetTaxAmountFromTaxes(Item, 'SGST'), Item.Qty);
            let ITaxAmtPerItem = Divide(GetTaxAmountFromTaxes(Item, 'IGST'), Item.Qty);
            Item.UnPr = TrUtils.FixedTo(Add(AfterDiscForEach, CTaxAmtPerItem, STaxAmtPerItem, ITaxAmtPerItem), DecimalsNumber);
        } else {
            Item.UnPr = TrUtils.FixPriceValue(Item.UnPr, DecimalsNumber);
        }

        // let Index = Item['Desc'].indexOf('#{');
        // if (Index !== -1) {
        //     Item.Desc1 = Item['Desc'].substring(Item['Desc'].indexOf('#{') + 2,
        //         Item['Desc'].lastIndexOf('}#'));
        // }
        // Item.Desc = Item['Desc'].split(' #{')[0];
        Item.MRP = TrUtils.FixPriceValue(Item.MRP, DecimalsNumber);
        Item.TCode = GetTCodeFromTaxes(Item);
        Item.CGSTAmt = TrUtils.FixPriceValue(GetTaxAmountFromTaxes(Item, 'CGST'), DecimalsNumber);
        Item.SGSTAmt = TrUtils.FixPriceValue(GetTaxAmountFromTaxes(Item, 'SGST'), DecimalsNumber);
        Item.IGSTAmt = TrUtils.FixPriceValue(GetTaxAmountFromTaxes(Item, 'IGST'), DecimalsNumber);
        Item.TaxName = getTaxName(Item.TCode, TaxCodes);
        if (!TrUtils.IsEmpty(Item.Perc)) {
            Item.DiscPerc = Item.Perc;
        } else {
            Item.DiscPerc = Item.Perc;
            if (!TrUtils.IsZero(Number(Item.UnPr))) {
                Item.DiscPerc = Divide(Multiply(100, Item.Disc), Item.UnPr);
            } else {
                Item.DiscPerc = 0;
            }
        }
        Item.CGSTPerc = GetTaxRateFromTaxes(Item, 'CGST');
        Item.SGSTPerc = GetTaxRateFromTaxes(Item, 'SGST');
        Item.IGSTPerc = GetTaxRateFromTaxes(Item, 'IGST');
        if (LineTotal === 'AT') {
            Item.LineTotal = TrUtils.FixPriceValue(Item.AfterPartTax, DecimalsNumber);
        } else {
            Item.LineTotal = TrUtils.FixPriceValue(Subtract(Item.UnAmt, Item.Disc), DecimalsNumber);
        }
        if (!TrUtils.IsZero(Item.Qty) && !TrUtils.CheckInvalidSelect(Item.UoM)) {
            Item.QtyAndUoM = Item.Qty + ' ' + Item.UoM;
        } else {
            Item.QtyAndUoM = Item.Qty + '';
        }
        if (!TrUtils.IsZero(Item.OfQty) && !TrUtils.CheckInvalidSelect(Item.UoM)) {
            Item.OfQtyAndUoM = Item.OfQty + ' ' + Item.UoM;
        } else {
            Item.OfQtyAndUoM = Item.OfQty + '';
        }
    });
    return Items;
}

export function getTaxName(TCode: any, TaxCodes: any) {
    let Index: any = TaxCodes.findIndex((TaxCode: any) => {
        return Number(TCode) === TaxCode._id;
    });
    return (Index !== -1) ? TaxCodes[Index].Name : '';
}

export function ReverseItemsForInvoicePrint(argInvoiceData: any) {
    argInvoiceData.Ops = argInvoiceData.Ops;
    argInvoiceData.Items = argInvoiceData.Items;
    return argInvoiceData;
}

export function PrepareFormatForInvoicePrint(InvoicePrintData: any, ROType: any, InvoiceStatus: any) {
    let PrintInfo: any[] = [];

    let ROLaborParts: any = {};

    ROLaborParts.Ops = InvoicePrintData.Ops;

    ROLaborParts.Items = InvoicePrintData.Items;

    ROLaborParts.Sts = InvoiceStatus;
    ROLaborParts.Type = ROType;

    PrintInfo.push(ROLaborParts);
    return PrintInfo;
}

export function GetFormattedProductDataForPrint(argInvoiceData: any, InvoicePrintData: any) {
    if (!TrUtils.IsNull(argInvoiceData.Prod)) {
        InvoicePrintData.Product = argInvoiceData.Prod;
        if (TrUtils.IsNull(InvoicePrintData.Product.VIN)) {
            InvoicePrintData.Product.VIN = '';
        }
        if (TrUtils.IsNull(InvoicePrintData.Product.RegNo)) {
            InvoicePrintData.Product.RegNo = '';
        }
        if (TrUtils.IsNull(InvoicePrintData.Product.EngNo)) {
            InvoicePrintData.Product.EngNo = '';
        }
        InvoicePrintData.MIn = argInvoiceData.Prod.MIn;
        InvoicePrintData.MOut = argInvoiceData.Prod.MOut;
    }
    return InvoicePrintData;
}

export function GetBillNameForInvoicePrint(argInvoiceData: any, InvoicePrintData: any) {
    let Customer: any = {};
    if (!TrUtils.IsNull(argInvoiceData.BillTo)) {
        Customer.Name = argInvoiceData.BillTo.Name;
        if (!TrUtils.IsNull(argInvoiceData.BillTo.Sltn)) {
            Customer.Name = argInvoiceData.BillTo.Sltn + ' ' + Customer.Name;
        }
        Customer.Code = argInvoiceData.Cust?.Code;
        Customer.Adrs = [];
        Customer.Cons = [];
        if (!TrUtils.IsNull(argInvoiceData.BillTo.Adrs)) {
            Customer.Adrs.push(argInvoiceData.BillTo.Adrs.A1);
            if (!TrUtils.IsEmpty(argInvoiceData.BillTo.Adrs.A2)) {
                Customer.Adrs.push(argInvoiceData.BillTo.Adrs.A2);
            }
            if (!TrUtils.IsEmpty(argInvoiceData.BillTo.Adrs.Ct)) {
                let city: any = argInvoiceData.BillTo.Adrs.Ct;
                if (!TrUtils.IsEmpty(argInvoiceData.BillTo.Adrs.Pin)) {
                    city = city + ', ' + argInvoiceData.BillTo.Adrs.StCode + '-' + argInvoiceData.BillTo.Adrs.Pin;
                }
                Customer.Adrs.push(city);
            }
        }
        Customer.TaxId = argInvoiceData.BillTo.TaxId;
        Customer.GSTIN = argInvoiceData.BillTo.TaxId?.Value;
        if (!TrUtils.IsNull(argInvoiceData.BillTo.DLNo)) {
            Customer.DLNo = argInvoiceData.BillTo.DLNo;
        }

        if (!TrUtils.IsEmpty(argInvoiceData.BillTo.Ph)) {
            Customer.Cons = [
                {
                    Type: 'M',
                    No: argInvoiceData.BillTo.Ph
                }
            ];
        }
        InvoicePrintData.Customer = Customer;
        InvoicePrintData.Name = argInvoiceData.Name;

        if (!TrUtils.IsNull(argInvoiceData.BillTo.Ins_Id)) {
            InvoicePrintData.Cust = GetCustomerDetails(argInvoiceData);
        }
    } else if (!TrUtils.IsNull(argInvoiceData.Cust)) {
        Customer.Name = argInvoiceData.Cust.Name;
        Customer.Code = argInvoiceData.Cust.Code;
        Customer.Adrs = [];
        Customer.Cons = [];
        InvoicePrintData.Customer = Customer;
    }


    if (!TrUtils.IsNull(argInvoiceData.ShipTo)) {
        let location: any = {};
        location.Adrs = PrintSharedService.GetAddress(argInvoiceData.ShipTo.Adrs);
        let Name: any;
        if (TrUtils.IsNull(argInvoiceData.ShipTo.Name)) {
            Name = argInvoiceData.ShipTo.ConName;
        } else {
            Name = argInvoiceData.ShipTo.Name;
        }
        if (TrUtils.IsNull(Name)) {
            Name = '';
        }
        location.Name = Name;
        if (!TrUtils.IsNull(argInvoiceData.ShipTo.ConPh)) {
            location.Cons = [
                {
                    Type: 'M',
                    No: argInvoiceData.ShipTo.ConPh
                }
            ];
        }

        InvoicePrintData.Location = location;
    }
    return InvoicePrintData;
}

export function GetCustomerDetails(argInvoiceData: any) {
    let Customer: any = {};
    Customer.Name = GetBillToName(argInvoiceData.Cust.Title, argInvoiceData.Cust.Name);
    Customer.Cons = [];
    if (!TrUtils.IsEmpty(argInvoiceData.Cust.Ph)) {
        Customer.Cons = [
            {
                Type: 'M',
                No: argInvoiceData.Cust.Ph
            }
        ];
    }
    Customer.GSTIN = argInvoiceData.Cust.GSTIN;
    Customer.Adrs = [];
    if (!TrUtils.IsNull(argInvoiceData.Cust.Adrs)) {
        Customer.Adrs.push(argInvoiceData.Cust.Adrs.A1);
        if (!TrUtils.IsEmpty(argInvoiceData.Cust.Adrs.A2)) {
            Customer.Adrs.push(argInvoiceData.Cust.Adrs.A2);
        }
        Customer.Adrs.push(argInvoiceData.Cust.Adrs.Ct);
    }
    Customer.ConName = argInvoiceData.Cust.ConName;
    Customer.ConPh = argInvoiceData.Cust.ConPhone;
    return Customer;
}

export function GetBillToName(Title: any, Name: string) {
    return TrUtils.IsEmpty(Title) ? Name : Title + ' ' + Name;
}

export function GetPaymentsTotal(Credits: any, InvoicePayments: any, Total: number, InvoiceStatus: string, DecimalsNumber: number) {
    var i = 0;
    let Data: any = {};
    let PaidTotal: any = 0;
    if (TrUtils.IsNull(InvoicePayments)) {
        InvoicePayments = [];
    }
    if (TrUtils.IsNull(Credits)) {
        Credits = [];
    }
    for (i = 0; i < InvoicePayments.length; i++) {
        PaidTotal += InvoicePayments[i].Paid;
    }
    for (i = 0; i < Credits.length; i++) {
        PaidTotal += Credits[i].Amt;
    }
    if (InvoiceStatus === InvoiceStatusEnum.Closed) {
        Data.Due = 0;
    } else {
        Data.Due = TrUtils.FixedTo(Subtract(Total, PaidTotal), DecimalsNumber);
    }
    if (Data.Due < 0) {
        Data.Due = 0;
    }
    if (Data.Due === 0) {
        Data.Sts = InvoiceStatusEnum.Closed;
    }
    Data.Paid = TrUtils.FixedTo(PaidTotal, DecimalsNumber);
    return Data;
}