import { SharedPDFService } from '../../shared/shared-pdf.service';
import { MyDate } from '../../utils/my-date';
import { TrUtils } from '../../utils/tr-utils';
declare var pdfMake: any;
declare var document: any;

export class MeetingPdfService {

    static BodySize: number = 10;

    static MeetingPrintData(meetingData: any, isAgendata: boolean, EntityData: any) {
        let Images: any;
        SharedPDFService.convertImgToBase64URL(meetingData.image, function (base64Img: any) {
            Images = base64Img.toString();
        }, function (ntg: any) {
            Images = null;
        });
        setTimeout(() => {
            let dd = {
                info: {
                    title: 'Meeting',
                },
                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: [
                    this.HeaderContent(meetingData, isAgendata, Images),
                    SharedPDFService.HeaderAfterLine(),
                    this.GetMeetingDetails(meetingData, isAgendata),
                    SharedPDFService.HeaderAfterLine(),
                    {
                        stack: [{ text: 'Topics', bold: true, marginBottom: 7 }, this.GetTopicsAndSubTopicsAndItemsList(meetingData, meetingData.Items, isAgendata, EntityData.User.TZ)], marginTop: 10
                    },
                ],
                styles: SharedPDFService.GetStyles()
            };
            // return dd;
            pdfMake.createPdf(dd).open();

        }, 400)

    }

    static HeadingforMeeting(isAgendata: any) {
        if (isAgendata) {
            return { text: 'AGENDA', alignment: 'center', bold: true, fontSize: 16 }
        } else {
            return { text: 'MINUTES', alignment: 'center', bold: true, fontSize: 16 }
        }
    }

    static HeaderContent(meetingData: any, isAgendata: boolean, Images: any) {
        if (TrUtils.IsNull(Images)) {
            return { columns: [this.Header(meetingData, isAgendata)], width: '*', marginBottom: 5 };
        } else {
            return {
                columns: [{ image: Images, width: 40 * 1 },
                this.Header(meetingData, isAgendata),
                ], marginBottom: 5
            }
        }
    }

    static imageExists(image_url: any) {

        var http = new XMLHttpRequest();

        http.open('HEAD', image_url, false);
        http.send();

        return http.status != 404;

    }

    static Header(meetingData: any, isAgendata: boolean) {
        // let Title: any;
        // if (isAgendata) {
        //     Title = 'Agenda for ' + meetingData.Title;
        // } else {
        //     Title = 'Minutes of  ' + meetingData.Title;
        // }
        return { stack: [this.HeadingforMeeting(isAgendata), { text: '' + meetingData.Title + '', style: ['meetingHeader'], width: '*', marginTop: 5, alignment: 'center' }] };
    }

    static GetMeetingDetails(meetingData: any, isAgendata: boolean) {
        return {
            stack: [
                this.GetMeetingTimeDetails(meetingData, isAgendata),
            ]
        }

    }

    static GetMeetingTimeDetails(MeetingData: any, isAgendata: boolean) {
        let MeetingFields: any = [
            { name: 'Date and time', value: this.getDateAndTime(MeetingData) },
            { name: 'Location', value: MeetingData.Loc }
        ]
        if (isAgendata) {
            MeetingFields.push({ name: 'Participants', value: this.getParticipantsMembers(MeetingData.Members) });
            MeetingFields.push({ name: 'Optional', value: this.GetOptionalMembers(MeetingData.Members) });
            MeetingFields.push({ name: 'CC', value: this.getCCMembers(MeetingData.Members) });
        } else {
            MeetingFields.push({ name: 'Present', value: this.getPresentMembers(MeetingData.Members) });
            MeetingFields.push({ name: 'Absent', value: this.getAbsentMembers(MeetingData.Members) });
            MeetingFields.push({ name: 'CC', value: this.getCCMembersAndOptionalAbsent(MeetingData.Members) })
        }

        return this.GetDetails(MeetingFields);
    }

    static getPresentMembers(Members: any) {
        let Present: string = '';

        let ReqMembers: any = Members.filter((member: any) => {
            return (member.Type !== 'CC') && member.Att;
        });

        ReqMembers.forEach((member: any, Index: number) => {
            Present += member.Name;
            if (Index !== ReqMembers.length - 1) {
                Present += ', '
            }
        });

        return Present;
    }

    static getAbsentMembers(Members: any) {
        let Absent: string = '';

        let ReqMembers: any = Members.filter((member: any) => {
            return (member.Type !== 'CC' && member.Type !== 'OPT') && !member.Att;
        });

        ReqMembers.forEach((member: any, Index: number) => {
            Absent += member.Name;
            if (Index !== ReqMembers.length - 1) {
                Absent += ', '
            }
        });

        return Absent;
    }

