////////////////////////////////////////////////
//let urlMp4 = "";
let subcategorias = [];
let categorias = [];

async function cleanLogsAll() {
    let username = localStorage.getItem('username');
    if (username === "jmab") {
        let lDelete = confirm('Esta a punto de eliminar registros obsoletos, desea continuar?')
        if (lDelete) {
            let lBorrado = confirm('Confirma la operación?')
            if (lBorrado) {
                try {
                    borrarPdfuser('log_pdf.json')
                    borrarRhbuser('log_rhb.json')
                    borrarLoginuser('log_login.json')
                    borrarLoginCst('log_login.json')
                    limpiarArchivo('log_login.json');
                    limpiarArchivo('log_encuesta.json');
                    limpiarArchivo('log_pdf.json');
                    limpiarArchivo('log_rhb.json');
                    limpiarArchivo('log_ubicacion.json');
                    limpiarArchivo('log_video.json');
                    limpiarArchivo('log_generico.json');
                } catch (error) {
                    console.error('Error:', error);
                }
            }
        }
    }
}
////////////////////////////////////////////
async function limpiarArchivo(archivo) {
    const confirmacion = confirm(`¿Esta a punto de depurar ${archivo}?`);
    if (!confirmacion) return;
    const res = await fetch(servidorURL + '/php/logs/php_limpiar_logs.php?t=' + new Date().getTime(), {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ archivo })
    });

    const result = await res.json();
    alert(result.message + (result.total_restantes !== undefined ? ` (${result.total_restantes} restantes)` : ''));
    return result;
}
/////////////////////////////////////////
async function borrarPdfuser(archivo) {
    let autor = "jmab";
    const res = await fetch(servidorURL + '/php/logs/php_delete_pdf_user.php?autor=' + autor, {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ archivo })
    });

    const result = await res.json();
    alert(result.message + (result.total_restantes !== undefined ? ` (${result.total_restantes} restantes)` : ''));
}

/////////////////////////////////////////
async function borrarRhbuser(archivo) {
    let autor = "jmab";
    const res = await fetch(servidorURL + '/php/logs/php_delete_rhb_user.php?autor=' + autor, {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ archivo })
    });
    const result = await res.json();
    alert(result.message + (result.total_restantes !== undefined ? ` (${result.total_restantes} restantes)` : ''));
}

/////////////////////////////////////////
async function borrarLoginuser(archivo) {
    let autor = "jmab";
    const res = await fetch(servidorURL + '/php/logs/php_delete_login_user.php?autor=' + autor, {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ archivo })
    });
    const result = await res.json();
    alert(result.message + (result.total_restantes !== undefined ? ` (${result.total_restantes} restantes)` : ''));
}
/////////////////////////////////////////
async function borrarLoginCst(archivo) {
    let autor = "cst";
    const res = await fetch(servidorURL + '/php/logs/php_delete_login_user.php?autor=' + autor, {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ archivo })
    });
    const result = await res.json();
    alert(result.message + (result.total_restantes !== undefined ? ` (${result.total_restantes} restantes)` : ''));
}
/////////////////////////////////////////
function loadScriptapp(urlScr) {
    return new Promise((resolve, reject) => {
        const script = document.createElement('script');
        script.src = urlScr;
        script.async = true;
        script.onload = () => resolve();
        script.onerror = () => reject(new Error(`Failed to load script: ${urlScr}`));
        document.head.appendChild(script);
    });
}

async function obtenerImagenes() {
    try {
        // Realizar la solicitud al servidor para obtener la lista de archivos

        const url = servidorURL + '/php/pdf/php_img.php?t=' + new Date().getTime();  // 11111111111111111111111111111111111111111111
        console.info(url);
        const response = await fetch(url);
        // Verificar si la respuesta es exitosa
        if (!response.ok) {
            throw new Error('Error al obtener la lista de archivos.');
        }
        // Parsear la respuesta JSON
        const data = await response.json();
        //console.info(data)
        // Verificar si hay un error en los datos recibidos
        if (data.error) {
            throw new Error(data.error);
        }
        // Almacenar la respuesta en una variable
        const files = data.files;  // 11111111111111111111111111111111111111111111111111
        //console.info(files);

        let tmp = await toClientes(files)
        let Objeto = JSON.stringify(tmp);
        localStorage.setItem("ClaveCreator", Objeto);
        //console.info(Objeto)
    } catch (error) {
        alert("Los datos no se han cargado, cierre la pagina y vuelva a abrir la aplicación")
        //window.open('../index.html', '_self');
        console.error('Error:', error.message);
    }
}
//////////////////////////////

