// Compress Video tool.
// Loaded as a <script type="module"> because ffmpeg.wasm ships as ES modules.
// FW (drag/drop, byte formatting, downloads, status text) comes from main.js,
// which is a plain global script, so it's still reachable from here.

const zone = document.getElementById('dropzone');
const input = document.getElementById('fileInput');
const workspace = document.getElementById('workspace');
const fileInfo = document.getElementById('fileInfo');
const origPreview = document.getElementById('origPreview');
const newPreview = document.getElementById('newPreview');
const newPlaceholder = document.getElementById('newPlaceholder');
const levelSelect = document.getElementById('level');
const resolutionSelect = document.getElementById('resolution');
const buildBtn = document.getElementById('buildBtn');
const downloadBtn = document.getElementById('downloadBtn');
const status = document.getElementById('status');
const resultBox = document.getElementById('resultBox');
const progressTrack = document.getElementById('progressTrack');
const progressFill = document.getElementById('progressFill');

// CRF: lower = higher quality, bigger file. "veryfast" keeps encode time reasonable in-browser.
const LEVELS = {
  low:    { crf: 20, preset: 'veryfast' },
  medium: { crf: 26, preset: 'veryfast' },
  high:   { crf: 32, preset: 'veryfast' }
};

let currentFile = null;
let outputBlob = null;
let ffmpeg = null;
let ffmpegLoading = null;

// ---------- Progress bar ----------
// The real ffmpeg.wasm "progress" event depends on it successfully parsing
// FFmpeg's internal log lines (Duration:, frame=... time=...). For short
// clips, some containers, or slow first-load, that either fires late, jumps
// straight to 100%, or never fires at all — so the bar can look broken or
// invisible. To make it always feel alive, we drive a smooth simulated climb
// on a timer, and simply snap up to the real percentage whenever ffmpeg does
// report one that's higher than where the simulation already is.
let progressTimer = null;
let progressPct = 0;

function setProgress(pct) {
  progressPct = Math.max(0, Math.min(100, pct));
  progressFill.style.width = progressPct + '%';
}

function startProgress() {
  progressTrack.classList.add('on');
  setProgress(0);
  clearInterval(progressTimer);
  // Climbs quickly at first, then slows as it nears the simulated ceiling —
  // never finishes on its own, so it always looks like real work in progress
  // until either a real progress tick or the final setProgress(100) lands.
  const ceiling = 92;
  progressTimer = setInterval(() => {
    if (progressPct >= ceiling) return;
    const remaining = ceiling - progressPct;
    setProgress(progressPct + Math.max(0.3, remaining * 0.06));
  }, 180);
}

function reportProgress(pct) {
  if (Number.isFinite(pct) && pct > progressPct) setProgress(pct);
}

function finishProgress(success) {
  clearInterval(progressTimer);
  progressTimer = null;
  if (success) {
    setProgress(100);
    setTimeout(() => progressTrack.classList.remove('on'), 500);
  } else {
    progressTrack.classList.remove('on');
    setProgress(0);
  }
}

FW.setupDropzone(zone, input, files => files[0] && handleFile(files[0]));

function handleFile(file) {
  if (!file.type.startsWith('video/')) {
    FW.status(status, 'That file is not a video. Please choose an MP4, MOV, WebM or similar file.', true);
    return;
  }
  currentFile = file;
  outputBlob = null;
  workspace.style.display = 'block';
  resultBox.style.display = 'none';
  downloadBtn.style.display = 'none';
  newPreview.style.display = 'none';
  newPlaceholder.style.display = 'block';
  progressTrack.classList.remove('on');
  setProgress(0);

  const url = URL.createObjectURL(file);
  origPreview.src = url;
  fileInfo.textContent = `${file.name} — ${FW.fmtBytes(file.size)}`;
  FW.status(status, 'Ready. Choose a quality and resolution, then compress.');
}

