binary_utils.js

/**
 * Utilidades para manejo de archivos binarios en DBP2P
 */

/**
 * Convierte un archivo a Base64
 * @param {File|Blob} file - El archivo o blob a convertir
 * @returns {Promise<string>} - Promesa que resuelve con el string en Base64
 */
function fileToBase64(file) {
  return new Promise((resolve, reject) => {
    const reader = new FileReader();
    reader.readAsDataURL(file);
    reader.onload = () => {
      // Eliminar el prefijo "data:*/*;base64," para obtener solo el contenido Base64
      const base64String = reader.result.split(",")[1];
      resolve(base64String);
    };
    reader.onerror = (error) => reject(error);
  });
}

/**
 * Calcula el hash SHA-256 de un archivo o blob
 * @param {File|Blob} file - El archivo o blob para calcular el hash
 * @returns {Promise<string>} - Promesa que resuelve con el hash en formato hexadecimal
 */
async function calculateSHA256(file) {
  return new Promise((resolve, reject) => {
    const reader = new FileReader();
    reader.readAsArrayBuffer(file);
    reader.onload = async () => {
      try {
        // Usar la API Web Crypto para calcular el hash
        const hashBuffer = await crypto.subtle.digest("SHA-256", reader.result);

        // Convertir el ArrayBuffer a string hexadecimal
        const hashArray = Array.from(new Uint8Array(hashBuffer));
        const hashHex = hashArray
          .map((b) => b.toString(16).padStart(2, "0"))
          .join("");

        resolve(hashHex);
      } catch (error) {
        reject(error);
      }
    };
    reader.onerror = (error) => reject(error);
  });
}

/**
 * Sube un archivo binario a una colección
 * @param {string} collection - Nombre de la colección
 * @param {File} file - Archivo a subir
 * @param {Object} metadata - Metadatos adicionales para el archivo
 * @param {Function} [progressCallback] - Función de callback para reportar progreso (0-100)
 * @returns {Promise<Object>} - Promesa que resuelve con los metadatos del archivo creado
 */