async function obtenerCatalogo() {
    try {
        // Realizar la solicitud al servidor para obtener la lista de archivos
        ////////////////////////////////////////////////
        const urlCat = servidorURL + '/php/pdf/php_img_clasifica.php?t=' + new Date().getTime(); // 2222222222222222222222222222222222222
        //console.info(urlCat);
        const responseCat = await fetch(urlCat);
        // Verificar si la respuesta es exitosa
        if (!responseCat.ok) {
            throw new Error('Error al obtener la lista de archivos.');
        }
        // Parsear la respuesta JSON
        const dataCat = await responseCat.json();
        //console.info(dataCat)
        // Verificar si hay un error en los datos recibidos
        if (dataCat.error) {
            throw new Error(dataCat.error);
        }
        // Almacenar la respuesta en una variable
        localStorage.setItem('catalogo', JSON.stringify(dataCat));
        //console.log('Catálogo guardado en localStorage:', dataCat);

        //const json = JSON.stringify(filesCat);

        //localStorage.setItem("catalogo", json);
        ////////////////////////////////////////
        // Array con nombres de las imágenes
        /*const imagenesArray = dataCat;
        // Objeto donde se almacenarán las imágenes clasificadas
        const imagenes = {};
        // Función para agregar imagen a la estructura de datos
        function agregarImagen(categoria, segmento, tipo, nombreImagen) {
            if (!imagenes[categoria]) imagenes[categoria] = {};
            if (!imagenes[categoria][segmento]) imagenes[categoria][segmento] = {};
            if (!imagenes[categoria][segmento][tipo]) imagenes[categoria][segmento][tipo] = [];
            imagenes[categoria][segmento][tipo].push(nombreImagen);
        }
        // Iterar sobre cada imagen y clasificarla
        imagenesArray.forEach(nombreImagen => {
            // Extraer la categoría, segmento y tipo del nombre de la imagen
            const partes = nombreImagen.split('_'); // Divide por guion bajo "_"
            const codigo = partes[0];               // Código principal (e.g., "117")
            const categoria = parseInt(codigo[0]) * 100;   // Centenas (e.g., 100, 200)
            const segmento = parseInt(codigo.slice(0, 3)); // Decenas y centenas (e.g., 110, 120, etc.)
            const tipo = parseInt(codigo[2]);              // Unidades (e.g., 1, 2, etc.)
            // Llamar a la función para agregar la imagen a la estructura
            agregarImagen(categoria, segmento, tipo, nombreImagen);
        });
        // Mostrar la estructura final
        localStorage.setItem("catalogo", imagenes);
        console.log(imagenes);
        */
    } catch (error) {
        alert("Los datos no se han cargado, cierre la pagina y vuelva a abrir la aplicación")
        //window.open('../index.html', '_self');
        console.error('Error:', error.message);
    }
}
/////////////////////////////////
async function obtenerImagenesLite() {
    try {
        // Generar la URL para la solicitud
        const url = servidorURL + '/php/pdf/php_img.php?t=' + new Date().getTime();
        console.info("Solicitando desde: ", url);

        // Realizar la solicitud al servidor para obtener la lista de archivos
        const response = await fetch(url);

        // Verificar si la respuesta es exitosa
        if (!response.ok) {
            throw new Error('Error al obtener la lista de archivos: ' + response.statusText);
        }

        // Parsear la respuesta JSON
        const data = await response.json();

        // Verificar si la respuesta JSON tiene un error
        if (data.error) {
            throw new Error('Error en los datos: ' + data.error);
        }

        // Almacenar los archivos recibidos en una variable
        const files = data.files;

        // Verificar si los archivos son válidos
        if (!Array.isArray(files)) {
            throw new Error('La respuesta no contiene una lista válida de archivos.');
        }

        // Convertir los archivos a clientes (esto es un ejemplo, asegúrate de que 'toClientes' maneje errores)
        let tmp = await toClientes(files);

        // Comprobar si tmp tiene un valor válido
        if (!tmp) {
            throw new Error('La conversión a clientes falló.');
        }

        // Convertir el objeto a una cadena JSON y almacenarlo en localStorage
        const Objeto = JSON.stringify(tmp);

        // Verificar si se pueden guardar datos en localStorage (tamaño, tipo de datos)
        if (Objeto.length > 5000000) { // ejemplo de límite arbitrario de tamaño
            throw new Error('El objeto es demasiado grande para almacenarlo en localStorage.');
        }

        localStorage.setItem("ClaveCreator", Objeto);
        console.info("Datos guardados en localStorage.");

    } catch (error) {
        // Mostrar un mensaje de error al usuario
        alert("Los datos no se han cargado correctamente. Cierre la página y vuelva a abrir la aplicación.");
        console.error('Error en la solicitud:', error.message);
    }
}
/////////////////////////////


