import fs from "node:fs";
import path from "node:path";
import type { Page } from "playwright";
import { createLogger, shortHash, sleep, type MediaLevel, type ObservedEntity, type ObservedMedia, type Platform, type Provenance } from "@src/shared";
import type { ClassifiedResponse, DomSnapshot } from "@src/observers";

const log = createLogger("media");

/**
 * Media Intelligence Layer (§17–§19, §47). Video detection fuses three surfaces:
 *  - DOM <video> elements (playback state, dimensions, duration)
 *  - network media manifests / segments (delivery kind + CDN hostnames)
 *  - entities of type video (platform id, title, author, thumbnail)
 * Frame sampling (LEVEL 2) captures a few element screenshots at fixed positions — no download of the artifact.
 */
export function detectVideos(opts: { platform: Platform; snapshot: DomSnapshot; entities: ObservedEntity[]; responses: ClassifiedResponse[]; pageUrl: string }): ObservedMedia[] {
  const out = new Map<string, ObservedMedia>();
  const mediaResponses = opts.responses.filter((r) => r.kind === "media_manifest" || r.kind === "media_segment");
  const hostnames = [...new Set(mediaResponses.map((r) => r.fingerprint.hostname))];
  const manifest = mediaResponses.find((r) => r.kind === "media_manifest");
  const deliveryKind: "progressive" | "hls" | "dash" | "unknown" = manifest
    ? /m3u8|mpegurl/i.test(manifest.response.url + manifest.response.content_type)
      ? "hls"
      : /mpd|dash/i.test(manifest.response.url + manifest.response.content_type)
        ? "dash"
        : "unknown"
    : mediaResponses.length
      ? "progressive"
      : "unknown";

  // 1) Current video (the one playing / present in DOM) — bind it to the current-page video entity when there is one.
  const current = opts.entities.find((e) => e.type === "video" && (e.context === "current video" || (e.url && samePage(e.url, opts.pageUrl))));
  for (const v of opts.snapshot.video_elements) {
    if (!(v.width > 0 || v.duration || v.current_src)) continue;
    const id = current?.platform_id ?? shortHash(v.current_src ?? v.src ?? opts.pageUrl, 12);
    const fp = `${opts.platform}:video:${id}`;
    const prov: Provenance[] = [{ surface: "dom", confidence: 0.9, detail: "video element" }];
    if (mediaResponses.length) prov.push({ surface: "network", confidence: 0.85, detail: `${mediaResponses.length} media responses` });
    if (current) prov.push(...current.provenance);
    out.set(fp, {
      media_type: "video",
      platform: opts.platform,
      platform_media_id: current?.platform_id ?? undefined,
      url: v.current_src ?? v.src,
      page_url: opts.pageUrl,
      title: current?.name ?? opts.snapshot.h1,
      author: current?.author,
      duration_s: v.duration ?? current?.media?.duration_s,
      width: v.width || undefined,
      height: v.height || undefined,
      thumbnail_url: v.poster ?? current?.media?.thumbnail_url,
      delivery: { kind: deliveryKind, manifest_url: manifest?.response.url, hostnames },
      fingerprint: fp,
      provenance: prov,
    });
  }
  // 2) Video entities visible on the page (feed cards, search results): metadata-level media records.
  for (const e of opts.entities) {
    if (e.type !== "video" || out.has(e.fingerprint)) continue;
    out.set(e.fingerprint, {
      media_type: "video",
      platform: opts.platform,
      platform_media_id: e.platform_id,
      page_url: e.url,
      title: e.name,
      author: e.author,
      duration_s: e.media?.duration_s,
      thumbnail_url: e.media?.thumbnail_url,
      fingerprint: e.fingerprint,
      provenance: e.provenance,
    });
  }
  return [...out.values()];
}

function samePage(a: string, b: string): boolean {
  try {
    const ua = new URL(a);
    const ub = new URL(b);
    return ua.pathname === ub.pathname && ua.searchParams.get("v") === ub.searchParams.get("v");
  } catch {
    return false;
  }
}

/**
 * VideoFrameSampler (§18): LEVEL ≥ 2 — screenshot the <video> element at 0 / 25 / 50 / 75 / 100 %.
 * Seeking a video the account is legitimately watching is normal viewer behaviour.
 * Returns file paths; perceptual hashing is left as a follow-up (MediaDeduplicator seam).
 */
export async function sampleVideoFrames(page: Page, media: ObservedMedia, mediaDir: string, level: MediaLevel, maxFrames = 5): Promise<string[]> {
  if (level < 2) return [];
  const video = page.locator("video").first();
  if (!(await video.isVisible().catch(() => false))) return [];
  const dir = path.join(mediaDir, media.platform, media.platform_media_id ?? shortHash(media.fingerprint, 10));
  fs.mkdirSync(dir, { recursive: true });
  const duration = media.duration_s ?? (await video.evaluate((v: HTMLVideoElement) => (Number.isFinite(v.duration) ? v.duration : 0)).catch(() => 0));
  const positions = [0, 0.25, 0.5, 0.75, 0.98].slice(0, maxFrames);
  const files: string[] = [];
  const deadline = Date.now() + 20_000; // frame sampling is best-effort and bounded
  for (const p of positions) {
    if (Date.now() > deadline) break;
    try {
      if (duration > 2) {
        await video.evaluate((v: HTMLVideoElement, t: number) => {
          v.currentTime = t;
        }, Math.min(duration - 0.5, duration * p));
        await sleep(600);
      }
      const file = path.join(dir, `frame_${Math.round(p * 100)}.jpg`);
      await video.screenshot({ path: file, type: "jpeg", quality: 70, timeout: 5000 });
      files.push(file);
      if (duration <= 2) break;
    } catch (err) {
      log.debug("frame capture failed", { err: (err as Error).message });
    }
  }
  return files;
}