

let pC = false;
let hard = "";
let tituloPdf = "";
//let divIframe = 0;
let arrPdf = [];
let pdfImage;
let imagenDatos = []
let dataImages = []
//let conexion = "";
let arraymp4Total = []
const imagesArray = [];

let fechaFin;
/////////////////////////////////////////////////////////
let password = "";
let user = "cst";
let uid = "";
let lOpen = false;
let lLoadProtocolo = false;
//let output;
//let initMainMenu = 0;
let idatos = 0;
let stringPdf = "";
//let datos = []
let findDatos = []
//let clients = []
let mainMenu = [];
let mainPdf = [];
let mainUpload = [];
//let menuSegmT = [];
let numNivelFinal = 0;
let nOpen = 0;
let pdfMailBase64 = "";
let nameFile = "exercicis.pdf";
//let clienteTo = "pdfrhb@gmail.com";
//let clienteTo = "abeciabuil@gmail.com";
let blocDevice = false;
let resizeManual = false;
let returPage = false;
//let deviceOrientation = "";
///////////////////////////////////
let nameComputer = "0000";
let pass = "";
let lPass = false;
//anulado let tiempoBase = 3;
///////////////////////////////////
let img;

//let pdfs = [];
//let subcategorias = [];
//let categorias = [];
let genericos = [];
//let protocolos = [];

//let tecinmo = [];
//let tecdeambu = [];
//let tectmp = [];
//let tectermo = [];
//let tecval = [];
//let tecelec = [];
//let tecclas = [];
//let usuarios = [];

let arrfileListImg = [];
let arrfileListMp4 = [];

let findsubcategorias = [];
let selectcategorias = [];
//////////////////////////////////////////

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);
  });
}

function createMetaTag() {
  let meta = createElement('meta');
  meta.attribute('name', 'viewport');
  meta.attribute('content', 'user-scalable=no,initial-scale=1,maximum-scale=1,minimum-scale=1,width=device-width,height=device-height');
  let head = select('head');
  meta.parent(head);
}

function matrix(rows, cols, defaultValue) {
  let arr = [];
  // Creates all lines:
  for (let i = 0; i < rows; i++) {
    // Creates an empty line
    arr.push([]);
    // Adds cols to the empty line:
    arr[i].push(new Array(cols));
    for (let j = 0; j < cols; j++) {
      // Initializes:
      arr[i][j] = defaultValue;
    }
  }
  return arr;
}

//////////////////////////////////
/*function initGroupTermo() {
  tectermo = matrix(1, 1, ''); // 2 lines, 3 cols filled with empty string
}
function initGroupElec() {
  tecelec = matrix(1, 1, ''); // 2 lines, 3 cols filled with empty string
}
function initGroupTmp() {
  tectmp = matrix(1, 1, ''); // 2 lines, 3 cols filled with empty string
}
function initGroupDeambu() {
  tecdeambu = matrix(1, 1, ''); // 2 lines, 3 cols filled with empty string
}
function initGroupInmo() {
  tecinmo = matrix(1, 1, ''); // 2 lines, 3 cols filled with empty string
}
function initGroupVal() {
  tecval = matrix(1, 1, ''); // 2 lines, 3 cols filled with empty string
}*/
///////////////////////////////////////
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;
      arrayTmp[i] = mainMenus[nImag].titulo;
      nameTmp = nameTmp + "," + arrayTmp[i]
    }
    nameEjercicios = nameTmp; //nameTmp.slice(0, nameTmp.length - 1)
  }
  console.info(nameEjercicios)
  localStorage.setItem('pdfEjercicios', nameEjercicios);
}

//////////////////////////////////////////////////
function numseg(num) {
  let segment = JSON.parse(localStorage.getItem("categorias"));
  let n = segment.findIndex(numero => numero.categoriasNum === num);
  return n
}
function nameseg(num) {
  let segment = JSON.parse(localStorage.getItem("categorias"));
  let n = segment.findIndex(numero => numero.categoriasNum === num);
  //console.info(num)
  //console.info(categorias[n].categorias)
  return segment[n].categorias
}