async function initJson() {

    //let urlpdf = "./json/pdf.json"
    //pdfs = await (await fetch(urlpdf)).json();
    //localStorage.setItem("pdfs", JSON.stringify(pdfs));
    //console.info(pdfs)

    let urlgen = "./json/genericos.json"
    genericos = await (await fetch(urlgen)).json();
    localStorage.setItem("genericos", JSON.stringify(genericos));

    let urlseg = "./json/categorias.json"
    categorias = await (await fetch(urlseg)).json();
    localStorage.setItem("categorias", JSON.stringify(categorias));

    let urltec = "./json/subcategorias.json"
    subcategorias = await (await fetch(urltec)).json();
    localStorage.setItem("subcategorias", JSON.stringify(subcategorias));

    /*let urlprot = "./json/protocolos.json"
    protocolos = await (await fetch(urlprot)).json();
    localStorage.setItem("protocolos", JSON.stringify(protocolos));

    let url1 = "./json/tecinmo.json"
    tecinmo = await (await fetch(url1)).json();
    localStorage.setItem("tecinmo", JSON.stringify(tecinmo));

    let url2 = "./json/tecdeambu.json"
    tecdeambu = await (await fetch(url2)).json();
    localStorage.setItem("tecdeambu", JSON.stringify(tecdeambu));

    let url3 = "./json/tectmp.json"
    tectmp = await (await fetch(url3)).json();
    localStorage.setItem("tectmp", JSON.stringify(tectmp));

    let url4 = "./json/tecelec.json"
    tecelec = await (await fetch(url4)).json();
    localStorage.setItem("tecelec", JSON.stringify(tecelec));

    let url5 = "./json/tectermo.json"
    tectermo = await (await fetch(url5)).json();
    localStorage.setItem("tectermo", JSON.stringify(tectermo));

    let url6 = "./json/tecclas.json"
    tecclas = await (await fetch(url6)).json();
    localStorage.setItem("tecclas", JSON.stringify(tecclas));

    let url7 = "./json/tecval.json"
    tecval = await (await fetch(url7)).json();
    localStorage.setItem("tecval", JSON.stringify(tecval));*/

    //console.info(JSON.parse(localStorage.getItem("usuarios")));

}

async function listadosImagenes() {
    try {
        // Realizar la solicitud al servidor para obtener la lista de archivos

        const url = servidorURL + '/php/pdf/php_img.php?t=' + new Date().getTime();
        //const response = await fetch('php/php_img.php?t=' + new Date().getTime());
        const response = await fetch(url);
        // Verificar si la respuesta es exitosa
        if (!response.ok) {
            throw new Error('Error al obtener la lista de archivos.');
        }
        // Parsear la respuesta JSON
        const data = await response.json();

        // Verificar si hay un error en los datos recibidos
        if (data.error) {
            throw new Error(data.error);
        }
        // Almacenar la respuesta en una variable
        const files = data.files;
        console.info(files)
    } catch (error) {
        console.error('Error:', error.message);
    }
}

async function listadosPdfs() {
    try {
        // Realizar la solicitud al servidor para obtener la lista de archivos

        const url = servidorURL + '/php/pdf/php_pdf.php?t=' + new Date().getTime();
        //const response = await fetch('php/php_pdf.php?t=' + new Date().getTime());
        const response = await fetch(url);

        // Verificar si la respuesta es exitosa
        if (!response.ok) {
            throw new Error('Error al obtener la lista de archivos.');
        }
        // Parsear la respuesta JSON
        const data = await response.json();

        // Verificar si hay un error en los datos recibidos
        if (data.error) {
            throw new Error(data.error);
        }
        // Almacenar la respuesta en una variable
        const files = data.files;
    } catch (error) {
        console.error('Error:', error.message);
    }
}

