import { SharedPDFService } from '../../shared/shared-pdf.service';
import { PrintSharedService } from '../../shared/shared-print.service';
import { TrUtils } from '../../utils/tr-utils';

export class PurchaseOrderPDFService {
    static SmallFont: number = 6;
    static MediumFont: number = 8;
    static LargeFont: number = 9;
    dd: any;
    static PurchaseOrder(ROPrintData: any, moreDiscDetails:boolean) {
        let dd = {
            info: {
                title: this.GetFileName(ROPrintData),
            },
            background: function (currentPage: any, pageSize: any) {
                return SharedPDFService.GetWatermarkImage(ROPrintData.Image, pageSize, ROPrintData.Entity.Wmark);
            },
            header: function (currentPage: any, pageCount: any) {
                return { text: currentPage.toString() + ' of ' + pageCount, alignment: 'right', marginRight: 7, fontSize: 8, marginTop: 2 };
            },
            pageMargins: [10, 15, 10, 15],
            content: [
                // SharedPDFService.MainHeading(ROPrintData.Entity.CName, ROPrintData.Entity.Header, ROPrintData.Image, ROPrintData.HColor, null),
                SharedPDFService.GetMainHeader(ROPrintData.Entity, ROPrintData.Image, ROPrintData.AColor, ROPrintData.HColor, null),
                SharedPDFService.GetPrintType(ROPrintData.HeaderName),
                SharedPDFService.HeaderAfterLine(),
                this.GetVendorDetails(ROPrintData),
                this.VendorDetailsAfterLine(),
                this.GetDisplayTable(),
                this.getPartsData(ROPrintData),
                SharedPDFService.GetUnderLine(),
                this.GetPOTotalDetails(ROPrintData, moreDiscDetails),
                SharedPDFService.GetTemsAndConditions(ROPrintData.Entity.Terms),
                SharedPDFService.GetUnderLine(),
                this.GetSignatures(ROPrintData.Entity.CName),
            ],
            styles: this.GetStyles()
        };
        return dd;

    }

    static GetFileName(ROPrintData: any) {
        let fileName: string = ROPrintData.HeaderName;
        return fileName;
    }

    static GetDisplayTable() {
        return { text: '', fontSize: 10, bold: true, margin: [0, 0, 0, 5] };
    }

    static GetStyles() {
        return {
            temp2header: {
                fontSize: 23,
                bold: true,
                alignment: 'left',
                // margin: [0, 10, 0, 0],
            },
            header: {
                fontSize: 26,
                bold: true,
                alignment: 'center',
                // margin: [0, 10, 0, 0],
            },
            Cust_Adrs: {
                fontSize: this.MediumFont,
                lineHeight: 1.2,
            },

            WSHeader_Left: {
                fontSize: 23,
                bold: true,
                alignment: 'left',
                // margin: [0, 10, 0, 0],
            },
            WSHeader_Center: {
                fontSize: 26,
                bold: true,
                alignment: 'center',
                // margin: [0, 10, 0, 0],
            },
            ws_adrs_center: {
                fontSize: this.MediumFont,
                alignment: 'center',
            },
            ws_adrs_left: {
                fontSize: this.MediumFont,
                alignment: 'left',
            },
            table_data: {
                margin: [0, 0.5, 0, 5],
                fontSize: this.MediumFont
            },
            table_header: {
                bold: true,
                fontSize: this.LargeFont,
                margin: [0, 1, 0, 5],
                alignment: 'center'
            },
            vendor_font: {
                fontSize: this.MediumFont,
                margin: [0, 5, 0, 5],
            },
            PO_Status: {
                fontSize: this.MediumFont,
                lineHeight: 1.4,
                margin: [10, 0, 0, 0],
            },
            po_status_font: {
                fontSize: this.LargeFont,
                // bold: true
            },
            totals_Styles: {
                marginTop: 15,
                lineHeight: 1.4,
                fontSize: this.MediumFont,
                margin: [15, 0, 0, 0],
            },
            total_margin: {
                margin: [0, 5, 0, 0],
            },
            hed: {
                fontSize: this.LargeFont,
                bold: true
            },
            Receiptheader1: {
                fontSize: 12,
                bold: true,
                alignment: 'center',
                margin: [0, 0, 0, 3]
            },
        }
    }

    static MainHeading(CName: any, Header: any, Image: any, HColor: any, AColor: any) {
        let headerstyle: string;
        let MainHeaderStyle: any = this.GetMainHeaderStyleForLeftAlignHeader(CName);
        if (Header === 1) {
            headerstyle = 'WSHeader_Center';
        } else {
            headerstyle = 'WSHeader_Left';
        }
        return [{ text: '' + CName + '', style: [headerstyle, MainHeaderStyle] }];
    }

    static GetMainHeaderStyleForLeftAlignHeader(WorkShopName: string) {
        var wsname_fontSize: any;

        if (TrUtils.IsNull(WorkShopName)) {
            WorkShopName = '';
        }

        switch (true) {
            case (WorkShopName.length < 30):
                wsname_fontSize = 23;
                break;
            case (WorkShopName.length < 35):
                wsname_fontSize = 20;
                break;
            case (WorkShopName.length < 50):
                wsname_fontSize = 17;
                break;
            default:
                wsname_fontSize = 14;
        }

        var WSHeaderFontSize: any = {
            fontSize: wsname_fontSize,
            bold: true,
        };

        return WSHeaderFontSize;

    }

