/**
 * Hidden-camera helper for the deep camera check.
 *
 * Opens a short-lived camera stream, mounts an off-screen <video>, and
 * waits for the sensor to deliver a real frame before resolving. The
 * caller takes a snapshot, then calls `cleanup()` to release the
 * tracks and remove the element.
 *
 * Why this exists separately from `WebcamObserver`:
 *  - Observer is for long-running session capture: it owns the stream
 *    for the duration of an exam, listens for track-ended, plumbs
 *    chunks into the uploader.
 *  - The system check needs the camera for ~1 second, with a hard
 *    timeout, then must release it. Reusing the observer would entail
 *    waiting on its photo schedule and having to suppress emit().
 *
 * Specific safety improvement over the teq-ts version: tracks an
 * `aborted` flag so that if the `getUserMedia` promise resolves after
 * the timeout has rejected, the late-resolved stream is stopped
 * immediately. The teq-ts code leaks the stream in that race.
 */

export interface HiddenCameraOptions {
  /** Optional camera deviceId. Falls back to the browser default. */
  deviceId?: string;
  /** Hard timeout on `getUserMedia`, in ms. Default: 10_000. */
  timeoutMs?: number;
  /** Requested capture width. Default: 1280. */
  desiredWidth?: number;
  /** Requested capture height. Default: 720. */
  desiredHeight?: number;
  /** id-prefix on the hidden <video>. Default: `"preflight-cam"`. */
  idPrefix?: string;
}

export interface HiddenCameraResult {
  videoElement: HTMLVideoElement;
  stream: MediaStream;
  cleanup: () => void;
}

/**
 * Open a hidden camera element. Resolves once the element has a real
 * frame (videoWidth/Height > 0). Rejects on `getUserMedia` failure or
 * timeout — and crucially, if `getUserMedia` resolves AFTER the
 * timeout fired, the stream is stopped immediately to avoid leaking
 * the camera light past the user's perception that the check failed.
 */
