import { PrintSharedService } from '../../shared/shared-print.service';
import { DebitNoteTotalsService } from './debit-note-totals.service';
import { ROTypeEnum } from '../../enums/code-enums';
import { TrUtils } from '../../utils/tr-utils';
import { InvoiceStatusEnum, PayTypeEnum } from '../../enums/enums';
import { MyDate } from '../../utils/my-date';
import { Add, Divide, Subtract } from '../../shared/math-operations';

export class DebitNotePrintService {

    static GetDebitNotePrintInfo(OriginalInvoiceData: any, OriginalEntityData: any, image: any,
        IncludeGST: boolean, ConsolidateGST: boolean, TaxCodes: any, IsProforma: boolean, IsCustBillTo: boolean) {
        let InvoicePrintData: any = {};

        let argInvoiceData = TrUtils.Stringify(OriginalInvoiceData);

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

        InvoicePrintData.IsProforma = IsProforma;

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

        let SType: any = TrUtils.IsNull(argInvoiceData.SType) ? null : argInvoiceData.SType;

        InvoicePrintData = this.GetPrintConditionsBasedOnInput(InvoicePrintData, IncludeGST, ConsolidateGST,
            SType, argInvoiceData, IsProforma, IsCustBillTo);

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

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

        InvoicePrintData = this.GetInvoiceOtherDetailsForPrint(InvoicePrintData, argInvoiceData, IsCustBillTo);

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

        let finalTotalsData: any = DebitNoteTotalsService.GetTotalsValue(argInvoiceData.Items, IsTaxable,
            true, argInvoiceData.Disc, argInvoiceData.Perc, TaxCodes, true, argInvoiceData.Settings, InvoicePrintData.Entity);

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

        InvoicePrintData = TrUtils.ConcatObjects(InvoicePrintData, finalTotalsData);

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

        argInvoiceData = this.ReverseItemsForInvoicePrint(argInvoiceData);

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

        InvoicePrintData = this.GetFormattedProductDataForPrint(argInvoiceData, InvoicePrintData);

        InvoicePrintData = this.GetBillNameForInvoicePrint(argInvoiceData, InvoicePrintData, IsCustBillTo);
        if(TrUtils.IsNull(argInvoiceData.Payments)){
            argInvoiceData.Payments=[];
        }

        let PaymentData = this.GetPaymentsTotal(argInvoiceData.Payments, InvoicePrintData.Total, argInvoiceData.Sts, InvoicePrintData.Entity?.DecimalsNumber);
        InvoicePrintData.Due = PaymentData.Due;
        InvoicePrintData.Paid = PaymentData.Paid;
        if (!TrUtils.IsNull(PaymentData.Sts)) {
            InvoicePrintData.Sts = PaymentData.Sts;
        }
        InvoicePrintData.Consolidate = ConsolidateGST;
        if (!ConsolidateGST) {
            InvoicePrintData.ShowDiscountColumn = (InvoicePrintData.Settings.DiscLvl === 'ITM' || InvoicePrintData.Settings.DiscLvl === 'RECITM') ? true : false;
        }
        return InvoicePrintData;
    }

    static GetPrintConditionsBasedOnInput(InvoicePrintData: any, IncludeGST: boolean, ConsolidateGST: boolean,
        SType: any, OriginalInvoiceData: any, IsProforma: boolean, IsBillTo: boolean) {
        InvoicePrintData.For = PayTypeEnum.Customer;
        InvoicePrintData.IncludeGST = IncludeGST;
        InvoicePrintData.ConsolidateGST = ConsolidateGST;

        InvoicePrintData.ShowAccParts = false;

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

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

        InvoicePrintData = this.GetInvoiceTypeHeading(InvoicePrintData, OriginalInvoiceData, IncludeGST, ConsolidateGST, IsProforma, IsBillTo);

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

        return InvoicePrintData;
    }

    static GetInvoiceTypeHeading(InvoicePrintData: any, OriginalInvoiceData: any, IncludeGST: boolean,
        ConsolidateGST: boolean, IsProforma: boolean, IsBillTo: boolean) {
        if (IsProforma) {
            InvoicePrintData.HeaderName = 'pro-forma Invoice';
        } else {
            if (IsBillTo) {
                InvoicePrintData.HeaderName = 'Debit Note';
            } else {
                InvoicePrintData.HeaderName = 'Vendor Credit Note';
            }

        }
        return InvoicePrintData;
    }

