// JavaScript Document
// Replaces libPDFscripts.js
// NEW - Process Scripts
// 
//  ** OFFICIAL SCRIPT TO USE WHEN IN PRODUCTION
//
// Function to add Authenticator validation https://www.npmjs.com/package/speakeasy
// Utility to fetch PDF bytes


console.log("LIBRARY: libProcessScript.js")






const dd = createDebugLogger(true, "dd"); // code function at bottom of the page



// Wrapper function to fetch, update, and download PDF
async function processAndDownloadPdf(filePath, ...dataSources) {
    console.log(filePath)
    try {
        const pdfBytes = await fetchPdfBytes(filePath);
        const updatedPdfBytes = await updatePdfFields(pdfBytes, dataSources);
        const fileName = generateRandomFilename(8, "ERT_", ".pdf");
        //const saveFilePath = await savePdfToFile(pdfBytes);
        //dd("[PDF PATH]", saveFilePath);
        downloadPdf(updatedPdfBytes, fileName);
    } catch (err) {
        dd("Error Processing PDF", err)
        //console.error("Error processing the PDF:", err);
    }
}

async function fetchPdfBytes(filePath) {


    try {
        const response = await fetch(filePath);
        if (!response.ok) throw new Error(`Failed to fetch PDF from ${filePath}`);
        return await response.arrayBuffer();
    } catch (err) {
        console.error("Error fetching PDF bytes:", err);
        throw err;
    }
}

// Update form fields in the PDF
async function updatePdfFields(
    pdfBytes,
    dataSources

) {
    console.log("Datasources Count:", dataSources.length)
    console.log(JSON.stringify(dataSources, null, 2));

    try {
        const pdfDoc = await PDFLib.PDFDocument.load(pdfBytes);
        const form = pdfDoc.getForm();

        dataSources.forEach((dataSource, dsIndex) => {
            console.log(`Processing dataSource[${dsIndex}]:`, dataSource);

            if (!Array.isArray(dataSource)) {
                console.warn(`dataSource[${dsIndex}] is not an array. Skipping.`);
                return;
            }

            dataSource.forEach((record, recIndex) => {
                console.log(`Processing record[${recIndex}]:`, record);

                if (!record || typeof record !== 'object') {
                    console.warn(`record[${recIndex}] is undefined or not an object. Skipping.`);
                    return;
                }

                // Extract numSection and pointValue dynamically or other 'key' components.
                const { numSection } = record;
                const pointValue = record.pointValue || record.Points;  // Fallback to Points if pointValue is missing


                if (numSection && pointValue) {
                    console.log(`Updating PDF field: ${numSection} with value: ${pointValue}`);

                    try {
                        // Use numSection as the dynamic field name
                        const formField = form.getTextField(numSection);

                        if (formField) {
                            formField.setText(String(pointValue));
                            console.log(`Field "${numSection}" updated with value "${pointValue}".`);
                        } else {
                            console.warn(`Field "${numSection}" not found in PDF.`);
                        }
                    } catch (err) {
                        console.error(`Error updating field "${numSection}":`, err);
                    }
                } else {
                    console.warn(`Missing numSection or pointValue in record[${recIndex}].`);
                }
            });
        });


        /**
        
                dataSources.forEach((dataSource) => {
                    //console.log("Current Datasource", dataSource)
                    dataSource.forEach((record) => {
                        console.log(record)
                        //console.log("Working in: ", record)
                        Object.entries(record).forEach(([fieldName, fieldValue]) => {
                            dd(`Field: ${fieldName}  Value: ${fieldValue}`) //debugger
                            try {
                                console.log(`----------------> form ${fieldName}`)
                                const formField = form.getTextField(fieldName);
                                if (formField) {
                                    // console.info(`Field "${fieldName}" OK`);
                                    dd(`${fieldName} --> ${fieldValue} OK`);
                                    formField.setText(String(fieldValue));
                                } else if (!skipMissingFields) {
                                    //dd(`Skipping Field: ${fieldName} NOT FOUND`)
                                    console.warn(`Field "${fieldName}" not found.`);
                                }
                            } catch (err) {
                                console.error(`Error updating field "${fieldName}":`); //console.error(`Error updating field "${fieldName}":`, err);
                            }
                        });
                    });
                });
        */
        // console.log(JSON.stringify(dataSources, null, 2));

        return await pdfDoc.save();
    } catch (err) {
        console.error("Error updating PDF fields:", err);
        throw err;
    }

}