    static GetHeader(Entity: any) {
        let headerstyle: string;
        if (Entity.Header === 1) {
            headerstyle = 'ws_adrs_center';
        } else {
            headerstyle = 'ws_adrs_left';
        }
        let SubHeader: any = [
            { text: '' + Entity.Adrs1 + '', style: [headerstyle] },
            { text: '' + Entity.City + this.GetPinCode(Entity.PIN) + ', ' + 'Ph: ' + Entity.Phone, style: headerstyle },
            { text: '' + this.GetEmailName(Entity.Email) + '', style: headerstyle }
        ];
        if (!TrUtils.IsEmpty(Entity.Adrs2)) {
            SubHeader.splice(1, 0, { text: '' + Entity.Adrs2 + '', style: [headerstyle] });
        }
        if (!TrUtils.IsEmpty(Entity.TLine)) {
            SubHeader.unshift({ text: this.GetTagLine(Entity.TLine), fontSize: 10, bold: true, margin: [0, 0, 0, 2] });
        }
        return SubHeader;
    }

    static GetEntityDetails(Entity: any) {
        return {
            lineHeight: 0.7,
            columns: [this.GetEntityTaxDetails(Entity)
            ]
        };

    }

    static GetTagLine(TLine: any) {
        if (TrUtils.IsEmpty(TLine)) {
            TLine = '';
        }
        return TLine;
    }

    static GetEmailName(email: any) {
        let Email: any = '';
        if (!TrUtils.IsNull(email)) {
            Email = 'Email: ' + email;
        }
        return Email;
    }

    static GetPinCode(pin: any) {
        let code: any = '';
        if (!TrUtils.IsNull(pin)) {
            code = ' - ' + pin;
        }
        return code;
    }

    static GetEntityTaxDetails(Entity: any) {
        let EntityData: any = [];
        if (!TrUtils.IsEmpty(Entity.GSTIN)) {
            EntityData.push({ name: 'GSTIN', value: Entity.GSTIN })
        }
        if (!TrUtils.IsEmpty(Entity.PAN)) {
            EntityData.push({ name: 'PAN No', value: Entity.PAN })
        }
        if (EntityData.length !== 0) {
            return this.GetEntityeDataTable(EntityData);
        } else {
            return SharedPDFService.emptyObject();
        }
    }

    static GetEntityeDataTable(EntityFields: any) {
        return {
            lineHeight: 0.7,
            marginLeft: 25,
            fontSize: this.SmallFont,
            table: {
                body: [
                    [{
                        table: {
                            fontSize: this.SmallFont,
                            widths: [37, 'auto', '*'],

                            body: this.DataCreateForTable(EntityFields)
                        },
                        layout: 'noBorders',
                    }]
                ]
            },
            layout: 'noBorders',
        };
    }

    static DataCreateForTable(EntityFields: any) {
        var body: any = [];
        EntityFields.forEach((row: any) => {
            if (!TrUtils.IsFixedZero(row.value) && !TrUtils.IsEmpty(row.value)) {
                var dataRow: any = [];
                dataRow.push({ text: (row.name).toString(), noWrap: true });
                dataRow.push(':');
                dataRow.push({ text: (row.value).toString(), noWrap: true });
                body.push(dataRow);
            }
        });
        return body;
    }

    static GetVendorDetails(PurchaseOrder: any) {
        return {
            style: 'vendor_font',
            columns: [
                { stack: [this.GetVendorData(PurchaseOrder.Vendor, PurchaseOrder.Type)], width: 120 }, { text: '', width: 250 },
                this.GetVehicle(PurchaseOrder)
            ],
            // columnGap: 150
        };
    }

    static GetVehicle(PurchaseOrder: any) {
        return {
            style: 'PO_Status',
            lineHeight: 0.7,
            columns: [
                {
                    table: {
                        fontSize: 6,
                        widths: [37, 'auto', '*'],
                        body: [[{ text: 'ID', alignment: 'right', style: 'po_status_font' }, { text: ':', style: 'po_status_font' }, PurchaseOrder.Id],
                        [{ text: 'Date', alignment: 'right', style: 'po_status_font' }, { text: ':', style: 'po_status_font' }, PurchaseOrder.CrDate],
                            // [{ text: 'Status', alignment: 'right', style: 'po_status_font' }, { text: ':', style: 'po_status_font' }, PurchaseOrder.Status]

                        ]
                    },
                    layout: 'noBorders',
                },

            ]

        };
    }

    static GetVendorData(Vendor: any, Type: any) {
        if (TrUtils.IsNull(Vendor)) {
            return SharedPDFService.emptyObject();
        }
        return {
            style: 'Cust_Adrs',
            stack: [{ text: 'Vendor Name & Address:', style: 'hed' },
            { text: Vendor.Name, marginTop: 2 },
            { text: this.GetAddress(Vendor), marginTop: 3 },
            this.GetVendorPhoneNumber(Vendor, Type), this.GetVendorGSTIN(Vendor)
            ]
        };
    }