async function getFFmpeg() {
  if (ffmpeg) return ffmpeg;
  if (ffmpegLoading) return ffmpegLoading;

  ffmpegLoading = (async () => {
    FW.status(status, 'Loading the video engine (about 30MB, first time only)…');
    const { FFmpeg } = await import('https://cdn.jsdelivr.net/npm/@ffmpeg/ffmpeg@0.12.10/dist/esm/index.js');
    const { toBlobURL } = await import('https://cdn.jsdelivr.net/npm/@ffmpeg/util@0.12.1/dist/esm/index.js');

    const instance = new FFmpeg();

    instance.on('progress', ({ progress }) => {
      reportProgress(Math.round(progress * 100));
      if (Number.isFinite(progress)) {
        FW.status(status, `Compressing… ${Math.max(0, Math.min(100, Math.round(progress * 100)))}%`);
      }
    });

    const baseURL = 'https://cdn.jsdelivr.net/npm/@ffmpeg/core@0.12.6/dist/esm';
    await instance.load({
      coreURL: await toBlobURL(`${baseURL}/ffmpeg-core.js`, 'text/javascript'),
      wasmURL: await toBlobURL(`${baseURL}/ffmpeg-core.wasm`, 'application/wasm'),
    });

    ffmpeg = instance;
    return instance;
  })();

  return ffmpegLoading;
}

function extOf(name) {
  const m = /\.([a-z0-9]+)$/i.exec(name || '');
  return m ? m[0] : '.mp4';
}

buildBtn.addEventListener('click', async () => {
  if (!currentFile) { FW.status(status, 'Add a video first.', true); return; }

  buildBtn.disabled = true;
  downloadBtn.style.display = 'none';
  resultBox.style.display = 'none';
  startProgress();

  const inputName = 'input' + extOf(currentFile.name);
  const outputName = 'output.mp4';
  const level = LEVELS[levelSelect.value] || LEVELS.medium;
  const targetHeight = Number(resolutionSelect.value) || 0;

  try {
    const engine = await getFFmpeg();

    FW.status(status, 'Reading video…');
    const bytes = new Uint8Array(await currentFile.arrayBuffer());
    await engine.writeFile(inputName, bytes);

    const args = ['-i', inputName];
    if (targetHeight > 0) {
      // Scale down only — width auto (-2 keeps it even), height capped, never upscales.
      args.push('-vf', `scale='min(iw,iw*${targetHeight}/ih)':'min(ih,${targetHeight})':force_original_aspect_ratio=decrease`);
    }
    args.push(
      '-c:v', 'libx264',
      '-crf', String(level.crf),
      '-preset', level.preset,
      '-c:a', 'aac',
      '-b:a', '128k',
      '-movflags', '+faststart',
      outputName
    );

    FW.status(status, 'Compressing…');
    await engine.exec(args);

    const data = await engine.readFile(outputName);
    outputBlob = new Blob([data], { type: 'video/mp4' });

    // Clean up the virtual filesystem for this run.
    try { await engine.deleteFile(inputName); } catch (e) {}
    try { await engine.deleteFile(outputName); } catch (e) {}

    newPreview.src = URL.createObjectURL(outputBlob);
    newPreview.style.display = 'block';
    newPlaceholder.style.display = 'none';

    const savedPct = Math.max(0, Math.round((1 - outputBlob.size / currentFile.size) * 100));
    resultBox.style.display = 'block';
    resultBox.innerHTML = `
      <div class="file-row"><span class="name">Original</span><span class="meta">${FW.fmtBytes(currentFile.size)}</span></div>
      <div class="file-row"><span class="name">Compressed</span><span class="meta">${FW.fmtBytes(outputBlob.size)}</span></div>
      <div class="file-row"><span class="name"><strong>${savedPct}% smaller</strong></span><span class="meta"></span></div>`;

    downloadBtn.style.display = 'inline-flex';
    finishProgress(true);
    FW.status(status, savedPct > 0
      ? `Done — file is about ${savedPct}% smaller.`
      : 'Done — this video was already fairly compact, so the size change may be small.');
  } catch (e) {
    console.error(e);
    finishProgress(false);
    FW.status(status, 'Could not compress this video. It may be an unsupported codec, or too large for your browser\'s available memory.', true);
  }

  buildBtn.disabled = false;
});

downloadBtn.addEventListener('click', () => {
  if (!outputBlob || !currentFile) return;
  const base = currentFile.name.replace(/\.[^.]+$/, '');
  FW.download(outputBlob, `${base}-compressed.mp4`);
});