    static getDateAndTime(MeetingData: any) {
        return MeetingData.StDate + ' to : ' + MeetingData.EnDate;
    }

    static getParticipantsMembers(Members: any) {
        let Invites: string = '';

        let ReqMembers: any = Members.filter((member: any) => {
            return member.Type === 'ORG' || member.Type === 'REQ';
        });

        ReqMembers.forEach((member: any, Index: number) => {
            Invites += member.Name;
            if (Index !== ReqMembers.length - 1) {
                Invites += ', '
            }
        });

        return Invites;
    }

    static GetOptionalMembers(Members: any) {
        let Invites: string = '';

        let ReqMembers: any = Members.filter((member: any) => {
            return member.Type === 'OPT';
        });

        ReqMembers.forEach((member: any, Index: number) => {
            Invites += member.Name;
            if (Index !== ReqMembers.length - 1) {
                Invites += ', '
            }
        });

        return Invites;
    }

    static getCCMembers(Members: any) {
        let Optional: string = '';

        let OptMembers: any = Members.filter((member: any) => {
            return member.Type === 'CC';
        });

        OptMembers.forEach((member: any, index: number) => {
            Optional += member.Name;
            if (index !== OptMembers.length - 1) {
                Optional += ', '
            }
        });

        return Optional;
    }

    static getCCMembersAndOptionalAbsent(Members: any) {
        let Optional: string = '';

        let OptMembers: any = Members.filter((member: any) => {
            return member.Type === 'CC' || (member.Type === 'OPT' && !member.Att);
        });

        OptMembers.forEach((member: any, index: number) => {
            Optional += member.Name;
            if (index !== OptMembers.length - 1) {
                Optional += ', '
            }
        });

        return Optional;
    }

    static GetDetails(data: any) {
        return {
            fontSize: this.BodySize,
            lineHeight: 1,
            // widths:['*','*',10],
            margin: 10,
            table: {
                body: this.GetDetailsTable(data)
            },
            layout: 'noBorders',
        };
    }

    static GetDetailsTable(data: any) {
        var body: any = [];
        data.forEach((row: any) => {
            if (!TrUtils.IsEmpty(row.value)) {
                var dataRow: any = [];
                dataRow.push({ text: (row.name).toString(), noWrap: true, bold: true });
                dataRow.push(':');
                dataRow.push({ text: (row.value).toString(), lineHeight: 1 });
                body.push(dataRow);
            } else {
                var a: any = [];
                a.push('');
                a.push('');
                a.push('');
                body.push(a);
            }
        });
        return body;
    }

    static GetTopicsAndSubTopicsAndItemsList(meetingData: any, items: any, isAgendata: boolean, TZ: any) {
        let tpcs: any = [];
        meetingData.Topics.forEach((tpc: any, index: any) => {
            let a: any;
            if (TrUtils.IsNull(tpc.Prt)) {
                a = { columns: [{ text: (index + 1) + ' . ', width: 20, marginTop: 5, marginBottom: 5, bold: true, fontSize: 12 }, { text: tpc.Desc, marginTop: 5, marginBottom: 5, bold: true, fontSize: 12 }] }
                tpcs.push(a);
                // tpcs.push({ stack: [this.SharedPrint.GetLightUnderLine(558, 'black')], marginLeft: 18 });
                if (!isAgendata) {
                    items.forEach((item: any) => {
                        if (item.Tpc === tpc._id) {
                            this.TopicsItemView(item, meetingData, tpcs, TZ);
                        }
                    });
                }

                tpc.SubTopics.forEach((subtpc: any, sindex: any) => {
                    let STopic: any = {
                        columns: [{ text: (index + 1 + '-' + (sindex + 1)) + ' . ', width: 25, bold: true, marginLeft: 20, marginTop: 10, marginBottom: 5, fontSize: 11 },
                        { text: subtpc.Desc, bold: true, marginLeft: 20, marginTop: 10, marginBottom: 5, fontSize: 11 }]
                    }
                    tpcs.push(STopic);
                    // tpcs.push({ stack: [this.SharedPrint.GetLightUnderLine(520, 'black')], marginLeft: 50 });
                    if (!isAgendata) {
                        items.forEach((item: any) => {
                            if (item.Tpc === subtpc._id) {
                                this.TopicsItemView(item, meetingData, tpcs, TZ);
                            }
                        });
                    }
                })

            }
        })
        return tpcs;
    }

