import { PayTypeEnum } from '../enums/enums';
import { SharedPDFService } from '../shared/shared-pdf.service';
import { TrUtils } from '../utils/tr-utils';
declare var pdfMake: any;

export class TechnicianpdfService {

    static GetTechnicianPrint(RepairOrder: any, isOtherIndustry: boolean) {
        var dd = {
            info: {
                title: 'Technician',
            },
            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(RepairOrder.Entity.CName, RepairOrder.Entity.Header, RepairOrder.Image, RepairOrder.HColor, null),
                SharedPDFService.GetMainHeader(RepairOrder.Entity, RepairOrder.Image, RepairOrder.AColor, RepairOrder.HColor, null),
                SharedPDFService.GetPrintType(RepairOrder.HeaderName),
                SharedPDFService.HeaderAfterLine(),
                SharedPDFService.GetCustomerAndVehicleDetails(RepairOrder._id, RepairOrder.CrDate, RepairOrder.PrDate,
                    RepairOrder.MOut, RepairOrder.MIn, RepairOrder.Product, RepairOrder.PrintType, RepairOrder.For,
                    RepairOrder.SurName, RepairOrder.SurPhone, RepairOrder.Type, RepairOrder.SurEmail, RepairOrder.InsComp,
                    RepairOrder.PolNo, RepairOrder.PolType, RepairOrder.Customer, false, RepairOrder.Settings, null, isOtherIndustry, null, null,null,null, RepairOrder.DoS),
                SharedPDFService.CustomerAndVehicleDetailsAfterLine(),
                { stack: this.getComplaintsAndServices(RepairOrder.Comps, RepairOrder.Ops), marginBottom: 7 },
                this.getLine(RepairOrder.Comps),
                this.getOnlyServices(RepairOrder.Ops),
                this.GetIndHeading(RepairOrder.Colli),
                this.GetCollisionItems(RepairOrder.Colli, RepairOrder.Parts, RepairOrder.Ops),
            ],
            styles: SharedPDFService.GetStyles()
        };
        return dd;
        // pdfMake.createPdf(dd).open();
        // this.dd = TrUtils.Stringify(dd);
        // pdfMake.createPdf(dd).getDataUrl(function (outDoc: any) {
        //     document.getElementById('pdf').setAttribute('src', outDoc);
        // });
    }

    static GetIndHeading(CollItems: any) {
        if (!TrUtils.IsNull(CollItems) && CollItems.length !== 0) {
            return [{ text: 'Accidental Repairs :', fontSize: 12, marginTop: 5, bold: true, decoration: 'underline' }];
        } else {
            let a: any = {};
            return a;
        }
    }

    static getLine(Comps: any) {
        if (Comps.length !== 0) {
            return SharedPDFService.GetUnderLine();
        } else {
            let a: any = {};
            return a;
        }
    }

    static GetCollisionItems(CollItems: any, Parts: any, Labors: any) {
        if (!TrUtils.IsNull(CollItems) && CollItems.length !== 0) {
            return {
                style: 'tableExample',
                marginTop: 10,
                lineHeight: 1,
                table: {
                    widths: [20, 300, 20, 60, 60, 60],
                    // headerRows: 1,
                    body: this.GetCollisionItemsBody(CollItems, Parts, Labors)
                },
                layout: {
                    hLineColor: function (i: any, node: any) {
                        return 'lightgray';
                    },
                    vLineColor: function (i: any, node: any) {
                        return 'lightgray';
                    },
                }
            };
        } else {
            let a: any = {};
            return a;
        }
    }

    static GetCollisionItemsBody(CollItems: any, Parts: any, Labors: any) {
        var body: any = [];
        let columns: any = this.GetCollisionItemsHeader();
        body.push(columns);
        let SNo: number = 1;
        CollItems.forEach((CollItem: any, i: any) => {
            var dataRow: any = [];
            columns.forEach((column: any) => {
                if (column.Field === 'SNo') {
                    CollItem[column.Field] = SNo;
                    SNo = SNo + 1;
                } else if (column.Field === 'Desc') {
                    CollItem[column.Field] = CollItem.Desc;
                } else if (column.Field === 'rr') {
                    let CollLaborIndex: any = Labors.findIndex((Labor: any) => {
                        return Labor._id === CollItem.RRFId;
                    });
                    if (CollLaborIndex !== -1) {
                        CollItem[column.Field] = this.CheckPrice(Labors[CollLaborIndex]);
                    } else {
                        CollItem[column.Field] = '';
                    }
                } else if (column.Field === 'dtng') {
                    let CollLaborIndex: any = Labors.findIndex((Labor: any) => {
                        return Labor._id === CollItem.RepId;
                    });
                    if (CollLaborIndex !== -1) {
                        CollItem[column.Field] = this.CheckPrice(Labors[CollLaborIndex]);
                    } else {
                        CollItem[column.Field] = '';
                    }
                } else if (column.Field === 'ptng') {
                    let CollLaborIndex: any = Labors.findIndex((Labor: any) => {
                        return Labor._id === CollItem.PainId;
                    });
                    if (CollLaborIndex !== -1) {
                        CollItem[column.Field] = this.CheckPrice(Labors[CollLaborIndex]);
                    } else {
                        CollItem[column.Field] = '';
                    }
                } else if (column.Field === 'Qty') {
                    let CollPartIndex: any = Parts.findIndex((Part: any) => {
                        return Part.CollId === CollItem._id;
                    });
                    if (CollPartIndex !== -1) {
                        CollItem[column.Field] = Parts[CollPartIndex][column.Field];
                    } else {
                        CollItem[column.Field] = '';
                    }
                } else {
                    CollItem[column.Field] = '';
                }
                if (column.Field === 'Desc') {
                    let DescData: any = [];
                    DescData.push(CollItem[column.Field].toString());
                    if (!TrUtils.IsEmpty(CollItem['EDesc'])) {
                        DescData.push({ text: CollItem['EDesc'].toString(), color: 'grey' });
                    }
                    dataRow.push({ stack: DescData });
                } else {
                    dataRow.push({ text: CollItem[column.Field].toString(), alignment: 'center' });
                }

            });
            body.push(dataRow);
        });
        return body;
    }

    static CheckPrice(Labor: any) {
        if (Labor.PBy === PayTypeEnum.Insurance) {
            if (!TrUtils.IsZero(Labor.AssPr)) {
                return 'Yes';
            } else {
                return '';
            }
        }
        if (Labor.PBy === PayTypeEnum.Customer) {
            if (!TrUtils.IsZero(Labor.Pr)) {
                return 'Yes';
            } else {
                return '';
            }
        }
        if (Labor.PBy === PayTypeEnum.Shared) {
            if (!TrUtils.IsZero(Labor.AssPr) && !TrUtils.IsZero(Labor.Pr)) {
                return 'Yes';
            } else {
                return '';
            }
        }
    }

    static GetCollisionItemsHeader() {
        let headersNames =
            [{ text: 'S.No.', Field: 'SNo', style: ['tableheader', 'withOutApp'] },
            { text: 'Description', Field: 'Desc', style: ['tableheader', 'withOutApp'] },
            { text: 'Qty', Field: 'Qty', style: ['tableheader', 'withOutApp'] },
            { text: 'R&R', Field: 'rr', style: ['tableheader', 'withOutApp'] },
            { text: 'Denting', Field: 'dtng', style: ['tableheader', 'withOutApp'] },
            { text: 'Painting', Field: 'ptng', style: ['tableheader', 'withOutApp'] }];

        return headersNames;
    }

    static getComplaintsAndServices(Comps: any, Ops: any) {
        var List: any = [];
        if (!TrUtils.IsNull(Comps) && Comps.length !== 0) {
            List.push({ text: 'Complaints :', fontSize: 12, marginTop: 5, bold: true, decoration: 'underline' });
            for (var i = 0; i < Comps.length; i++) {
                List.push({ ul: [{ text: Comps[i].Desc, fontSize: 10, bold: true, marginLeft: 10, marginTop: 5 }] });
                for (var j = 0; j < Ops.length; j++) {
                    if (Comps[i]._id === Ops[j].CompId) {
                        List.push({ text: Ops[j].Desc, fontSize: SharedPDFService.TableHeaders, marginTop: 1.5, marginLeft: 30 });
                    }
                }
            }
            return List;
        } else {
            return List;
        }
    }

    static getOnlyServices(Ops: any) {
        let List: any = [];
        let isTrue: boolean = false;
        if (!TrUtils.IsNull(Ops) && Ops.length !== 0) {
            for (var i = 0; i < Ops.length; i++) {
                if (TrUtils.IsNull(Ops[i].CompId) && TrUtils.IsNull(Ops[i].CollId)) {
                    isTrue = true;
                    List.push({ ul: [{ text: Ops[i].Desc, fontSize: 10, bold: true, marginLeft: 10, marginTop: 5 }] });
                }
            }
            if (isTrue) {
                List.unshift({ text: 'Services :', fontSize: 12, marginTop: 5, bold: true, decoration: 'underline' });
            }
            return List;
        } else {
            return this.EmptyReturnValue();
        }
    }

    static EmptyReturnValue() {
        let Empty = '';
        return Empty;
    }

}