async function uploadBinaryToCollection(
  collection,
  file,
  metadata = {},
  progressCallback = null
) {
  try {
    // Tamaño máximo de fragmento (2MB para mejor compatibilidad)
    let CHUNK_SIZE = 2 * 1024 * 1024;

    // Ajustar tamaño de fragmento según el tipo de archivo
    if (file.type === "video/mp4") {
      // Para archivos MP4, usar fragmentos más pequeños (1MB)
      CHUNK_SIZE = 1 * 1024 * 1024;
      console.log("Archivo MP4 detectado, usando fragmentos de 1MB");
    }

    // Verificar si el archivo es grande (>5MB)
    const isLargeFile = file.size > 5 * 1024 * 1024;

    // Calcular número óptimo de fragmentos basado en el tamaño y tipo de archivo
    let totalChunks = Math.ceil(file.size / CHUNK_SIZE);

    // Para archivos MP4 muy grandes, limitar el número de fragmentos
    const MAX_CHUNKS = 200; // Límite máximo de fragmentos (aumentado para videos grandes)
    if (file.type === "video/mp4" && totalChunks > MAX_CHUNKS) {
      console.log(
        `Archivo MP4 grande detectado (${totalChunks} fragmentos). Ajustando a ${MAX_CHUNKS} fragmentos.`
      );
      // Recalcular tamaño de fragmento para tener exactamente MAX_CHUNKS fragmentos
      CHUNK_SIZE = Math.ceil(file.size / MAX_CHUNKS);
      totalChunks = MAX_CHUNKS;
      console.log(`Nuevo tamaño de fragmento: ${CHUNK_SIZE} bytes`);
    }

    // Para archivos extremadamente grandes, mostrar advertencia
    if (file.size > 500 * 1024 * 1024) {
      // 500MB
      console.warn(
        `Archivo muy grande detectado (${(file.size / (1024 * 1024)).toFixed(
          2
        )}MB). La subida puede tardar mucho tiempo.`
      );
      showAlert(
        `Archivo muy grande (${(file.size / (1024 * 1024)).toFixed(
          2
        )}MB). La subida puede tardar mucho tiempo y consumir muchos recursos.`,
        "warning"
      );
    }

    // Para archivos pequeños, usar el método simple
    if (!isLargeFile) {
      // Convertir archivo a Base64
      const base64Content = await fileToBase64(file);

      // Crear documento con el contenido binario
      const documentData = {
        filename: file.name,
        mimetype: file.type,
        size: file.size,
        binary: base64Content,
        ...metadata,
      };

      // Crear documento en la colección
      const result = await makeApiRequest(
        `${API_URL}/collections/${collection}`,
        {
          method: "POST",
          body: JSON.stringify(documentData),
          useCache: false,
        }
      );

      return result;
    }

    // Para archivos grandes, usar streaming por fragmentos
    // Crear un ID temporal para el archivo
    const tempId = `temp_${Date.now()}_${Math.random()
      .toString(36)
      .substring(2, 15)}`;

    // Crear documento inicial con metadatos pero sin contenido
    const initialData = {
      filename: file.name,
      mimetype: file.type,
      size: file.size,
      chunks: totalChunks, // Usar el valor calculado anteriormente
      tempId: tempId,
      isMultipart: true,
      chunkSize: CHUNK_SIZE,
      completedChunks: 0,
      ...metadata,
    };

    // Crear documento inicial
    const initialResult = await makeApiRequest(
      `${API_URL}/collections/${collection}`,
      {
        method: "POST",
        body: JSON.stringify(initialData),
        useCache: false,
      }
    );

    const docId = initialResult.id;

    // Subir fragmentos
    for (let chunkIndex = 0; chunkIndex < totalChunks; chunkIndex++) {
      const chunk = file.slice(
        chunkIndex * CHUNK_SIZE,
        (chunkIndex + 1) * CHUNK_SIZE
      );
      await fetch(
        `${API_URL}/collections/${collection}/${docId}/chunk?chunkIndex=${chunkIndex}`,
        {
          method: "PUT",
          headers: {
            Authorization: `Bearer ${token}`,
          },
          body: chunk,
        }
      );

      // Actualizar progreso
      if (progressCallback) {
        const progress = Math.round(((chunkIndex + 1) / totalChunks) * 100);
        progressCallback(progress);
      }
    }

    // Verificar que todos los fragmentos se hayan subido correctamente
    try {
      console.log("Verificando integridad de la subida...");
      const verifyResponse = await fetch(
        `${API_URL}/diagnostics/document/${collection}/${docId}`,
        {
          method: "GET",
          headers: {
            Authorization: `Bearer ${token}`,
            "Content-Type": "application/json",
          },
          credentials: "include",
          mode: "cors",
        }
      );

      if (verifyResponse.ok) {
        const verifyData = await verifyResponse.json();
        console.log("Resultado de verificación:", verifyData);

        // Si hay problemas, intentar reparar
        if (!verifyData.success) {
          console.log("Intentando reparar documento...");
          const repairResponse = await fetch(
            `${API_URL}/diagnostics/document/${collection}/${docId}/repair`,
            {
              method: "POST",
              headers: {
                Authorization: `Bearer ${token}`,
                "Content-Type": "application/json",
              },
              credentials: "include",
              mode: "cors",
            }
          );

          if (repairResponse.ok) {
            const repairData = await repairResponse.json();
            console.log("Resultado de reparación:", repairData);
          }
        }
      }
    } catch (error) {
      console.error("Error al verificar integridad:", error);
      // No lanzar error aquí, continuar con la finalización
    }

    // Finalizar la subida
    const finalizeData = {
      isComplete: true,
      tempId: tempId,
      partCount: totalChunks,
      fileSize: file.size,
      chunkSize: CHUNK_SIZE,
      mimeType: file.type,
      fileName: file.name,
      force: file.type === "video/mp4", // Forzar finalización para archivos MP4
    };

    console.log("Finalizando subida con datos:", finalizeData);

    const finalResult = await makeApiRequest(
      `${API_URL}/collections/${collection}/${docId}/finalize`,
      {
        method: "POST", // Cambiar a POST para evitar problemas de caché
        body: JSON.stringify(finalizeData),
        useCache: false,
      }
    );

    return finalResult;
  } catch (error) {
    console.error("Error al subir archivo binario:", error);
    throw error;
  }
}

/**
 * Descarga un archivo binario de una colección
 * @param {string} collection - Nombre de la colección
 * @param {string} id - ID del documento
 * @param {Function} [progressCallback] - Función de callback para reportar progreso (0-100)
 * @returns {Promise<Object>} - Promesa que resuelve con el objeto {blob, filename, mimetype}
 */