function namegen(num) {
  let generic = JSON.parse(localStorage.getItem("genericos"));
  let n = generic.findIndex(numero => numero.genericosNum === num);
  //console.info(num)
  //console.info(categorias[n].categorias)
  return generic[n].genericos
}

function plusOptionSegIni(num) {
  let n = mainMenu.findIndex(numero => numero.segmnum === num);
  if (n != -1) return true
  else return false
}

function plusOptionGenIni(num) {
  let n = pdfMainMenu.findIndex(numero => numero.menu === num);
  if (n != -1) return true
  else return false
}
/////////////////////////////////////////////
function numtec(num) {
  let tecnica = JSON.parse(localStorage.getItem("subcategorias"));
  let n = tecnica.findIndex(numero => numero.subcategoriasNum === num);
  return n
}
function nametec(num) {
  let tecnica = JSON.parse(localStorage.getItem("subcategorias"));
  let n = tecnica.findIndex(numero => numero.subcategoriasNum === num);
  ////console.info(subcategorias[n].subcategorias)
  return tecnica[n].subcategorias
}
function plusOptionTec(num) {
  let tecnic = JSON.parse(localStorage.getItem("subcategorias"));
  let n = tecnic.findIndex(numero => numero.subcategoriasNum === num);
  if (n != -1) return true
  else return false
}

function sortJSON(data, key, orden) {
  return data.sort(function (a, b) {
    let x = a[key],
      y = b[key];

    if (orden === 'asc') {
      return ((x < y) ? -1 : ((x > y) ? 1 : 0));
    }

    if (orden === 'desc') {
      return ((x > y) ? -1 : ((x < y) ? 1 : 0));
    }
  });
}
///////////////////////////////////////////////////

