// Client-side media processing — pure helpers over Files and canvases, no
// network and no keys. Images are downscaled + re-encoded before upload
// (which also strips EXIF/GPS) and get a BlurHash placeholder; videos give up
// a poster frame, dimensions, and duration. Everything here returns bytes for
// the caller to encrypt — the server only ever sees ciphertext.
import { encodeBlurhash } from "/static/blurhash.js";

const MAX_IMAGE_DIM = 2048; // long-edge cap; bigger images are downscaled in-browser

// Pull a poster frame (JPEG), native dimensions, and duration out of a video
// File entirely client-side — the server only ever holds ciphertext, so it can't
// make a thumbnail. We draw the first decodable frame to a canvas and re-encode
// it small (which also strips any metadata). Resolves with a null posterBytes on
// failure (a codec the browser can't decode, a draw that throws) — the clip still
// uploads and plays wherever the format is supported. Never rejects.
export function videoMeta(file, maxPosterDim = 640) {
  return new Promise((resolve) => {
    const url = URL.createObjectURL(file);
    const v = document.createElement("video");
    v.muted = true;
    v.playsInline = true;
    v.preload = "auto";
    // Safari won't decode/paint frames from a *detached* <video>, so a canvas draw
    // would come out blank — keep it in the DOM but off-screen while we grab the
    // frame, then remove it.
    // Keep it in the DOM but off-screen at its NATURAL size while we grab a frame.
    // Safari won't decode frames for a detached or effectively-invisible video (a
    // 1px/opacity:0 element blanks the canvas), so only push it off-screen.
    v.style.cssText = "position:fixed;left:-9999px;top:0;pointer-events:none";
    document.body.appendChild(v);

    let done = false;
    let w = 0, h = 0, dur = 0; // captured at loadedmetadata, so dims survive a failed frame grab
    const finish = (posterBytes) => {
      if (done) return;
      done = true;
      clearTimeout(guard);
      try { v.pause(); } catch { /* ignore */ }
      URL.revokeObjectURL(url);
      v.remove();
      resolve({ w, h, dur, posterBytes });
    };
    // Give up (still returning any dims we captured) if decoding stalls.
    const guard = setTimeout(() => finish(null), 8000);

    const grab = async () => {
      if (done || !w || !h) return;
      let posterBytes = null;
      try {
        const scale = Math.min(maxPosterDim / w, maxPosterDim / h, 1);
        const cw = Math.max(1, Math.round(w * scale)), ch = Math.max(1, Math.round(h * scale));
        const canvas = document.createElement("canvas");
        canvas.width = cw;
        canvas.height = ch;
        canvas.getContext("2d").drawImage(v, 0, 0, cw, ch);
        const blob = await new Promise((r) => canvas.toBlob(r, "image/jpeg", 0.8));
        if (blob && blob.size > 0) posterBytes = new Uint8Array(await blob.arrayBuffer());
      } catch { /* undecodable frame → no poster (dims kept) */ }
      finish(posterBytes);
    };

    v.onerror = () => finish(null);
    v.onloadedmetadata = () => {
      w = v.videoWidth || 0;
      h = v.videoHeight || 0;
      dur = v.duration || 0;
    };
    // Playing muted forces Safari to actually decode a frame (a paused video
    // often won't); grab once it's advancing, then stop. Seek fallback if play
    // is blocked.
    v.oncanplay = () => {
      v.play().catch(() => { try { v.currentTime = Math.min(0.1, (dur || 0) / 2); } catch { /* ignore */ } });
    };
    v.onplaying = () => { setTimeout(grab, 150); };
    v.onseeked = grab;
    v.src = url;
  });
}

// Downscale + re-encode an image in-browser (caps the long edge, strips EXIF/GPS).
export async function processImage(file, maxDim = MAX_IMAGE_DIM) {
  const bitmap = await createImageBitmap(file);
  const scale = Math.min(1, maxDim / Math.max(bitmap.width, bitmap.height));
  const w = Math.round(bitmap.width * scale);
  const h = Math.round(bitmap.height * scale);
  const canvas = document.createElement("canvas");
  canvas.width = w;
  canvas.height = h;
  canvas.getContext("2d").drawImage(bitmap, 0, 0, w, h);
  const out = await new Promise((res) => canvas.toBlob(res, "image/jpeg", 0.85));
  // The BlurHash placeholder, from a tiny second draw (DCT cost is O(pixels) —
  // hash a ~32px thumbnail, never the full image). Rides INSIDE the encrypted
  // payload (attachments[].bh) like w/h — it's derived from image content.
  let bh = null;
  try {
    const ts = Math.min(1, 32 / Math.max(w, h));
    const tw = Math.max(1, Math.round(w * ts));
    const th = Math.max(1, Math.round(h * ts));
    const tiny = document.createElement("canvas");
    tiny.width = tw;
    tiny.height = th;
    tiny.getContext("2d").drawImage(bitmap, 0, 0, tw, th);
    bh = encodeBlurhash(tiny.getContext("2d").getImageData(0, 0, tw, th).data, tw, th);
  } catch {
    // No hash is fine — receivers keep the flat placeholder.
  }
  return { bytes: new Uint8Array(await out.arrayBuffer()), type: "image/jpeg", w, h, bh };
}