    static GetInvoiceOtherDetailsForPrint(InvoicePrintData: any, OriginalInvoiceData: any, IsCustBillTo: boolean) {
        if (IsCustBillTo) {
            InvoicePrintData.Type = 'Debit Notes';
            InvoicePrintData._id = OriginalInvoiceData.Code;
        } else {
            InvoicePrintData.Type = 'Credit Notes';
            InvoicePrintData._id = OriginalInvoiceData.BNo;
        }
        InvoicePrintData.Sts = OriginalInvoiceData.Sts;
        InvoicePrintData.CrDate = MyDate.ConvertUTCDateToReadable(OriginalInvoiceData.CrDate);
        return InvoicePrintData;
    }

    static 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(Item.CGST , Item.Qty);
                let STaxAmtPerItem = Divide(Item.SGST , Item.Qty);
                let ITaxAmtPerItem = Divide(Item.IGST , Item.Qty);
                Item.UnPr = TrUtils.FixedTo(Add(AfterDiscForEach , CTaxAmtPerItem , STaxAmtPerItem , ITaxAmtPerItem), DecimalsNumber);
            }else{
                Item.UnPr = TrUtils.FixPriceValue(Item.UnPr, DecimalsNumber);
            }
            Item.CGSTAmt = TrUtils.FixPriceValue(Item.CGST, DecimalsNumber);
            Item.SGSTAmt = TrUtils.FixPriceValue(Item.SGST, DecimalsNumber);
            Item.IGSTAmt = TrUtils.FixPriceValue(Item.IGST, DecimalsNumber);
            Item.CGSTPerc = PrintSharedService.GetCGSTValueBasedOnTaxCode(Item.TCode, TaxCodes);
            Item.SGSTPerc = PrintSharedService.GetSGSTValueBasedOnTaxCode(Item.TCode, TaxCodes);
            Item.IGSTPerc = PrintSharedService.GetIGSTValueBasedOnTaxCode(Item.TCode, TaxCodes);
            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;
            }
        });
        return Items;
    }

    static ReverseItemsForInvoicePrint(argInvoiceData: any) {
        argInvoiceData.Items = argInvoiceData.Items.reverse();
        return argInvoiceData;
    }

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

        let ROLaborParts: any = {};

        ROLaborParts.Items = InvoicePrintData.Items;

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

        PrintInfo.push(ROLaborParts);
        return PrintInfo;
    }

    static GetFormattedProductDataForPrint(OriginalInvoiceData: any, InvoicePrintData: any) {
        if (!TrUtils.IsNull(OriginalInvoiceData.Prod)) {
            InvoicePrintData.Product = OriginalInvoiceData.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 = OriginalInvoiceData.Prod.MIn;
            InvoicePrintData.MOut = OriginalInvoiceData.Prod.MOut;
        }
        return InvoicePrintData;
    }

    static GetBillNameForInvoicePrint(OriginalInvoiceData: any, InvoicePrintData: any, IsBillTo: boolean) {
        let Customer: any = {};
        if (IsBillTo) {
            Customer.Name = OriginalInvoiceData.BillTo.Name;
            Customer.Adrs = [];
            Customer.Cons = [];
            if (!TrUtils.IsNull(OriginalInvoiceData.BillTo.Adrs)) {
                Customer.Adrs.push(OriginalInvoiceData.BillTo.Adrs.A1);
                if (!TrUtils.IsEmpty(OriginalInvoiceData.BillTo.Adrs.A2)) {
                    Customer.Adrs.push(OriginalInvoiceData.BillTo.Adrs.A2);
                }
                if (!TrUtils.IsEmpty(OriginalInvoiceData.BillTo.Adrs.Ct)) {
                    Customer.Adrs.push(OriginalInvoiceData.BillTo.Adrs.Ct);
                }
            }
            Customer.GSTIN = OriginalInvoiceData.BillTo.GSTIN;

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

        } else {
            Customer.Name = OriginalInvoiceData.BFrom.Name;
        }
        InvoicePrintData.Customer = Customer;
        return InvoicePrintData;
    }

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

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

    static GetPaymentsTotal(InvoicePayments: any, Total: number, InvoiceStatus: string, DecimalsNumber: number) {
        var i = 0;
        let Data: any = {};
        let PaidTotal: any = 0;
        for (i = 0; i < InvoicePayments.length; i++) {
            PaidTotal += InvoicePayments[i].Paid;
        }
        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;
    }

}