async function listadosVideos() {
    try {
        // Realizar la solicitud al servidor para obtener la lista de archivos

        const url = servidorURL + '/php/pdf/php_mp4.php?t=' + new Date().getTime();
        const response = await fetch(url);
        //const response = await fetch('php/php_mp4.php?t=' + new Date().getTime());

        // Verificar si la respuesta es exitosa
        if (!response.ok) {
            throw new Error('Error al obtener la lista de archivos.');
        }
        // Parsear la respuesta JSON
        const data = await response.json();

        // Verificar si hay un error en los datos recibidos
        if (data.error) {
            throw new Error(data.error);
        }
        // Almacenar la respuesta en una variable
        const files = data.files;
        console.info(files)
    } catch (error) {
        console.error('Error:', error.message);
    }
}

async function listadosWords() {
    try {
        // Realizar la solicitud al servidor para obtener la lista de archivos

        const url = servidorURL + '/php/pdf/php_word.php?t=' + new Date().getTime();
        //const response = await fetch('php/php_word.php?t=' + new Date().getTime());
        const response = await fetch(url);

        // Verificar si la respuesta es exitosa
        if (!response.ok) {
            throw new Error('Error al obtener la lista de archivos.');
        }
        // Parsear la respuesta JSON
        const data = await response.json();

        // Verificar si hay un error en los datos recibidos
        if (data.error) {
            throw new Error(data.error);
        }
        // Almacenar la respuesta en una variable
        const files = data.files;
        console.info(files)
    } catch (error) {
        console.error('Error:', error.message);
    }
}
async function listadosPdfImg() {
    try {
        // Realizar la solicitud al servidor para obtener la lista de archivos

        const url = servidorURL + '/php/pdf/php_pdftoimage.php?t=' + new Date().getTime();
        //const response = await fetch('php/php_pdf.php?t=' + new Date().getTime());
        const response = await fetch(url);

        // Verificar si la respuesta es exitosa
        if (!response.ok) {
            throw new Error('Error al obtener la lista de archivos.');
        }
        // Parsear la respuesta JSON
        const data = await response.json();

        // Verificar si hay un error en los datos recibidos
        if (data.error) {
            throw new Error(data.error);
        }
        // Almacenar la respuesta en una variable
        const files = data.files;
        console.info(files)
    } catch (error) {
        console.error('Error:', error.message);
    }
}
/////////////////////////////////////////

async function obtenerPngs() {
    try {
        // Realizar la solicitud al servidor para obtener la lista de archivos

        const url = servidorURL + '/php/pdf/php_pdftoimage.php?t=' + new Date().getTime();
        //const response = await fetch('php/php_pdf.php?t=' + new Date().getTime());
        const response = await fetch(url);

        // Verificar si la respuesta es exitosa
        if (!response.ok) {
            throw new Error('Error al obtener la lista de archivos.');
        }
        // Parsear la respuesta JSON
        const data = await response.json();

        // Verificar si hay un error en los datos recibidos
        if (data.error) {
            throw new Error(data.error);
        }
        // Almacenar la respuesta en una variable
        const files = data.files;
        //console.info(files)
        let Objeto = JSON.stringify(files);
        localStorage.setItem("ClavePng", Objeto);
        //console.info(Objeto)

        ///////////////////////////////////
        let filesPdf = JSON.parse(localStorage.getItem("ClavePdf"));
        let filesArr = JSON.parse(localStorage.getItem("ClavePng"));
        //console.info(filesArr)
        for (let i = 0; i < filesPdf.length; i++) {
            let filePdf = filesPdf[i].titulo;
            let filePng = filePdf.slice(0, filePdf.length - 4) + ".png";
            //console.info(filePng)
            //console.info(filePdf)
            //console.info(filePng)
            const fileExists = filesArr.includes(filePng); //checkFileExistsInArray(filePng, filesArr);
            if (fileExists) {
                console.log("El archivo existe en el array.");
            } else {
                pdfToImage(filePdf);
                console.log("El archivo no existe en el array.");
            }
        }
        ////////////////////////////////////
    } catch (error) {
        console.info("ERROR")
        console.error('Error:', error.message);
    }
}

