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, Multiply, Subtract } from '../../shared/math-operations';
import { InvoiceTotalsService } from '../invoice/invoice-total.service';

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 = InvoiceTotalsService.GetTotalsValue(argInvoiceData.Services, argInvoiceData.Items, IsTaxable,
            true, null, '', null, '', argInvoiceData.Disc, argInvoiceData.Perc, TaxCodes, true, argInvoiceData.Settings, argInvoiceData.Adjust, true, InvoicePrintData.Entity);

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

        InvoicePrintData = TrUtils.ConcatObjects(InvoicePrintData, finalTotalsData);
        InvoicePrintData.Ops = this.GetLaborPrintInfo(InvoicePrintData.Ops, ConsolidateGST, TaxCodes, OriginalEntityData.Entity.Settings?.Acc?.LTot, InvoicePrintData.Entity.DecimalsNumber);
        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 GetLaborPrintInfo(LaborList: any, Consolidate: boolean, TaxCodes: any, LineTotal: string, DecimalsNumber: number) {
        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);
            } else {
                Labor.UnPr = 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 = this.GetTCodeFromTaxes(Labor);
            Labor.CGSTAmt = TrUtils.FixPriceValue(this.GetTaxAmountFromTaxes(Labor, 'CGST'), DecimalsNumber);
            Labor.SGSTAmt = TrUtils.FixPriceValue(this.GetTaxAmountFromTaxes(Labor, 'SGST'), DecimalsNumber);
            Labor.IGSTAmt = TrUtils.FixPriceValue(this.GetTaxAmountFromTaxes(Labor, 'IGST'), DecimalsNumber);
            Labor.QtyAndUoM = Labor.Qty.toString();
            Labor.CGSTPerc = this.GetTaxRateFromTaxes(Labor, 'CGST');
            Labor.SGSTPerc = this.GetTaxRateFromTaxes(Labor, 'SGST');
            Labor.IGSTPerc = this.GetTaxRateFromTaxes(Labor, 'IGST');
            Labor.TaxName = this.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;
    }

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

    static 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;
    }


    static 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;
    }

    static 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;
    }

    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(this.GetTaxAmountFromTaxes(Item, 'CGST'), Item.Qty);
                let STaxAmtPerItem = Divide(this.GetTaxAmountFromTaxes(Item, 'SGST'), Item.Qty);
                let ITaxAmtPerItem = Divide(this.GetTaxAmountFromTaxes(Item, 'IGST'), Item.Qty);
                Item.UnPr = TrUtils.FixedTo(Add(AfterDiscForEach, CTaxAmtPerItem, STaxAmtPerItem, ITaxAmtPerItem), DecimalsNumber);
            } else {
                Item.UnPr = TrUtils.FixPriceValue(Item.UnPr, DecimalsNumber);
            }
            Item.TCode = this.GetTCodeFromTaxes(Item);
            Item.CGSTAmt = TrUtils.FixPriceValue(this.GetTaxAmountFromTaxes(Item, 'CGST'), DecimalsNumber);
            Item.SGSTAmt = TrUtils.FixPriceValue(this.GetTaxAmountFromTaxes(Item, 'SGST'), DecimalsNumber);
            Item.IGSTAmt = TrUtils.FixPriceValue(this.GetTaxAmountFromTaxes(Item, 'IGST'), DecimalsNumber);
            Item.QtyAndUoM = Item.Qty.toString();
            Item.CGSTPerc = this.GetTaxRateFromTaxes(Item, 'CGST');
            Item.SGSTPerc = this.GetTaxRateFromTaxes(Item, 'SGST');
            Item.IGSTPerc = this.GetTaxRateFromTaxes(Item, 'IGST');
            Item.TaxName = this.getTaxName(Item.TCode, TaxCodes);
            // 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.Services = argInvoiceData.Services;
        argInvoiceData.Items = argInvoiceData.Items;
        return argInvoiceData;
    }

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

        let ROLaborParts: any = {};
        ROLaborParts.Services = InvoicePrintData.Services;
        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 = !TrUtils.IsNull(OriginalInvoiceData.BillTo) ? OriginalInvoiceData.BillTo.Name : OriginalInvoiceData.BFrom.Name;
            Customer.Adrs = [];
            Customer.Cons = [];
            if (!TrUtils.IsNull(OriginalInvoiceData.BillTo) && !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);
                }
            }
            if (!TrUtils.IsNull(OriginalInvoiceData.BFrom) && !TrUtils.IsNull(OriginalInvoiceData.BFrom.Adrs)) {
                Customer.Adrs.push(OriginalInvoiceData.BFrom.Adrs.A1);
                if (!TrUtils.IsEmpty(OriginalInvoiceData.BFrom.Adrs.A2)) {
                    Customer.Adrs.push(OriginalInvoiceData.BFrom.Adrs.A2);
                }
                if (!TrUtils.IsEmpty(OriginalInvoiceData.BFrom.Adrs.Ct)) {
                    Customer.Adrs.push(OriginalInvoiceData.BFrom.Adrs.Ct);
                }
            }
            Customer.GSTIN = !TrUtils.IsNull(OriginalInvoiceData.BillTo) ? OriginalInvoiceData.BillTo.GSTIN : OriginalInvoiceData.BFrom.GSTIN;

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

            if (!TrUtils.IsNull(OriginalInvoiceData.BFrom) && !TrUtils.IsEmpty(OriginalInvoiceData.BFrom.Ph)) {
                Customer.Cons = [
                    {
                        Type: 'M',
                        No: OriginalInvoiceData.BFrom.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;
    }

}