    static GetAddress(Vendor: any) {
        var Address = this.GetFormatAddress(Vendor);
        if (Address.length !== 5) {
            return Address;
        } else {
            let a: any = '';
            return a;
        }
    }

    static GetFormatContact(CustomerObj: any) {
        var contactnew = '';
        CustomerObj.Contact.forEach((Contact: any) => {
            contactnew = contactnew + '(' + Contact.Type + '):' + Contact.No + '\n';
        });
        return contactnew;
    }

    static GetFormatAddress(CustomerObj: any) {
        var Addressnew = '';
        if (!TrUtils.IsNull(CustomerObj) && !TrUtils.IsNull(CustomerObj.Address)) {
            CustomerObj.Address.forEach((Adrs: any) => {
                Addressnew = Addressnew + Adrs + '\n';
            });
        }

        return Addressnew;
    }

    static GetVendorGSTIN(Vendor: any) {
        let GSTIN: any = {};
        if (!TrUtils.IsEmpty(Vendor.GSTIN)) {
            let columns: any = [];
            columns.push({ text: 'GSTIN :', width: 33, style: 'hed' });
            columns.push({ text: Vendor.GSTIN, marginTop: 1.5 });
            GSTIN.columns = columns;
            return GSTIN;
        } else {
            return GSTIN;
        }
    }

    static GetVendorPhoneNumber(Vendor: any, Type: any) {
        let PhoneNumber: any = {};
        if (Type !== 'Technician Copy') {
            var contact = this.GetFormatContact(Vendor);
            if (contact.length !== 0) {
                let columns: any = [];
                columns.push({ text: 'Phone', width: 27, style: 'hed' });
                columns.push(contact);
                PhoneNumber.columns = columns;
                return PhoneNumber;
            } else {
                return PhoneNumber;
            }
        } else {
            return PhoneNumber;
        }
    }

    static VendorDetailsAfterLine() {
        return {
            canvas: [
                {
                    type: 'line',
                    lineColor: 'black',
                    x1: 0,
                    y1: 0,
                    x2: 575,
                    y2: 0,
                    lineWidth: 1
                }
            ]
        };
    }

    static getPartsData(ROPrintData: any) {
        if (ROPrintData.Entity.Body === 1) {
            return this.GetPartsTableForView(TrUtils.Stringify(ROPrintData.Items), TrUtils.Stringify(ROPrintData.Ops), ROPrintData.Entity.MPN);
        } else {
            if (ROPrintData.Entity.Body === 2) {
                return this.WithOutDiscountFieldTable(TrUtils.Stringify(ROPrintData.Items), TrUtils.Stringify(ROPrintData.Ops), ROPrintData.Entity.MPN, ROPrintData.ShowTaxColumn, ROPrintData.Entity.Body, ROPrintData.ShowIGST, ROPrintData.ShowDiscountColumn);
            } else {
                return this.GetWithOutDiscAndTaxFieldHeader(
                    TrUtils.Stringify(ROPrintData.Items), TrUtils.Stringify(ROPrintData.Ops), ROPrintData.Entity.MPN, ROPrintData.ShowTaxColumn, ROPrintData.Entity.Body, ROPrintData.ShowIGST, ROPrintData.ShowDiscountColumn);
            }
        }
    }

    static GetWithOutDiscAndTaxFieldHeader(Items: any, Ops: any, PrintPartNo: any, ShowTaxColumn: any, Body: any, ShowIGST: any, ShowDiscountColumn: any) {
        if (Items.length !== 0) {
            if (ShowTaxColumn) {
                return this.TaxDataTable(PrintPartNo, ShowIGST, Items, Ops, Body, ShowTaxColumn, ShowDiscountColumn);
            } else {
                return this.WithOutTaxDataTable(PrintPartNo, ShowIGST, Items, Ops, Body, ShowTaxColumn, ShowDiscountColumn)
            }
        } else {
            let a: any = '';
            return a;
        }
    }

    static TaxDataTable(PrintPartNo: any, ShowIGST: any, Items: any, Ops: any, Body: any, ShowTaxColumn: any, ShowDiscountColumn: any) {
        if (PrintPartNo) {
            return this.TaxDataTableWithPartNumber(PrintPartNo, ShowIGST, Items, Ops, Body, ShowTaxColumn, ShowDiscountColumn);
        } else {
            return this.TaxDataTableWithOutPartNumber(PrintPartNo, ShowIGST, Items, Ops, Body, ShowTaxColumn, ShowDiscountColumn);
        }
    }

    static TaxDataTableWithPartNumber(PrintPartNo: any, ShowIGST: any, Items: any, Ops: any, Body: any, ShowTaxColumn: any, ShowDiscountColumn: any) {
        if (ShowIGST) {
            return this.IGSTTaxDataTableWithPartNumber(PrintPartNo, ShowIGST, Items, Ops, Body, ShowTaxColumn, ShowDiscountColumn);
        } else {
            return this.CGSTAndSGSTTaxDataTableWithPartNUmber(PrintPartNo, ShowIGST, Items, Ops, Body, ShowTaxColumn, ShowDiscountColumn);

        }
    }

