Untitled

addEventListener('fetch', event => {
  event.respondWith(handleRequest(event.request));
});

async function handleRequest(request) {
  const url = new URL(request.url);
  const link = "https://e88d763d.test-15e.pages.dev/";
  const path = url.pathname;
  const rangeHeader = request.headers.get('Range');
  console.log(rangeHeader)
  const fileName = path.slice(1);

  if (path === '/') {
    return fetch(link);
  }

  // Fetch the .txt file to get the file size
  const txtFileResponse = await fetch(link + `${fileName}.txt`);
  const fileSizeText = await txtFileResponse.text();

  // Extract the file size from the .txt file content
  const fileSize = parseInt(fileSizeText, 10);

  // Calculate the number of parts required
  const partSize = 5242880;
  const numParts = Math.ceil(fileSize / partSize);

  // If range header is present, determine the part number and fetch the corresponding part
  if (rangeHeader) {
    const partNumber = getPartNumberFromRange(rangeHeader, partSize);
    const partRange = getPartRange(partNumber, partSize, fileSize);
    return handlePartRequest(partNumber, partRange, fileSize, fileName, link);
  }

  // Fetch the first part
  const partRange = getPartRange(1, partSize, fileSize);
  return handlePartRequest(1, partRange, fileSize, fileName, link);
}

// Helper function to calculate the part number from the range header
function getPartNumberFromRange(rangeHeader, partSize) {
  const range = rangeHeader.replace('bytes=', '');
  const startByte = parseInt(range.split('-')[0], 10);
  const partNumber = Math.floor(startByte / partSize) + 1;
  return partNumber;
}

// Helper function to calculate byte range for a part file
// Helper function to calculate byte range for a part file
function getPartRange(partNumber, partSize, fileSize) {
  const startByte = (partNumber - 1) * partSize;
  const endByte = Math.min(startByte + partSize - 1, fileSize - 1);

  // Check if the calculated part range exceeds the maximum allowed size
  if (endByte - startByte + 1 > partSize) {
    // Adjust the endByte to the maximum allowed size
    endByte = startByte + partSize - 1;
  }

  return `bytes=${startByte}-${endByte}/${fileSize}`;
}


async function handlePartRequest(partNumber, partRange, fileSize, fileName, link) {
  const partResponse = await fetch(link + `${fileName}.part${partNumber}`, {
    headers: {
      Range: partRange,
    },
  });

  const response = new Response(partResponse.body, partResponse);
  response.headers.set('Content-Range', `bytes ${partRange.replace("bytes=", "")}`);
  response.headers.set('Accept-Ranges', 'bytes');
  response.headers.set('Content-Type', 'video/x-matroska');

  return new Response(response.body, {
    status: 206,
    statusText: 'Partial Content',
    headers: response.headers
  });
}