// Function to trigger download of the updated PDF
function downloadPdf(pdfBytes, fileName) {
    const blob = new Blob([pdfBytes], { type: "application/pdf" });
    const url = URL.createObjectURL(blob);

    const link = Object.assign(document.createElement("a"), {
        href: url,
        download: fileName,
    });

    link.click();
    URL.revokeObjectURL(url); // Clean up the URL immediately
}

function generateRandomFilename(length = 8, prefix = "", suffix = "") {
    const characters =
        "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
    const array = Array.from({ length }, () =>
        characters.charAt(Math.floor(Math.random() * characters.length))
    );
    const filename = `${prefix}${array.join("")}${suffix}`;

    dd("Random Filename:", filename);
    return filename;
}

// Example Usage:




async function savePdfToFile(pdfBytes) {
    const randomFilename = generateRandomFilename(12, "", ".pdf");
    File.path;
    const filePath = Filehandle.path.join(__dirname, "PDF", randomFilename);
    dd("[SAVE TO DISK]", randomFilename);
    // Save the file to disk
    await fs.writeFile(filePath, Buffer.from(pdfBytes));

    // Return a URL or file path based on your server setup
    return `/PDF/${randomFilename}`;
}

function createDebugLogger(debug, prefix = "DD") {


    return function (message, ...optionalParams) {

        switch (debug) {
            case true:
                console.log(
                    `[${prefix}]`.toUpperCase(), `${message}`, ...optionalParams);
                break
        }
    };
}


function saveSignature_OFF() { //Testing a new function under dummyfunctions section
    const canvas = document.getElementById('signatureCanvas');
    const imageData = canvas.toDataURL('image/png');
    dd(imageData.length)
    // Trigger the server action and handle the response
    dmx.parse('serverconnect_sign.load({imageData: "' + imageData + '"})');
    //dmx.parse('serverconnect_sign.load({ image: imageData })');
    /** 
    dmx.parse('serverconnect_sign.load', { image: imageData }).then((response) => {
        //dmx.parse('serverconnect_sign.load({image: "' + imageData + '"})').then((response) => {
        const uploadedSignature = document.getElementById('uploadedSignature');
        uploadedSignature.src = response.fileUrl; // Use the file path returned from the server
        dd(response.fileUrl)
    }).catch((error) => {
        console.error("Error uploading signature:", error);
    });
*/
}


// ************** DUMMY TEST FUNCTIONS BELOW ******************  //

function runMyFunction() {
    //  alert("function run")
    let result = generateRandomIdentifier(9);
    // Use Wappler dmx.set to bind result to a Wappler variable if needed
    //<p>{{myResult}}</p>
    console.log(result)
    dmx.global.set('myResult', result);

}

function generateRandomIdentifier(v) {
    return generateRandomFilename(v)
}


function saveSignature() {
    const canvas = document.getElementById('signatureCanvas');
    const imageData = canvas.toDataURL('image/png'); // Convert the canvas to a Base64 image string
    dd("Got Signature:", imageData)

    dmx.parse('serverconnect_sign.load({image: "' + imageData + '"})').then((response) => {
        const uploadedSignature = document.getElementById('uploadedSignature');
        dd(uploadedSignature)
        dd("Response:", response.fileUrl)
        uploadedSignature.src = response.fileUrl; // Set the uploaded file URL to the image element

    }).catch((error) => {
        console.error("Error uploading signature:", error);
    });
}

function saveSignatureAsBase64() {
    //const canvas = document.getElementById('signatureCanvas');

    return document.getElementById('signatureCanvas').toDataURL('image/png'); // Get the Base64 string

}

function getSignatureData() {
    dmx.global.set('signatureDataEncoded', saveSignatureAsBase64())
    dd('SignatureData:', saveSignatureAsBase64())
}

function saveSignatureNew() {
    const canvas = document.getElementById('signatureCanvas');
    const imageData = canvas.toDataURL('image/png'); // Convert the canvas to a Base64 image string
    dd("Got Signature:", imageData)
    dmx.app.data.content.serverconnect_sign.__load({ imageData: imageData }).then((response) => {
        dd("Success:", response);
        const uploadedSignature = document.getElementById('uploadedSignature');
        dd(uploadedSignature, "Response:", response.fileUrl)
        uploadedSignature.src = response.fileUrl; // Set the uploaded file URL to the image element
    }).catch((error) => {
        console.error("Error:", error);
    });
}