    static IGSTTaxDataTableWithPartNumber(PrintPartNo: any, ShowIGST: any, Items: any, Ops: any, Body: any, ShowTaxColumn: any, ShowDiscountColumn: any) {
        return {
            style: 'table_data',
            table: {
                widths: PrintSharedService.TaxTableWidths(PrintPartNo, ShowIGST, ShowDiscountColumn),
                body: this.BuildTableBodyForLaborAndParts(Items, Ops, PrintPartNo, ShowTaxColumn, Body, ShowIGST, ShowDiscountColumn)
            },
            layout: PrintSharedService.LayOutStyle()
        };
    }

    static CGSTAndSGSTTaxDataTableWithPartNUmber(PrintPartNo: any, ShowIGST: any, Items: any, Ops: any, Body: any, ShowTaxColumn: any, ShowDiscountColumn: any) {
        return {
            style: 'table_data',
            table: {
                widths: PrintSharedService.TaxTableWidths(PrintPartNo, ShowIGST, ShowDiscountColumn),
                body: this.BuildTableBodyForLaborAndParts(Items, Ops, PrintPartNo, ShowTaxColumn, Body, ShowIGST, ShowDiscountColumn)
            },
            layout: PrintSharedService.LayOutStyle()
        };
    }

    static TaxDataTableWithOutPartNumber(PrintPartNo: any, ShowIGST: any, Items: any, Ops: any, Body: any, ShowTaxColumn: any, ShowDiscountColumn: any) {
        if (ShowIGST) {
            return this.IGSTTaxDataTableWithOutPartNumber(PrintPartNo, ShowIGST, Items, Ops, Body, ShowTaxColumn, ShowDiscountColumn);
        } else {
            return this.CGSTAndSGSTTaxDataTableWithOutPartNUmber(PrintPartNo, ShowIGST, Items, Ops, Body, ShowTaxColumn, ShowDiscountColumn);
        }
    }

    static IGSTTaxDataTableWithOutPartNumber(PrintPartNo: any, ShowIGST: any, Items: any, Ops: any, Body: any, ShowTaxColumn: any, ShowDiscountColumn: any) {
        return {
            style: 'table_data',
            table: {
                widths: PrintSharedService.TaxTableWidths(PrintPartNo, ShowIGST, ShowDiscountColumn),
                body: this.BuildTableBodyForLaborAndParts(Items, Ops, PrintPartNo, ShowTaxColumn, Body, ShowIGST, ShowDiscountColumn)
            },
            layout: PrintSharedService.LayOutStyle()
        };
    }

    static CGSTAndSGSTTaxDataTableWithOutPartNUmber(PrintPartNo: any, ShowIGST: any, Items: any, Ops: any, Body: any, ShowTaxColumn: any, ShowDiscountColumn: any) {
        return {
            style: 'table_data',
            table: {
                widths: PrintSharedService.TaxTableWidths(PrintPartNo, ShowIGST, ShowDiscountColumn),
                body: this.BuildTableBodyForLaborAndParts(Items, Ops, PrintPartNo, ShowTaxColumn, Body, ShowIGST, ShowDiscountColumn)
            },
            layout: PrintSharedService.LayOutStyle()
        };
    }

    static WithOutTaxDataTable(PrintPartNo: any, ShowIGST: any, Items: any, Ops: any, Body: any, ShowTaxColumn: any, ShowDiscountColumn: any) {
        if (PrintPartNo) {
            return this.WithOutTaxDataTableWithPartNumber(Items, Ops, PrintPartNo, ShowTaxColumn, Body, ShowIGST, ShowDiscountColumn);
        } else {
            return this.WithOutTaxDataTableWithOutPartNumber(Items, Ops, PrintPartNo, ShowTaxColumn, Body, ShowIGST, ShowDiscountColumn);
        }
    }

    static WithOutTaxDataTableWithPartNumber(Items: any, Ops: any, PrintPartNo: any, ShowTaxColumn: any, Body: any, ShowIGST: any, ShowDiscountColumn: any) {
        return {
            style: 'table_data',
            marginLeft: 20,
            table: {
                widths: [15, 70, 200, 25, 60, 40, 40, 55],
                body: this.BuildTableBodyForLaborAndParts(Items, Ops, PrintPartNo, ShowTaxColumn, Body, ShowIGST, ShowDiscountColumn)
            },
            layout: PrintSharedService.LayOutStyle()
        };
    }

    static WithOutTaxDataTableWithOutPartNumber(Items: any, Ops: any, PrintPartNo: any, ShowTaxColumn: any, Body: any, ShowIGST: any, ShowDiscountColumn: any) {
        return {
            style: 'table_data',
            marginLeft: 20,
            table: {
                widths: [15, 274, 50, 72, 80],
                body: this.BuildTableBodyForLaborAndParts(Items, Ops, PrintPartNo, ShowTaxColumn, Body, ShowIGST, ShowDiscountColumn)
            },
            layout: PrintSharedService.LayOutStyle()
        };
    }

