const formatLocalized = (template, ...args) => typeof template === 'string' ? template.replace(/\{(\d+)\}/g, (_, idx) => args[idx] ?? '') : '';

class App {
    constructor(envelopeKey, envelopeReceiver, documentBytes, licenseKey, locale, container) {
        this.container = container ?? `#${this.constructor.name.toLowerCase()}`;
        this.envelopeKey = envelopeKey
        this.pdfKit = null
        this.currentDocument = envelopeReceiver.envelope.documents[0]
        this.currentReceiver = envelopeReceiver.receiver
        this.signatureCount = envelopeReceiver.envelope.documents[0].elements.length;
        this.envelopeReceiver = envelopeReceiver;
        this.documentBytes = documentBytes;
        this.licenseKey = licenseKey;
        this.locale = locale;
    }

    async init() {
        // Load PSPDFKit
        this.pdfKit = await loadPSPDFKit(this.documentBytes, this.container, this.licenseKey, this.locale)
        addToolbarItems(this.pdfKit, this.handleClick.bind(this))

        this.pdfKit.addEventListener(
            'annotations.load',
            this.handleAnnotationsLoad.bind(this)
        )
        this.pdfKit.addEventListener(
            'annotations.change',
            this.handleAnnotationsChange.bind(this)
        )
        this.pdfKit.addEventListener(
            'annotations.create',
            this.handleAnnotationsCreate.bind(this)
        )

        this.pdfKit.addEventListener("annotations.willChange", _ => {
            Comp.ActPanel.Toggle();
        });

        // Load annotations into PSPDFKit
        this.signatureWidgets = [] // { pageIndex, boundingBox, id }
        if (!READ_AND_CONFIRM)
            try {
                let signatures = await createAnnotations(this.currentDocument, this.envelopeReceiver.envelopeId, this.envelopeReceiver.receiverId);
                await this.pdfKit.create(signatures);
                // Cache signature widget bounding boxes for stable frame placement
                this.signatureWidgets = signatures
                    .filter(s => s instanceof PSPDFKit.Annotations.WidgetAnnotation && s.formFieldName?.includes('signature'))
                    .map(s => ({ id: s.id, pageIndex: s.pageIndex, boundingBox: s.boundingBox.toJS() }))
            } catch (e) {
                console.error("Error loading annotations:", e);
            }

        //add click events of external buttons
        if (!READ_AND_CONFIRM) {
            [...document.getElementsByClassName('btn_refresh')].forEach(btn => btn.addEventListener('click', _ => this.handleClick('RESET')));
        }
        [...document.getElementsByClassName('btn_complete')].forEach(btn => btn.addEventListener('click', _ => this.handleClick('FINISH')));
        [...document.getElementsByClassName('btn_reject')].forEach(btn => btn.addEventListener('click', _ => this.handleClick('REJECT')));
    }

    handleAnnotationsLoad(loadedAnnotations) {
        loadedAnnotations.toJS()
    }

    handleAnnotationsChange() { }