    static TopicsItemView(item: any, meetingData: any, tpcs: any, TZ:any) {
        let ItemType: any = {
            text: this.GetTypeOfItem(item.Type), marginLeft: 20, marginBottom: 5, marginTop: 5, width: 50,
            color: this.GetColorsBasedOnType(item.Type), background: 'white', fontSize: this.BodySize,
        };
        let ItemDesc: any = this.GetDescrption(item, meetingData);
        let TaskAssignees: any = this.getAssignee(item, meetingData);
        let TaskDueDate: any = this.GetDueDate(item, meetingData, TZ);

        let Item: any;
        if (item.Type !== 'TAS') {
            Item = {
                columns: [ItemType, { text: ItemDesc, marginLeft: 2, marginTop: 6, marginBottom: 5, fontSize: this.BodySize }], marginTop: 5
            }
        } else {
            Item = {
                columns: [ItemType,
                    {
                        stack: [{ text: ItemDesc, marginLeft: 2, fontSize: this.BodySize },

                        ], marginTop: 6,
                    }], marginTop: 5
            }
            if (!TrUtils.IsEmpty(TaskAssignees)) {
                Item.columns[1].stack.push({
                    columns: [{ text: 'Assignee(s) ', color: 'magenta', width: 55, fontSize: this.BodySize, marginTop: 2 },
                    { text: TaskAssignees, fontSize: this.BodySize, marginTop: 2, marginBottom: 2 }]
                });
            }

            if (!TrUtils.IsEmpty(TaskDueDate)) {
                Item.columns[1].stack.push({
                    columns: [{ text: 'Due Date ', color: 'magenta', width: 55, fontSize: this.BodySize, marginTop: 2 },
                    { text: TaskDueDate, fontSize: this.BodySize, marginTop: 2, marginBottom: 5 }]
                })
            }
        }
        if (!TrUtils.IsEmpty(ItemDesc)) {
            tpcs.push(Item);
            tpcs.push({ stack: [SharedPDFService.GetLightUnderLine(525, 'lightgray')], marginLeft: 50 });
        }
    }

    static GetDescrption(Item: any, MeetingData: any) {
        if (Item.Type === 'TAS' && !TrUtils.IsNull(MeetingData.MeetingTasks)) {
            let Index: any = MeetingData.MeetingTasks.findIndex((task: any) => {
                return task._id === Item.T_Id;
            })
            if (Index !== -1) {
                return MeetingData.MeetingTasks[Index].Name;
            } else {
                return '';
            }
        } else {
            return Item.Desc;
        }
    }

    static GetDueDate(Item: any, MeetingData: any,TZ: any) {
        if (Item.Type === 'TAS' && !TrUtils.IsNull(MeetingData.MeetingTasks)) {
            let Index: any = MeetingData.MeetingTasks.findIndex((task: any) => {
                return task._id === Item.T_Id;
            })
            if (Index !== -1) {
                return TrUtils.IsNull(MeetingData.MeetingTasks[Index].EstEnDt) ? '' : MyDate.GetWeekAndDate(MeetingData.MeetingTasks[Index].EstEnDt, TZ);
            } else {
                return '';
            }
        } else {
            return '';
        }
    }

    static getAssignee(Item: any, MeetingData: any) {
        if (Item.Type === 'TAS' && !TrUtils.IsNull(MeetingData.MeetingTasks)) {
            let Index: any = MeetingData.MeetingTasks.findIndex((task: any) => {
                return task._id === Item.T_Id;
            })
            if (Index !== -1) {
                let Members: any = MeetingData.MeetingTasks[Index].Members.filter((member: any) => {
                    return !TrUtils.IsNull(member.Ass) && TrUtils.IsNull(member.EnDt);
                });
                let Ass: string = '';
                Members.forEach((member: any, index: any) => {
                    if (!TrUtils.IsNull(member.Ass)) {
                        Ass = Ass + member.Name;
                        if (index !== Members.length - 1) {
                            Ass = Ass + ', ';
                        }
                    }
                });
                return Ass;
            } else {
                return '';
            }
        } else {
            return '';
        }
    }

    static GetTypeOfItem(type: any) {
        if (type === 'NOT') {
            return 'Note';
        } else if (type === 'DEC') {
            return 'Desc';
        } else {
            return 'Task';
        }
    }

    static GetColorsBasedOnType(type: any) {
        if (type === 'NOT') {
            return '#b30000';
        } else if (type === 'DEC') {
            return 'blue';
        } else {
            return 'green';
        }

    }

}