    static GetPartsTableForView(Items: any, Ops: any, PrintPartNo: any) {
        if (Items.length !== 0) {
            if (PrintPartNo) {
                return {
                    style: 'table_data',
                    marginLeft: 20,
                    table: {
                        widths: [15, 85, 170, 20, 50, 30, 30, 60],
                        // headerRows: 2,
                        body: this.PartsTableBody(Items, Ops, PrintPartNo)
                    },
                    layout: PrintSharedService.LayOutStyleanother()
                };
            } else {
                return {
                    style: 'table_data',
                    marginLeft: 20,
                    table: {
                        widths: [15, 250, 25, 50, 35, 35, 60],
                        // headerRows: 2,
                        body: this.PartsTableBody(Items, Ops, PrintPartNo)
                    },
                    layout: PrintSharedService.LayOutStyleanother()
                };
            }
        } else {
            let a: any = '';
            return a;
        }
    }

    static WithOutDiscountFieldTable(Items: any, Ops: any, PrintPartNo: any, ShowTaxColumn: any, Body: any, ShowIGST: any, ShowDiscountColumn: any) {
        if (Items.length !== 0) {
            if (PrintPartNo) {
                return {
                    style: 'table_data',
                    marginLeft: 20,
                    table: {
                        widths: [15, 67, 160, 25, 50, 60, 30, 53],
                        headerRows: 1,
                        body: this.BuildTableBodyForLaborAndParts(Items, Ops, PrintPartNo, ShowTaxColumn, Body, ShowIGST, ShowDiscountColumn)
                    },
                    layout: PrintSharedService.LayOutStyleanother()
                };
            } else {
                return {
                    style: 'table_data',
                    marginLeft: 20,
                    table: {
                        widths: [15, 215, 25, 50, 60, 45, 60],
                        headerRows: 1,
                        body: this.BuildTableBodyForLaborAndParts(Items, Ops, PrintPartNo, ShowTaxColumn, Body, ShowIGST, ShowDiscountColumn)
                    },
                    layout: PrintSharedService.LayOutStyleanother()
                };
            }
        } else {
            let a: any = '';
            return a;
        }
    }

    static BuildTableBodyForLaborAndParts(Items: any, Ops: any, PrintPartNo: any, ShowTaxColumn: any, Body: any, ShowIGST: any, ShowDiscountColumn: any) {
        var body: any = [];
        let columns: any = PrintSharedService.GetWithOutDiscountFieldHeader(PrintPartNo, ShowTaxColumn, Body, ShowIGST, ShowDiscountColumn);
        // if (ShowTaxColumn) {
        for (let i = 0; i < columns.length; i++) {
            body.push(columns[i]);
        }
        columns = columns[1];
        // } else {
        //     body.push(columns);
        // }
        let PartsTable = this.GetPartsDataTable(Items, Ops, columns, body);
        return PartsTable;
    }

    static GetPartsDataTable(Items: any, Ops: any, columns: any, body: any) {
        let SNo: number = 1;
        Items.forEach((part: any) => {
            var dataRow: any = [];
            columns.forEach((column: any) => {
                if (!TrUtils.IsFixedZero(part[column.Field]) && !TrUtils.IsNull(part[column.Field])
                    || column.text === 'Line Total' || column.text === 'Unit Price') {
                    if (part[column.Field] === 'Spare Items') {
                        dataRow.push({ text: part[column.Field]?.toString(), marginLeft: 50, style: 'InlineHeader' });
                    } else {
                        if (column.text === 'Line Total' || column.Field === 'QtyAndUoM'
                            || column.Field === 'CGSTAmt' || column.Field === 'SGSTAmt') {
                            dataRow.push({ text: part[column.Field]?.toString(), alignment: 'right', nowrap: true });
                        } else if (column.Field1 === 'UnCo') {
                            dataRow.push({ text: part[column.Field1]?.toString(), alignment: 'right', nowrap: true });
                        } else {
                            // dataRow.push(part[column.Field].toString());
                            if (column.Field === 'Desc') {
                                let DescData: any = [];
                                DescData.push(part[column.Field]?.toString());
                                if (!TrUtils.IsEmpty(part['EDesc'])) {
                                    DescData.push({ text: part['EDesc'].toString(), color: 'grey' });
                                }
                                dataRow.push({ stack: DescData });
                            } else {
                                dataRow.push({ text: part[column.Field].toString() });
                            }
                        }
                    }
                } else {
                    if (column.Field === 'SNo') {
                        part[column.Field] = SNo;
                        SNo = SNo + 1;
                    } else {
                        part[column.Field] = '';
                    }
                    dataRow.push({ text: part[column.Field].toString(), alignment: 'center' });
                }
            });

            body.push(dataRow);
        });

        if (!TrUtils.IsNull(Ops)) {
            Ops?.forEach((part: any) => {
                var dataRow: any = [];
                columns.forEach((column: any) => {
                    if (!TrUtils.IsFixedZero(part[column.Field]) && !TrUtils.IsNull(part[column.Field])
                        || column.text === 'Line Total' || column.text === 'Unit Price') {
                        if (part[column.Field] === 'Spare Items') {
                            dataRow.push({ text: part[column.Field]?.toString(), marginLeft: 50, style: 'InlineHeader' });
                        } else {
                            if (column.text === 'Line Total' || column.Field === 'QtyAndUoM'
                                || column.Field === 'CGSTAmt' || column.Field === 'SGSTAmt') {
                                dataRow.push({ text: part[column.Field]?.toString(), alignment: 'right', nowrap: true });
                            } else if (column.Field1 === 'UnCo') {
                                dataRow.push({ text: part[column.Field1]?.toString(), alignment: 'right', nowrap: true });
                            } else {
                                // dataRow.push(part[column.Field].toString());
                                if (column.Field === 'Desc') {
                                    let DescData: any = [];
                                    DescData.push(part[column.Field]?.toString());
                                    if (!TrUtils.IsEmpty(part['EDesc'])) {
                                        DescData.push({ text: part['EDesc'].toString(), color: 'grey' });
                                    }
                                    dataRow.push({ stack: DescData });
                                } else {
                                    dataRow.push({ text: part[column.Field].toString() });
                                }
                            }
                        }
                    } else {
                        if (column.Field === 'SNo') {
                            part[column.Field] = SNo;
                            SNo = SNo + 1;
                        } else {
                            part[column.Field] = '';
                        }
                        dataRow.push({ text: part[column.Field].toString(), alignment: 'center' });
                    }
                });

                body.push(dataRow);
            });
        }



        return body;
    }