    async handleAnnotationsCreate(createdAnnotations) {
        const annotation = createdAnnotations.toJS()[0]
        const isFormField = !!annotation.formFieldName
        const isSignature = !!annotation.isSignature

        if (isFormField === false && isSignature === true) {

            // Find the nearest signature widget on the same page to use its stable bounding box
            const inkBBox = annotation.boundingBox
            const samePageWidgets = this.signatureWidgets.filter(w => w.pageIndex === annotation.pageIndex)
            const nearestWidget = samePageWidgets.reduce((nearest, w) => {
                const dx = w.boundingBox.left - inkBBox.left
                const dy = w.boundingBox.top - inkBBox.top
                const dist = Math.sqrt(dx * dx + dy * dy)
                return dist < nearest.dist ? { dist, widget: w } : nearest
            }, { dist: Infinity, widget: null }).widget

            // 1. Remove widget background after signing
            if (nearestWidget) {
                const pageAnnots = await this.pdfKit.getAnnotations(annotation.pageIndex)
                const widgetAnnot = pageAnnots.find(a => a.id === nearestWidget.id)
                if (widgetAnnot)
                    await this.pdfKit.update(widgetAnnot.set('backgroundColor', PSPDFKit.Color.TRANSPARENT))
            }

            const bbox = nearestWidget?.boundingBox ?? inkBBox
            const left = bbox.left - 20
            const top  = bbox.top  - 12
            const width = 150
            const height = 75
            const timestamp = new Date()

            const imageUrl = await createAnnotationFrameBlob(
                this.envelopeReceiver.name,
                this.currentReceiver.signature,
                timestamp,
                width,
                height
            )

            const request = await fetch(imageUrl)
            const blob = await request.blob()
            const imageAttachmentId = await this.pdfKit.createAttachment(blob)

            const frameAnnotation = createImageAnnotation(
                new PSPDFKit.Geometry.Rect({
                    left: left,
                    top: top,
                    width: width,
                    height: height,
                }),
                annotation.pageIndex,
                imageAttachmentId,
                generateId(
                    this.envelopeReceiver.envelopeId,
                    this.envelopeReceiver.receiverId,
                    this.fakeElementId--,
                    'signed'
                )
            )

            this.pdfKit.create(frameAnnotation)
        }
    }

    async handleClick(eventType) {
        let result = false

        switch (eventType) {
            case 'RESET':
                result = await this.handleReset(null)
                Comp.SignatureProgress.SignedCount = 0;
                if (result.isConfirmed) {
                    Swal.fire({
                        title: localized.success,
                        text: localized.documentReset,
                        icon: 'info',
                    })
                }
                break;

            case 'FINISH':
                result = await this.handleFinish(null)

                if (result == true) {
                    // Redirect to success page after saving to database
                    window.location.href = `/Envelope/${this.envelopeKey}`
                }
                break;

            case 'REJECT':
                Swal.fire({
                    title: localized.rejection,
                    html: `<div class="text-start fs-6 p-0 m-0">${localized.rejectionReasonQ}</div>`,
                    icon: "question",
                    input: "text",
                    inputAttributes: {
                        autocapitalize: "off"
                    },
                    showCancelButton: true,
                    confirmButtonColor: "#3085d6",
                    cancelButtonColor: "#d33",
                    confirmButtonText: localized.complete,
                    cancelButtonText: localized.back,
                    showLoaderOnConfirm: true,
                    preConfirm: async (reason) => {
                        try {
                            var res = await rejectEnvelope(reason);
                            return res;
                        } catch (error) {
                            Swal.showValidationMessage(`
                          Request failed: ${error}
                        `);
                        }
                    },
                    allowOutsideClick: () => !Swal.isLoading()
                }).then((result) => {
                    if (!result.isConfirmed)
                        return;
                    const res = result.value;
                    if (res.ok) {
                        reload()
                    }
                    else
                        Swal.showValidationMessage(`Request failed: ${res.message}`);
                });
                break;
            case 'COPY_URL':
                const url = window.location.href.replace(/\/readonly/gi, '');
                navigator.clipboard.writeText(url).then(function () {
                    bsNotify(localized.copyLinkSuccess, { alert_type: 'success', delay: 4, icon_name: 'check_circle' });
                }).catch(function (err) {
                    bsNotify(localized.copyLinkFailure ?? localized.unexpectedErrorTitle, { alert_type: 'danger', delay: 4, icon_name: 'error' });
                });
                break;

            case 'SHARE':
                // Show the modal
                Comp.ShareBackdrop.show();
                break;
            case 'LOGOUT':
                await logout();
                break;
        }
    }