export const createHiddenCameraElement = async (
  options: HiddenCameraOptions = {},
): Promise<HiddenCameraResult> => {
  const {
    deviceId,
    timeoutMs = 10_000,
    desiredWidth = 1280,
    desiredHeight = 720,
    idPrefix = "preflight-cam",
  } = options;

  if (typeof navigator === "undefined" || !navigator.mediaDevices?.getUserMedia) {
    throw new Error("getUserMedia is not available in this environment");
  }

  // `aborted` flips true when the timeout wins the race. If
  // getUserMedia subsequently resolves, the resolver checks this flag
  // and stops the tracks rather than handing back a stream the caller
  // has already moved past.
  let aborted = false;
  let timeoutId: ReturnType<typeof setTimeout> | null = null;

  const constraints: MediaStreamConstraints = {
    video: deviceId
      ? {
          deviceId: { exact: deviceId },
          width: { ideal: desiredWidth },
          height: { ideal: desiredHeight },
          facingMode: "user",
        }
      : {
          width: { ideal: desiredWidth },
          height: { ideal: desiredHeight },
          facingMode: "user",
        },
    audio: false,
  };

  const stream = await new Promise<MediaStream>((resolve, reject) => {
    timeoutId = setTimeout(() => {
      aborted = true;
      reject(new Error(`createHiddenCameraElement timeout (${timeoutMs}ms)`));
    }, timeoutMs);

    navigator.mediaDevices.getUserMedia(constraints).then(
      (s) => {
        if (aborted) {
          // Timeout already rejected; stop the late stream so the
          // camera light doesn't keep burning.
          s.getTracks().forEach((t) => t.stop());
          return;
        }
        if (timeoutId) clearTimeout(timeoutId);
        resolve(s);
      },
      (err: unknown) => {
        if (aborted) return;
        if (timeoutId) clearTimeout(timeoutId);
        reject(err instanceof Error ? err : new Error(String(err)));
      },
    );
  });

  // Mount a hidden <video> so we can snapshot it via canvas.
  // Off-screen DOM is the cheapest paint source the canvas API
  // understands.
  const uniqueId = `${idPrefix}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
  const videoElement = document.createElement("video");
  videoElement.id = uniqueId;
  videoElement.autoplay = true;
  videoElement.muted = true;
  videoElement.playsInline = true;
  videoElement.srcObject = stream;
  videoElement.style.cssText = [
    "position:absolute",
    "left:-9999px",
    "top:-9999px",
    "width:1px",
    "height:1px",
    "opacity:0",
    "pointer-events:none",
  ].join(";");
  document.body.appendChild(videoElement);

  try {
    await videoElement.play();
  } catch {
    // play() can reject on autoplay policies; the track still produces
    // frames, draw will still work.
  }

  // Wait for the first frame with dimensions. Without this the first
  // canvas draw can come back empty.
  await waitForRealFrame(videoElement);

  const cleanup = (): void => {
    stream.getTracks().forEach((t) => t.stop());
    if (videoElement.parentNode) {
      videoElement.parentNode.removeChild(videoElement);
    }
  };

  return { videoElement, stream, cleanup };
};

/**
 * Resolves once the video element reports non-zero dimensions, meaning
 * the sensor has handed over a real frame. Times out after 3s so we
 * never block the engine indefinitely — the caller's deep-check retry
 * loop catches the timeout case.
 */
export const waitForRealFrame = (video: HTMLVideoElement): Promise<void> =>
  new Promise((resolve, reject) => {
    if (video.videoWidth > 0 && video.videoHeight > 0) {
      resolve();
      return;
    }

    const FRAME_TIMEOUT_MS = 3_000;
    const timeout = setTimeout(() => {
      cleanup();
      reject(new Error("waitForRealFrame: timed out waiting for first frame"));
    }, FRAME_TIMEOUT_MS);

    const onReady = (): void => {
      if (video.videoWidth > 0 && video.videoHeight > 0) {
        cleanup();
        resolve();
      }
    };

    const cleanup = (): void => {
      clearTimeout(timeout);
      video.removeEventListener("loadedmetadata", onReady);
      video.removeEventListener("loadeddata", onReady);
      video.removeEventListener("playing", onReady);
    };

    video.addEventListener("loadedmetadata", onReady);
    video.addEventListener("loadeddata", onReady);
    video.addEventListener("playing", onReady);
  });

/**
 * Draw the current video frame to a JPEG data URL. Used by the deep
 * camera check to capture exactly one photo per attempt. The face
 * detector judges the frame — a fully-black/covered lens simply
 * returns zero faces and fails the check.
 */
export interface CapturedFrame {
  dataUrl: string;
  width: number;
  height: number;
  averageLuma?: number;
  lumaStdDev?: number;
  isLikelyBlank: boolean;
}

export const captureFrame = (
  video: HTMLVideoElement,
  jpegQuality = 0.7,
): CapturedFrame => {
  const width = video.videoWidth || 1280;
  const height = video.videoHeight || 720;

  const canvas = document.createElement("canvas");
  canvas.width = width;
  canvas.height = height;
  const ctx = canvas.getContext("2d");
  if (!ctx) {
    throw new Error("captureFrame: canvas 2d context unavailable");
  }
  ctx.drawImage(video, 0, 0, width, height);

  const dataUrl = canvas.toDataURL("image/jpeg", jpegQuality);
  const analysis = analyzeFrame(ctx, width, height);

  return { dataUrl, width, height, ...analysis };
};

const analyzeFrame = (
  ctx: CanvasRenderingContext2D,
  width: number,
  height: number,
): Pick<CapturedFrame, "averageLuma" | "lumaStdDev" | "isLikelyBlank"> => {
  try {
    const data = ctx.getImageData(0, 0, width, height).data;
    const pixelCount = width * height;
    const stride = Math.max(1, Math.floor(pixelCount / 5_000));
    let count = 0;
    let sum = 0;
    let sumSquares = 0;

    for (let pixel = 0; pixel < pixelCount; pixel += stride) {
      const offset = pixel * 4;
      const r = data[offset] ?? 0;
      const g = data[offset + 1] ?? 0;
      const b = data[offset + 2] ?? 0;
      const luma = 0.299 * r + 0.587 * g + 0.114 * b;
      count += 1;
      sum += luma;
      sumSquares += luma * luma;
    }

    const averageLuma = count > 0 ? sum / count : 0;
    const variance =
      count > 0 ? Math.max(0, sumSquares / count - averageLuma * averageLuma) : 0;
    const lumaStdDev = Math.sqrt(variance);
    return {
      averageLuma,
      lumaStdDev,
      isLikelyBlank: averageLuma < 8 || (averageLuma < 18 && lumaStdDev < 4),
    };
  } catch {
    return { isLikelyBlank: false };
  }
};