    static PartsTableBody(Items: any, Ops: any, PrintPartNo: any) {
        var body: any = [];
        let columns: any = SharedPDFService.GetHeaders(PrintPartNo);
        for (let i = 0; i < columns.length; i++) {
            body.push(columns[i]);
        }

        let PartsTable = this.GetPartsDataTable(Items, Ops, columns[1], body);
        return PartsTable;
    }

    static GetPOTotalDetails(ROPrintData: any, moreDiscDetails:boolean) {
        if (TrUtils.IsNull(ROPrintData.SubTotal)) {
            ROPrintData.SubTotal = 0;
        }
        return {
            columns: [
                {
                    stack: [
                        this.GetTaxOnParts(ROPrintData.PartsTotalAfterDisc, ROPrintData.PartsTotalBeforeDisc,
                            ROPrintData.PartCGST, ROPrintData.PartSGST, ROPrintData.PartIGST, ROPrintData.ShowIGST, ROPrintData.ShowAccParts, ROPrintData.ShowTaxColumn, ROPrintData.ShowDetailedPartTaxInfo),
                        this.PartsAmountGroupByTax(ROPrintData.PartsTaxInfo, ROPrintData.ShowAccParts,
                            ROPrintData.ShowIGST, ROPrintData.ShowTaxColumn)
                    ]
                }, { text: '', width: moreDiscDetails?170:200 }, this.GrandTotal(ROPrintData,ROPrintData.LaborAfterGST, ROPrintData.PartAfterTax,
                    ROPrintData.Total, ROPrintData.TotalRoundedBy, ROPrintData.RoundedTotal, ROPrintData.SubTotal, ROPrintData.TaxTotal,
                    ROPrintData.PartsDiscTotal, ROPrintData.Adjust, moreDiscDetails)]
            , marginLeft: 10
        };
    }

    static GetTaxOnParts(BasicPartsTotal: any, PartsTotalBeforeDisc: any, PCGST: any, PSGST: any, ShowAccParts: any, PIGST: any, ShowIGST: any, ShowTaxColumn: any, ShowDetailedPartTaxInfo: any) {
        let istheretax = false;
        let PartsTotal = [];
        if (!TrUtils.IsFixedZero(BasicPartsTotal)) {
            PartsTotal.push({ name: 'Total Taxable', value: BasicPartsTotal });
        }
        if (ShowTaxColumn) {
            if (!TrUtils.IsFixedZero(PartsTotalBeforeDisc)) {
                PartsTotal.unshift({ name: 'Items', value: PartsTotalBeforeDisc });
            }
        }
        if (ShowTaxColumn && ShowDetailedPartTaxInfo) {
            if (ShowIGST) {
                PartsTotal.push({ name: 'IGST On Items', value: PIGST });
            } else {
                PartsTotal.push({ name: 'CGST On Items', value: PCGST });
                PartsTotal.push({ name: 'SGST On Items', value: PSGST });
            }
        }
        if (PartsTotal.length !== 0) {
            return {
                style: ['total_margin', 'totals_Styles'],
                lineHeight: 0.7,
                fontSize: 7,
                marginBottom: 5,
                table: {
                    body: this.CreatePartsTotalsTable(PartsTotal, true)
                },
                layout: 'noBorders',
            };
        } else {
            return SharedPDFService.emptyObject();
        }
    }