////////////////////////////////////////////
async function obtenerPdfs() {
    try {
        // Realizar la solicitud al servidor para obtener la lista de archivos

        const url = servidorURL + '/php/pdf/php_pdf.php?t=' + new Date().getTime();
        const response = await fetch(url);
        //const response = await fetch('php/php_pdf.php?t=' + new Date().getTime());
        console.info(servidorURL)

        // Verificar si la respuesta es exitosa
        if (!response.ok) {
            throw new Error('Error al obtener la lista de archivos.');
        }
        // Parsear la respuesta JSON
        const data = await response.json();
        //console.info(data)

        // Verificar si hay un error en los datos recibidos
        if (data.error) {
            throw new Error(data.error);
        }
        // Almacenar la respuesta en una variable
        const files = data.files; //JSON.stringify(data, null, 2); //
        //console.info(files)
        let tmp = await toPdf(files)
        console.info(tmp)
        let Objeto = JSON.stringify(tmp);
        localStorage.setItem("ClavePdf", Objeto);
        window.recargarMenuPdfs?.();

    } catch (error) {
        console.error('Error:', error.message);
    }
}
////////////////////////////////////////
function clientesNew2(id, generico, ngenerico, path, word, nombre, titulo, pathpdf, pdfEjer, radi, activo, menu, imagen) {
    this.id = id
    this.generico = generico
    this.ngenerico = ngenerico
    this.path = path
    this.word = word
    this.nombre = nombre // "flex_ext_codo_palo.jpg",
    this.titulo = titulo // "111flex_ext_codo_palo.jpg",
    this.pathpdf = pathpdf // 
    this.pdfEjer = pdfEjer // 
    this.radi = radi
    this.activo = activo
    this.menu = menu //120
    this.imagen = imagen
}
//////////////////////////////////////////////////

async function toPdf(result) {
    let genericos = JSON.parse(localStorage.getItem("genericos"));
    //let pdfs = JSON.parse(localStorage.getItem("pdfs"));
    let pos = 0;
    let datos = [];
    let clients = [];
    let texto = ""
    for (let i = 0; i < result.length; i++) {
        let inicio = result[i] //result[i].name
        //console.info(inicio)
        if (parseInt(inicio.slice(0, 4)) > 1000) {
            //clients.push(new clientes(result[i].name))
            //////////////////////////////
            let nPdf = parseInt(inicio.slice(0, 1));
            let ngenerico = genericos[nPdf - 1].genericosNum;
            let generico = genericos[nPdf - 1].genericos;

            let nameIni = inicio;
            let name = nameIni;
            name = name.slice(0, name.indexOf("."));
            //console.info(nameIni)
            let numero = nameIni.slice(0, 4);
            let id = pos;
            let pathimg = servidorURL + "/assets/cstpdfimg/" + nameIni; //
            let path = servidorURL + "/assets/cstpdf/" + nameIni; //
            let pathWord = servidorURL + "/assets/cstword/" + nameIni; //
            let word = pathWord.slice(0, pathWord.length - 3) + "docx"
            let imagen = pathimg.slice(0, pathimg.length - 3) + "png"
            //let nombre = valredux.slice(8, valredux.length) // "flex_ext_codo_palo.jpg",
            let titulo = nameIni // "111_flex_ext_codo_palo.jpg",
            let pathpdf = path;
            let remplaza = /_+/gi;
            name = name.replace(remplaza, " ");
            let nombre = name.slice(5, name.length)
            let radi = 0
            let activo = 1
            let menu = parseInt(numero) //120

            let pdfEjer = "";
            //console.info(pdfs)
            //let n = pdfs.findIndex(numero => numero.pdfNum === menu);
            //console.info(n)
            //console.info(menu)
            //if (n >= 0) pdfEjer = pdfs[n].pdfName;
            //console.info(pdfEjer)

            clients.push(new clientesNew2(id, generico, ngenerico, path, word, nombre, titulo, pathpdf, pdfEjer, radi, activo, menu, imagen))
            //console.log(clients[pos])
            pos++
            //console.info(titulo)
            /////////////////////////////////
        }
    }
    for (let i = 0; i < clients.length; i++) {
        let dict = {}
        dict['id'] = clients[i].id
        dict['generico'] = clients[i].generico
        dict['ngenerico'] = clients[i].ngenerico
        dict['path'] = clients[i].path
        dict['word'] = clients[i].word
        dict['nombre'] = clients[i].nombre
        dict['titulo'] = clients[i].titulo
        dict['pathpdf'] = clients[i].pathpdf
        dict['pdfEjer'] = clients[i].pdfEjer
        dict['activo'] = clients[i].activo
        dict['menu'] = clients[i].menu
        dict['radi'] = clients[i].radi
        dict['imagen'] = clients[i].imagen
        datos[i] = dict
        //console.info(dict)
    }
    let textos = datos //JSON.stringify(datos);
    //console.info(textos)
    return textos;
}