    async handleFinish(event) {

        let annotResult = undefined;

        // READ_AND_CONFIRM flow: require all pages viewed, skip annotation validations
        if (READ_AND_CONFIRM) {
            const allViewed = JSON.parse(sessionStorage.getItem('pspdf_all_pages_rendered') || 'false') === true
            if (!allViewed) {
                const unviewed = JSON.parse(sessionStorage.getItem('pspdf_unviewed_pages') || '[]')
                const message = unviewed.length
                    ? formatLocalized(localized.viewRemainingPages, unviewed.join(', '))
                    : localized.viewAllPages

                await Swal.fire({
                    title: localized.warning,
                    text: message,
                    icon: 'warning'
                })
                return false
            }
        }
        else {
            const iJSON = await this.pdfKit.exportInstantJSON()

            const iFormFieldValues = iJSON.formFieldValues;

            //check required
            const iReqFields = iFormFieldValues.filter(f => isFieldRequired(f))
            const hasEmptyReq = iReqFields.some(f => (f.value === undefined || f.value === null || f.value === ""))

            if (hasEmptyReq) {
                Swal.fire({
                    title: localized.warning,
                    text: localized.locationFieldsRequired,
                    icon: 'warning',
                })
                return false;
            }

            //check city
            const city_regex = new RegExp("^[a-zA-Z\\u0080-\\u024F]+(?:([\\ \\-\\']|(\\.\\ ))[a-zA-Z\\u0080-\\u024F]+)*$")
            const iCityFields = iFormFieldValues.filter(f => isCityField(f))
            for (var f of iCityFields)
                if (!IS_MOBILE_DEVICE && !city_regex.test(f.value)) {
                    Swal.fire({
                        title: localized.warning,
                        text: formatLocalized(localized.cityFormatInvalid, f.value),
                        icon: 'warning',
                    })
                    return false;
                }

            //check # of signature
            const validationResult = await this.validateAnnotations(this.signatureCount)
            if (validationResult === false) {
                Swal.fire({
                    title: localized.warning,
                    text: localized.missingSignatures,
                    icon: 'warning',
                })
                return false
            }

            // set annot-result if all validations passed
            annotResult = { instant: iJSON, structured: mapSignature(iJSON) };
        }

        return Swal.fire({
            title: localized.confirmation,
            html: `<div class="text-start fs-6 p-0 m-0">${READ_AND_CONFIRM ? localized.confirmAgree : localized.sigAgree}</div>`,
            icon: "question",
            showCancelButton: true,
            confirmButtonColor: "#3085d6",
            cancelButtonColor: "#d33",
            confirmButtonText: localized.finalize,
            cancelButtonText: localized.back
        }).then(async (result) => {
            if (result.isConfirmed) {
                //---
                // Save changes before doing anything
                try {
                    await this.pdfKit.save()
                } catch (e) {
                    Swal.fire({
                        title: localized.warning,
                        text: localized.envelopeSignError,
                        icon: 'error',
                    })
                    return false
                }

                // Export annotation data and save to database
                try {
                    const res = READ_AND_CONFIRM ? await signEnvelope() : await signEnvelope(annotResult);

                    if (!res.ok) {
                        if (res.status === 409) {
                            Swal.fire({
                                title: localized.warning,
                                text: localized.envelopeUnavailable,
                                icon: 'warning',
                            })
                            return false
                        }
                        else if (res.status === 423) {
                            Swal.fire({
                                title: localized.info ?? localized.warning,
                                text: localized.envelopeRejectedRedirect,
                                icon: 'info',
                                timer: 2000,
                                showConfirmButton: false
                            }).then(() => {
                                location.reload();
                            });
                        }
                        else {
                            throw new Error()
                        }
                    } else
                        return true
                } catch (e) {
                    Swal.fire({
                        title: localized.warning,
                        text: localized.envelopeSignError,
                        icon: 'error',
                    })
                    return false
                }
            }
            else
                return false;
        });
    }

    async validateAnnotations(totalSignatures) {
        const annotations = await getAnnotations(this.pdfKit)
        const filtered = annotations
            .map(a => a.toJS())
            .filter(a => a.isSignature)

        return totalSignatures <= filtered.length
    }

    async handleReset(event) {
        const result = Swal.fire({
            title: localized.resetConfirmTitle,
            text: localized.resetConfirmText,
            icon: 'question',
            showCancelButton: true
        })

        if (result.isConfirmed) {
            const result = await deleteAnnotations(this.pdfKit)
        }

        return result
    }

    fakeElementId = 0;
}