    static GrandTotal(RecordData:any, LaborAfterGST: any, PartsAfterGST: any, OverAllRecordTotal: any, Rounded: any, GrandTotal: any, SubTotal: any, TaxTotal: any, PartsDiscTotal: any, Adj: any, moreDiscDetails:boolean) {
        let AccountFields = [
            // { name: 'Part Total', value: PartsAfterGST }
        ];
        let total = {
            name: 'Total',
            value: TrUtils.FixPriceValue(OverAllRecordTotal, RecordData.Entity.DecimalsNumber)
        };
        let Rounding = { name: 'Rounding', value: Rounded };
        let FinalTotal = { name: 'Total', value: GrandTotal };
        if (Rounding.value > 0) {
            Rounding.value = '+' + Rounding.value;
        }

        if (!TrUtils.IsFixedZero(SubTotal)) {
            AccountFields.push({ name: 'SubTotal', value: TrUtils.FixPriceValue(SubTotal, RecordData.Entity.DecimalsNumber) })
        }

        if (!TrUtils.IsEmpty(PartsDiscTotal) && !moreDiscDetails) {
            AccountFields.push({ name: 'Discount', value: '-' + PartsDiscTotal });
        }else{
            AccountFields.push({ name: 'Overall Discount', value: '-' + TrUtils.FixPriceValue(RecordData.Disc, RecordData.Entity.DecimalsNumber) });

        }

        if (!TrUtils.IsEmpty(TaxTotal)) {
            AccountFields.push({ name: 'Total Tax', value: TaxTotal });
        }

        if (!TrUtils.IsEmpty(Adj)) {
            if (Adj > 0) {
                Adj = '+' + TrUtils.FixPriceValue(Adj, RecordData.Entity.DecimalsNumber);
            }
            AccountFields.push({ name: 'Adjust', value: TrUtils.FixPriceValue(Adj, RecordData.Entity.DecimalsNumber) });
        }
        AccountFields.push(total);
        AccountFields.push(Rounding);
        if (!TrUtils.IsFixedZero(Rounded)) {
            AccountFields.push(FinalTotal);
        }
        return {
            style: ['total_margin', 'totals_Styles'],
            lineHeight: 0.7,
            marginBottom: 5,
            table: {
                body: this.CreateGrandTotalTable(AccountFields)
            },
            layout: 'noBorders'
        };
    }

    static PartsAmountGroupByTax(PartsTaxInfo: any, ShowAccParts: any, ShowIGST: any, ShowTaxColumn: any) {
        if (ShowTaxColumn) {
            return {
                stack: [this.PartsGroupByHSN(PartsTaxInfo, ShowAccParts, ShowIGST, ShowTaxColumn)]
            };
        } else {
            return '';
        }
    }

    static PartsGroupByHSN(PartsTaxInfo: any, ShowAccParts: any, ShowIGST: any, ShowTaxColumn: any) {

        if (ShowIGST) {
            return {
                style: 'table_data',
                table: {
                    widths: [40, 30, 45, 45],
                    headerRows: 1,
                    body: this.CreateTableForGroupByHSN(PartsTaxInfo, ShowAccParts, ShowIGST, ShowTaxColumn)
                },
                layout: this.HeaderLineStyle(),
            };
        } else {
            return {
                style: 'table_data',
                table: {
                    widths: [40, 15, 15, 45, 45],
                    headerRows: 1,
                    body: this.CreateTableForGroupByHSN(PartsTaxInfo, ShowAccParts, ShowIGST, ShowTaxColumn)
                },
                layout: this.HeaderLineStyle(),
            };
        }
    }

    static PartsGroupByPercentage(PartsTaxInfo: any, ShowAccParts: any, ShowTaxColumn: any) {
        return {
            style: 'table_data',
            table: {
                widths: [20, 20, 40, 40],
                body: this.CreateTableForGroupByPercentage(PartsTaxInfo, ShowAccParts, ShowTaxColumn)
            },
            layout: this.HeaderLineStyle(),
        };
    }

    static GetSignatures(CName: any) {
        return {
            fontSize: this.MediumFont,
            columns: [{
                stack: [
                    this.CompanyName(CName),
                    { columns: [this.Authorizedsignature()] }
                ]
            }],
        };
    }

    static CompanyName(CName: any) {
        return {
            style: 'forCompany',
            text: ['For ', { text: CName, bold: 'true' }],
        };
    }

    static Authorizedsignature() {
        return {
            style: 'Sign',
            text: ['Authorized Signatory'],
        };
    }

    static HeaderLineStyle() {
        return {
            hLineWidth: function (i: any, node: any) {
                return (i === 1) ? 0.5 : 0;
            },
            vLineWidth: function (i: any, node: any) {
                return (i === 0 || i === node.table.widths.length) ? 0 : 0;
            },
        };
    }

    static CreateHeaderForGroupByPercentage() {
        let HeaderNames = [{ text: 'GST(%)', style: 'table_header', fontSize: 6, lineHeight: 0.3, Field: 'CombinedTaxPercentage' },
        { text: 'Count', style: 'table_header', fontSize: 6, lineHeight: 0.3, Field: 'PartsCount' },
        { text: 'Taxble Value', style: 'table_header', alignment: 'right', fontSize: 6, lineHeight: 0.3, Field: 'TotalTaxableAmount' },
        { text: 'Amount', style: 'table_header', alignment: 'right', fontSize: 6, lineHeight: 0.3, Field: 'TotalTaxAmount' },
        ];
        return HeaderNames;
    }