//////////////////////////////////////////////////////////

function sendImageToServer(imgData, filename) {

    const xhr = new XMLHttpRequest();
    xhr.open('POST', servidorURL + '/php/pdf/php_pdfimg.php?t=' + new Date().getTime(), true);
    xhr.setRequestHeader('Content-Type', 'application/json');
    xhr.onreadystatechange = function () {
        if (xhr.readyState == 4 && xhr.status == 200) {
            console.log(xhr.responseText);
            obtenerPdfs();
        }
    };
    xhr.send(JSON.stringify({ image: imgData, filename: filename }));
}
///////////////////////////////////////////
async function pdfToImage(newUrlPdf) {

    //pdfjsLib.GlobalWorkerOptions.workerSrc = 'https://cdnjs.cloudflare.com/ajax/libs/pdf.js/2.14.305/pdf.worker.min.js';
    pdfjsLib.GlobalWorkerOptions.workerSrc = '../js/pdf.worker.min.js';

    const url = servidorURL + `/php/pdf/php_get_pdf.php?pdf_name=${encodeURIComponent(newUrlPdf)}`;

    pdfjsLib.getDocument(url).promise.then(pdf => {
        // Fetch the first page
        //loadData();
        pdf.getPage(1).then(page => {
            const viewport = page.getViewport({ scale: 0.60 });
            const canvas = document.createElement('canvas');
            const context = canvas.getContext('2d');
            canvas.height = viewport.height;
            canvas.width = viewport.width;

            // Render PDF page into canvas context
            const renderContext = {
                canvasContext: context,
                viewport: viewport
            };
            page.render(renderContext).promise.then(() => {
                //console.log('Page rendered');
                // Convert the canvas to an image
                const imgData = canvas.toDataURL('image/png');
                let filename = newUrlPdf.slice(0, newUrlPdf.length - 4)
                console.info(filename)
                sendImageToServer(imgData, filename);
            });
        });
    });
}
//////////////////////////////////////////////////////////

// Abrir o crear una base de datos en IndexedDB
function initBD() {
    const request = indexedDB.open('pefirDB', 1);

    request.onupgradeneeded = function (event) {
        const db = event.target.result;
        // Crear un almacén de objetos (Object Store) si no existe
        if (!db.objectStoreNames.contains('dbtimg')) {
            db.createObjectStore('dbtimg', { keyPath: 'id', autoIncrement: true });
        }

        // Crear un almacén de objetos (Object Store) si no existe
        if (!db.objectStoreNames.contains('dbtpdf')) {
            db.createObjectStore('dbtpdf', { keyPath: 'id', autoIncrement: true });
        }

        /* // Crear un almacén de objetos (Object Store) si no existe
         if (!db.objectStoreNames.contains('dbtpng')) {
            db.createObjectStore('dbtpng', { keyPath: 'id', autoIncrement: true });
        }*/
    };

    request.onsuccess = function (event) {
        const db = event.target.result;

        const imgString = localStorage.getItem('ClaveCreator');
        if (imgString) {
            const claveimg = JSON.parse(imgString);

            // Llamar a la función para agregar los datos a IndexedDB
            agregarDatosAIndexedDB(db, claveimg, 'dbtimg');
        }

        // Verificar si existen datos en localStorage
        const pdfString = localStorage.getItem('ClavePdf');
        if (pdfString) {
            const clavepdf = JSON.parse(pdfString);

            // Llamar a la función para agregar los datos a IndexedDB
            agregarDatosAIndexedDB(db, clavepdf, 'dbtpdf');
        }

        /*const pngString = localStorage.getItem('ClavePng');
        if (pngString) {
            const clavepng = JSON.parse(pngString);

            // Llamar a la función para agregar los datos a IndexedDB
            agregarDatosAIndexedDB(db, clavepng, 'dbtpng');
        }*/
    };

    request.onerror = function (event) {
        console.error('Error al abrir la base de datos:', event.target.errorCode);
    };
}
///////////////////////////////////////
function agregarDatosAIndexedDB(db, clavedb, dbt) {
    const transaction = db.transaction(dbt, 'readwrite');
    const store = transaction.objectStore(dbt);

    clavedb.forEach((dbindex, index) => {
        store.put(dbindex);
    });

    transaction.oncomplete = function () {
        console.log('Datos guardados en IndexedDB');
    };

    transaction.onerror = function (event) {
        console.error('Error al guardar los datos:', event.target.errorCode);
    };
}
///////////////////////////////////////