async function toClientes(result) {
  //let datoscat = JSON.parse(localStorage.getItem("catalogo"));
  let catalogo = JSON.parse(localStorage.getItem("catalogo"));; //JSON.stringify(datoscat);
  //console.info(catalogo);
  let clients = []
  let datos = []
  let datosLite = []
  let rutina = [];
  let pos = 0;
  let texto = ""
  let segment = JSON.parse(localStorage.getItem("categorias"));
  let tecnic = JSON.parse(localStorage.getItem("subcategorias"));

  //for (let i = 0; i < result.length; i++) {
  //let inicio = result[i] //result[i].name
  for (let i = 0; i < catalogo.length; i++) {
    let inicio = catalogo[i].imagen; //result[i];
    //console.info(inicio);
    if (inicio && parseInt(inicio.slice(0, 3)) > 100 && inicio.length > 7) {
      //clients.push(new clientes(result[i].name))
      let idCat = catalogo[i].id;
      //////////////////////////////
      let nameIni = inicio;
      let nameInicat = nameIni; //catalogo[i].imagen;
      let name = nameIni;
      name = name.slice(0, name.indexOf("."));
      ////console.info(nameIni)

      // ojo let numero = name.slice(0, 3)
      let numeroCat = catalogo[i].cl;
      let numero = numeroCat.slice(0, 3)

      let num1 = parseInt(numero.slice(0, 1))
      let num2 = parseInt(numero.slice(0, 2))
      let num3 = parseInt(numero.slice(2, 3))

      let orden = catalogo[i].cl; //name.slice(0, 7)
      let ordenOri = catalogo[i].codigo;

      let nivel = ""
      let seg = ""
      let tipo = ""
      let regnum = 0
      let segmnum = 0

      //let num0 = -1;
      //if (num1 == 0) num0 = 0;
      /////////////////////////////////////
      let numa = -1
      let numb = -1
      let numt = -1
      //let numa = categoriasNum.indexOf(num1 * 100);
      if (plusOptionSeg(num1 * 100)) {
        numa = numseg(num1 * 100)
        nivel = segment[numa].categorias
        regnum = segment[numa].categoriasNum
      }

      //let numb = categoriasNum.indexOf(num2 * 10);
      if (plusOptionSeg(num2 * 10)) {
        numb = numseg(num2 * 10)
        segmnum = segment[numb].categoriasNum
        seg = segment[numb].categorias
      }

      //let numt = subcategoriasNum.indexOf(num3);
      if (plusOptionTec(num3)) {
        numt = numtec(num3)
        tipo = tecnic[numt].subcategorias
      }
      ;
      let id = pos;
      let path = servidorURL + "/assets/cstimage/" + nameInicat; //nameIni;
      //let nombre = valredux.slice(8, valredux.length) // "flex_ext_codo_palo.jpg",

      //let titulo = nameIni.slice(8, nameIni.length-4);
      let titulo = nameInicat;

      let nseg = numero
  
      let sseg = nseg.toString()

      let namIniMp4 = nameInicat.substr(0, 7); //nameIni.substr(0, 7)

      let exec = "";
      let videomp4 = "";
      if (parseInt(namIniMp4[2]) == 9) {
        exec = servidorURL + "/assets/cstvideo/" + namIniMp4 + ".txt"
        videomp4 = exec;
      }
      else {
        exec = servidorURL + "/assets/cstvideo/" + namIniMp4 + ".mp4"
        videomp4 = servidorURL + "/php/logs/php_log_video.php?video=" + encodeURIComponent(namIniMp4 + ".mp4") + "&dist=" + encodeURIComponent("pefir");
      }

      let remplaza = /_+/gi;
      name = name.replace(remplaza, " ");
      let nombre = name.slice(8, name.length)
      let region = nivel //eess
      let segm = seg //"hombro",
      let radi = 0
      let activo = 1
      // ojo let menu = parseInt(numero) //120
      let menu = parseInt(numero) //120
      let memo = nivel + "/" + seg //
      let memoI = nivel + "/" + seg + "/" + tipo //"autoasistidos",
      let memoII = tipo  //"activos",
      let memoIII = tipo
      //              Ejercicio(index, codigo, grupo, subgrupo, tipo, nombre, imagen, video, descripcion, duracion, series, repeticiones) 
      let ejercicio = new Ejercicio(id, idCat, videomp4, orden, ordenOri, regnum, region, segmnum, segm, menu, memoII, nombre, path, exec, titulo, 1, 3, 10)
      clients.push(new clientesNew(id, idCat, videomp4, path, nombre, titulo, exec, orden, ordenOri, regnum, region, segmnum, segm, radi, activo, menu, memo, memoI, memoII, memoIII))
      rutina.push(ejercicio);
      pos++
    }
  }
  for (let i = 0; i < clients.length; i++) {
    let dict = {}

    let dictLite = {}
    dictLite['titulo'] = clients[i].titulo
    dictLite['orden'] = clients[i].orden
    dictLite['ordenOri'] = clients[i].ordenOri
    dictLite['nombre'] = clients[i].nombre
    dictLite['ca'] = clients[i].nombre
    dictLite['es'] = clients[i].nombre
    datosLite[i] = dictLite

    ////console.info(clients[i].path)
    dict['id'] = clients[i].id
    dict['idCat'] = clients[i].idCat
    dict['videomp4'] = clients[i].videomp4
    dict['path'] = clients[i].path
    dict['nombre'] = clients[i].nombre
    dict['titulo'] = clients[i].titulo
    dict['exec'] = clients[i].exec
    dict['orden'] = clients[i].orden
    dict['ordenOri'] = clients[i].ordenOri
    dict['regnum'] = clients[i].regnum
    dict['region'] = clients[i].region
    dict['segmnum'] = clients[i].segmnum
    dict['segm'] = clients[i].segm
    dict['radi'] = clients[i].radi
    dict['activo'] = clients[i].activo
    dict['menu'] = clients[i].menu
    dict['memo'] = clients[i].memo
    dict['memoI'] = clients[i].memoI
    dict['memoII'] = clients[i].memoII
    dict['memoIII'] = clients[i].memoIII
    datos[i] = dict

    ////console.info(datos[i])
  }
  let textos = datos //
  let textosLite = datosLite //

  /*//////////////////////////////
  let Objeto = JSON.stringify(textosLite);
  localStorage.setItem("traducciones", Objeto);
  console.info(Objeto)
  // Obtener el JSON desde localStorage
  const datosStr = localStorage.getItem('traducciones');
  if (!datosStr) {
    alert('No hay datos guardados en localStorage');
  } else {
    // Crear un Blob con el JSON
    const blob = new Blob([datosStr], { type: 'application/json' });
    const url = URL.createObjectURL(blob);

    // Crear un enlace temporal para descargar
    const a = document.createElement('a');
    a.href = url;
    a.download = 'traducciones.json';  // Nombre del archivo a descargar
    document.body.appendChild(a);
    a.click();

    // Limpiar
    document.body.removeChild(a);
    URL.revokeObjectURL(url);
  }
  //////////////////////////////////*/

  return textos;
}