async function downloadBinaryFromCollection(
  collection,
  id,
  progressCallback = null
) {
  try {
    // Obtener documento (metadatos)
    const doc = await makeApiRequest(
      `${API_URL}/collections/${collection}/${id}`
    );

    if (!doc || !doc.data) {
      throw new Error("No se pudo obtener el documento");
    }

    // Verificar si es un archivo multipart (grande)
    const isMultipart = doc.data.isMultipart === true;

    // Para archivos pequeños, usar el método simple
    if (!isMultipart) {
      if (!doc.data.binary) {
        throw new Error("El documento no contiene datos binarios");
      }

      // Convertir Base64 a Blob
      const byteCharacters = atob(doc.data.binary);
      const byteArrays = [];

      for (let offset = 0; offset < byteCharacters.length; offset += 512) {
        const slice = byteCharacters.slice(offset, offset + 512);

        const byteNumbers = new Array(slice.length);
        for (let i = 0; i < slice.length; i++) {
          byteNumbers[i] = slice.charCodeAt(i);
        }

        const byteArray = new Uint8Array(byteNumbers);
        byteArrays.push(byteArray);
      }

      // Crear Blob con el tipo MIME correcto
      const blob = new Blob(byteArrays, {
        type: doc.data.mimetype || "application/octet-stream",
      });
      return {
        blob,
        filename: doc.data.filename || `file_${id}`,
        mimetype: doc.data.mimetype || "application/octet-stream",
      };
    }

    // Para archivos grandes, descargar por fragmentos
    const totalChunks = doc.data.chunks || 0;
    if (totalChunks <= 0) {
      throw new Error("Información de fragmentos no válida");
    }

    // Array para almacenar todos los fragmentos
    const chunks = [];

    // Descargar cada fragmento
    for (let chunkIndex = 0; chunkIndex < totalChunks; chunkIndex++) {
      const chunkUrl = `${API_URL}/collections/${collection}/${id}/chunk?chunkIndex=${chunkIndex}`;
      // Solicitar fragmento
      const chunkResponse = await makeApiRequest(chunkUrl, { useCache: false });

      if (!chunkResponse || !chunkResponse.binary) {
        console.error(
          `Error al descargar fragmento ${chunkIndex} (${chunkUrl})`,
          chunkResponse
        );
        showAlert(
          `No se pudo descargar el fragmento ${chunkIndex}. Verifique que el archivo exista en el servidor.`,
          "danger"
        );
        throw new Error(
          `Error al descargar fragmento ${chunkIndex}: Fragmento no encontrado. Verifique que el archivo exista en el servidor.`
        );
      }

      // Verificar checksum si está disponible
      if (chunkResponse.checksum) {
        const chunkData = atob(chunkResponse.binary);
        const byteNumbers = new Array(chunkData.length);
        for (let i = 0; i < chunkData.length; i++) {
          byteNumbers[i] = chunkData.charCodeAt(i);
        }
        const byteArray = new Uint8Array(byteNumbers);
        const blob = new Blob([byteArray]);

        // Calcular checksum del fragmento recibido
        const calculatedChecksum = await calculateSHA256(blob);

        // Verificar integridad
        if (calculatedChecksum !== chunkResponse.checksum) {
          throw new Error(
            `Error de integridad en fragmento ${chunkIndex}: checksum no coincide`
          );
        }
      }

      // Convertir Base64 a ArrayBuffer
      const byteCharacters = atob(chunkResponse.binary);
      const byteNumbers = new Array(byteCharacters.length);
      for (let i = 0; i < byteCharacters.length; i++) {
        byteNumbers[i] = byteCharacters.charCodeAt(i);
      }
      const byteArray = new Uint8Array(byteNumbers);

      // Guardar fragmento
      chunks.push(byteArray);

      // Actualizar progreso
      if (progressCallback) {
        const progress = Math.round(((chunkIndex + 1) / totalChunks) * 100);
        progressCallback(progress);
      }
    }

    // Combinar todos los fragmentos en un solo Blob
    const blob = new Blob(chunks, {
      type: doc.data.mimetype || "application/octet-stream",
    });

    return {
      blob,
      filename: doc.data.filename || `file_${id}`,
      mimetype: doc.data.mimetype || "application/octet-stream",
    };
  } catch (error) {
    console.error("Error al descargar archivo binario:", error);
    throw error;
  }
}

/**
 * Descarga y abre un archivo binario
 * @param {string} collection - Nombre de la colección
 * @param {string} id - ID del documento
 * @param {boolean} [visualize=false] - Si es true, intenta abrir el archivo en el navegador; si es false, lo descarga
 */
async function openBinaryFile(collection, id, visualize = false) {
  try {
    const { blob, filename, mimetype } = await downloadBinaryFromCollection(
      collection,
      id
    );
    const url = URL.createObjectURL(blob);

    // Permitir visualizar imágenes, textos, PDFs y videos
    const canHandle =
      mimetype &&
      (mimetype.startsWith("image/") ||
        mimetype.startsWith("text/") ||
        mimetype.startsWith("video/") ||
        mimetype === "application/pdf");

    if (visualize && canHandle) {
      window.open(url, "_blank");
    } else {
      const a = document.createElement("a");
      a.href = url;
      a.download = filename || "archivo";
      document.body.appendChild(a);
      a.click();
      document.body.removeChild(a);
      URL.revokeObjectURL(url);
    }
  } catch (error) {
    console.error("Error al abrir archivo:", error);

    // Verificar si es un error de fragmento no encontrado
    if (error.message && error.message.includes("Fragmento no encontrado")) {
      showAlert(
        "No se pudo abrir el archivo: Error fragmento no encontrado. Verifique que el archivo exista en el servidor y que no esté corrupto.",
        "danger"
      );
    } else {
      showAlert("No se pudo abrir el archivo: " + error, "danger");
    }
  }
}