async function fetchImageAsBase64(name) {
    let base64Image;
    try {

        const url = servidorURL + `/php/pdf/php_get_image.php?image_name=${encodeURIComponent(name)}`;

        // Obtener la imagen como un Blob
        const response = await fetch(url);
        if (!response.ok) {
            throw new Error('Error al obtener la imagen.');
        }
        const blob = await response.blob();
        // Leer el blob como una data URL (base64)
        base64Image = await readBlobAsDataURL(blob);
    } catch (error) {
        console.error('Error:', error);
    }
    return base64Image;
}

function readBlobAsDataURL(blob) {
    return new Promise((resolve, reject) => {
        const reader = new FileReader();
        reader.onloadend = function () {
            resolve(reader.result);
        };
        reader.onerror = function (error) {
            reject(error);
        };
        reader.readAsDataURL(blob);
    });
}
async function gotoImagenes(imagenes) {
    console.info(imagenes)
    let num = imagenes.split("?");
    let nameEjercicios = imagenes; //imagenes.slice(0, imagenes.length);
    let mainMenus = JSON.parse(localStorage.getItem("ClaveCreator"));
    console.info(mainMenus)
    let arrayTmp = []
    arrayTmp = nameEjercicios.split(",");
    let nameTmp = "";
    console.info(arrayTmp)
    if (arrayTmp.length > 1) {
        for (let i = 1; i < arrayTmp.length; i++) {
            let nImag = mainMenus.findIndex(item => item.ordenOri == arrayTmp[i]);
            if (nImag === -1) continue; // imagen borrada, se omite
            arrayTmp[i] = mainMenus[nImag].titulo;
            nameTmp = nameTmp + "," + arrayTmp[i]
        }
        nameEjercicios = nameTmp;
    }
    console.info(nameEjercicios)
    localStorage.setItem('pdfEjercicios', nameEjercicios);
}

////////////////////////////////////////////
async function leerYAbrirURL2(txtUrl, doc, rectXp, rectYp, imgWidth, imgHeight) {

    // URL del archivo .txt en el servidor
    const archivoURL = txtUrl;  // Cambia esto por la URL de tu archivo
    console.info(txtUrl)
    // Usamos fetch() para obtener el contenido del archivo .txt
    await fetch(archivoURL)
        .then(response => {
            if (!response.ok) {
                throw new Error('No se pudo obtener el archivo');
            }
            return response.text();  // Leemos el archivo como texto
        })
        .then(contenido => {
            const urlTxt = contenido.trim(); // Extraemos la URL y quitamos espacios innecesarios

            // Verificamos si el contenido es una URL válida
            if (isValidUrl(urlTxt)) {
                console.log('URL extraída:', urlTxt);
                doc.link(rectXp, rectYp, imgWidth, imgHeight, { url: urlTxt }); //
                //return urlTxt;
                //window.open(url, '_blank');  // Abrimos la URL en una nueva ventana
            } else {
                //urlTxt = "";
                alert('El archivo no contiene una URL válida');
                //return txtUrl;
            }
            //return urlTxt;
        })
        .catch(error => {
            console.error('Error al leer el archivo:', error);
            alert('Hubo un error al leer el archivo');
        });

}

// Función para verificar si la URL es válida (básica)
function isValidUrl(url) {
    const regex = /^(http|https):\/\/[^\s/$.?#].[^\s]*$/i;
    return regex.test(url);
}
///////////////////////////////////