function downloadTextFile(text, name) {
  const a = document.createElement('a');
  const type = name.split(".").pop();
  a.href = URL.createObjectURL(new Blob([text], { type: `text / ${type === "txt" ? "plain" : type} ` }));
  a.download = name;
  a.click();
}

function clientesNew(id, idCat, videomp4, path, nombre, titulo, exec, orden, ordenOri, regnum, region, segmnum, segm, radi, activo, menu, memo, memoI, memoII, memoIII) {
  this.id = id
  this.idCat = idCat
  this.videomp4 = videomp4
  this.path = path
  this.nombre = nombre // "flex_ext_codo_palo",
  this.titulo = titulo // "111flex_ext_codo_palo.jpg",
  this.exec = exec // 
  this.orden = orden
  this.ordenOri = ordenOri
  this.regnum = regnum
  this.region = region //"eess",
  this.segmnum = segmnum //"490",
  this.segm = segm //"hombro",
  this.radi = radi
  this.activo = activo
  this.menu = menu //120
  this.memo = memo //
  this.memoI = memoI //"autoasistidos",
  this.memoII = memoII  //"activos",
  this.memoIII = memoIII
}
//////////////////////////////////

function plusOptionGen(num) {
  let generic = JSON.parse(localStorage.getItem("genericos"));
  let n = generic.findIndex(numero => numero.genericosNum === num);
  ////console.info(n)
  if (n != -1) return true
  else return false
}

function plusOptionSeg(num) {
  let segment = JSON.parse(localStorage.getItem("categorias"));
  let n = segment.findIndex(numero => numero.categoriasNum === num);
  ////console.info(n)
  if (n != -1) return true
  else return false
}
function plusOptionTec(num) {
  let tecnic = JSON.parse(localStorage.getItem("subcategorias"));
  let n = tecnic.findIndex(numero => numero.subcategoriasNum === num);
  if (n != -1) return true
  else return false
}
function numseg(num) {
  let segment = JSON.parse(localStorage.getItem("categorias"));
  let n = segment.findIndex(numero => numero.categoriasNum === num);
  return n
}
function numtec(num) {
  let tecnic = JSON.parse(localStorage.getItem("subcategorias"));
  let n = tecnic.findIndex(numero => numero.subcategoriasNum === num);
  return n
}