    static CreateHeaderForGroupByHSN(ShowIGST: any) {
        let HeaderNames = [{ text: 'HSN', style: 'table_header', fontSize: 6, lineHeight: 0.3, Field: 'HSN' },
        { text: 'Taxable Value', style: 'table_header', fontSize: 6, lineHeight: 0.3, Field: 'TotalTaxableAmount' },
        { text: 'Amount', style: 'table_header', fontSize: 6, lineHeight: 0.3, Field: 'TotalTaxAmount' },
        ];
        if (ShowIGST) {
            HeaderNames.splice(1, 0, { text: 'IGST', style: 'table_header', fontSize: 6, lineHeight: 0.3, Field: 'IGST' })
        } else {
            HeaderNames.splice(1, 0, { text: 'CGST', style: 'table_header', fontSize: 6, lineHeight: 0.3, Field: 'CGST' })
            HeaderNames.splice(2, 0, { text: 'SGST', style: 'table_header', fontSize: 6, lineHeight: 0.3, Field: 'SGST' })
        }
        return HeaderNames;
    }

    static CreateTableForGroupByHSN(PartsTaxInfo: any, ShowAccParts: any, ShowIGST: any, ShowTaxColumn: any) {
        if (!TrUtils.IsNull(PartsTaxInfo) && PartsTaxInfo.length !== 0 && ShowAccParts && ShowTaxColumn) {
            var body: any = [];
            let columns: any = this.CreateHeaderForGroupByHSN(ShowIGST);
            body.push(columns);
            PartsTaxInfo.forEach((part: any) => {
                var dataRow: any = [];
                columns.forEach((column: any) => {
                    if (!TrUtils.IsFixedZero(part[column.Field]) &&
                        !TrUtils.IsNull(part[column.Field]) || column.Field === 'SGST' || column.Field === 'CGST'
                        || column.Field === 'TotalTaxAmount') {
                        if (column.Field === 'SGSTLaborAmt') {
                            dataRow.push({ text: part[column.Field].toString(), alignment: 'right', nowrap: true });
                        } else {
                            dataRow.push({ text: part[column.Field].toString(), alignment: 'center', nowrap: true });
                        }
                    } else {
                        part[column.Field] = '';
                        dataRow.push({ text: part[column.Field].toString(), alignment: 'center' });
                    }
                });

                body.push(dataRow);
            });
            return body;
        } else {
            return [{}];
        }
    }

    static CreateTableForGroupByPercentage(PartsTaxInfo: any, ShowAccParts: any, ShowTaxColumn: any) {
        if (!TrUtils.IsNull(PartsTaxInfo) && PartsTaxInfo.length !== 0 && ShowAccParts && ShowTaxColumn) {
            var body: any = [];
            let columns: any = this.CreateHeaderForGroupByPercentage();
            body.push(columns);
            PartsTaxInfo.forEach((part: any) => {

                var dataRow: any = [];
                columns.forEach((column: any) => {
                    if (!TrUtils.IsNull(part[column.Field]) && !TrUtils.IsNull(part[column.Field])) {
                        if (column.Field === 'TotalTaxAmount' || column.Field === 'TotalTaxableAmount') {
                            dataRow.push({ text: part[column.Field].toString(), alignment: 'right', nowrap: true });
                        } else {
                            dataRow.push({ text: part[column.Field].toString(), alignment: 'center', nowrap: true });
                        }
                    } else {
                        part[column.Field] = '';
                        dataRow.push({ text: part[column.Field].toString(), alignment: 'center' });
                    }
                });

                body.push(dataRow);
            });
            return body;
        } else {
            return [{}];
        }
    }

    static CreateGrandTotalTable(data: any) {
        var body: any = [];
        data.forEach((row: any) => {
            if (!TrUtils.IsFixedZero(row.value) || row.name === 'Total') {
                var dataRow: any = [];
                dataRow.push({ text: (row.name).toString(), noWrap: true });
                dataRow.push(':');
                dataRow.push({ text: (row.value).toString(), noWrap: true, alignment: 'right' });
                body.push(dataRow);
            }
        });
        return body;
    }

    static CreatePartsTotalsTable(data: any, istotal: boolean) {
        var body: any = [];
        data.forEach((row: any) => {
            var dataRow: any = [];
            if (row.name === 'Items') {
                dataRow.push({ text: [{ text: row.name, bold: 'true' }, ' Total'] });
            } else {
                dataRow.push({ text: (row.name).toString(), noWrap: true });
            }
            dataRow.push(':');
            if (istotal) {
                dataRow.push({ text: (row.value).toString(), noWrap: true, alignment: 'right' });
            } else {
                dataRow.push({ text: (row.value).toString(), noWrap: true, });
            }
            body.push(dataRow);
        });
        return body;
    }

}