// Definir un objeto para representar un ejercicio
function Ejercicio(index, videomp4, codigo, grupo, gruponame, subgrupo, subgruponame, tipo, tiponame, nombre, imagen, video, descripcion, duracion, series, repeticiones) {
  this.index = index;
  this.videomp4 = videomp4;
  this.codigo = codigo;
  this.grupo = grupo;
  this.gruponame = gruponame;
  this.subgrupo = subgrupo;
  this.subgruponame = subgruponame;
  this.tipo = tipo;
  this.tiponame = tiponame;
  this.nombre = nombre;
  this.imagen = imagen;
  this.video = video;
  this.descripcion = descripcion;
  this.duracion = duracion;
  this.series = series;
  this.repeticiones = repeticiones;
}
//////////////////////////////////////////
function fechaFormateada() {
  // Obtener la fecha y hora actual
  const fechaHoraActual = new Date();

  // Formatear la fecha y hora como string
  //const año = String(fechaHoraActual.getFullYear()).slice(-2)
  const año = fechaHoraActual.getFullYear();
  const mes = String(fechaHoraActual.getMonth() + 1).padStart(2, '0'); // Los meses empiezan desde 0
  const dia = String(fechaHoraActual.getDate()).padStart(2, '0');
  const horas = String(fechaHoraActual.getHours()).padStart(2, '0');
  const minutos = String(fechaHoraActual.getMinutes()).padStart(2, '0');
  const segundos = String(fechaHoraActual.getSeconds()).padStart(2, '0');

  // Combinar en una fecha formateada
  const fechaHoraFormateada = `${año}${mes}${dia}_${horas}${minutos}${segundos}`;

  console.log(fechaHoraFormateada);
  return fechaHoraFormateada
}
/////////////////////////////////////////////////
function isTablet() {
  // Check user agent for tablet keywords
  const userAgent = navigator.userAgent.toLowerCase();
  const isTabletUserAgent = /(ipad|tablet|(android(?!.*mobi)))/i.test(userAgent);
  // Check screen dimensions for tablet size
  const screenWidth = window.screen.width;
  const screenHeight = window.screen.height;
  const isTabletScreen = (screenWidth >= 600 && screenWidth <= 1024) || (screenHeight >= 600 && screenHeight <= 1024);
  return isTabletUserAgent || isTabletScreen;
}
/////////////////////////////////////////
function isMobile() {
  const userAgent = navigator.userAgent.toLowerCase();
  const isMobileUserAgent = /(iphone|ipod|android.*mobile|windows phone)/i.test(userAgent);
  return isMobileUserAgent && !isTablet();
}
////////////////////////////////////////////
function isDesktop() {
  return !isMobile() && !isTablet();
}

function initHard() {
  //if (hard == undefined) 
  {

    showPlatformMessage(hard);
    if (isTablet()) {
      hard = hard + "T";
      //alert('This device is a tablet');
    } else if (isMobile()) {
      hard = hard + "T";
      //alert('This device is a mobile');
    } else {
      hard = hard + "D";
      //alert('This device is a desktop');
    }
  }
  switch (hard) {
    case "WPD":
      {
        //alert('ESTO ES UN PC');
        pC = true;
        localStorage.setItem("deviceAndroid", false);
        localStorage.setItem('hard', "WPD");
      }
      break;
    case "AMT":
      {
        //alert('ESTO ES UN MOVIL');
        pC = false;
        localStorage.setItem("deviceAndroid", true);
        localStorage.setItem('hard', "AMT");
      }
      break;
    case "UPT":
      {
        //alert('ESTO ES UNA TABLET');
        pC = false;
        localStorage.setItem("deviceAndroid", true);
        localStorage.setItem('hard', "UPT");
      }
      break;
    default:
      pC = true;
      localStorage.setItem("deviceAndroid", false);
      localStorage.setItem('hard', "WPD");
      hard = "WPD";
  }

}



async function fetchImageAsBase64(name) {
  let base64Image;

  try {

    //const url = servidorURL + `/php/pdf/php_get_image.php?image_name=${encodeURIComponent(name)}`;
    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 logEventPdf(eventData) {

  const response = await fetch(servidorURL + '/php/logs/php_log_pdf.php?t=' + new Date().getTime(), {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json; charset=utf-8'
    },
    body: JSON.stringify(eventData)
  });

  const result = await response.json();
  console.log(result);
}

////////////////////////////////////////////
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);
}
///////////////////////////////////