import { randomUUID } from "node:crypto";
import type { ViaplayAccountCreds } from "./accounts";
import { toMediaGuid } from "./accounts";

export const VIAPLAY_USER_AGENT =
  "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/153.0.0.0 Safari/537.36 Edg/153.0.0.0";

export type ViaplayPlayResult = {
  mediaGuid: string;
  mpdUrl: string;
  licenseUrl: string | null;
  licenseAuth: string | null;
  channelName: string | null;
  stationId: string | null;
  title: string | null;
};

function asRecord(v: unknown): Record<string, unknown> | null {
  return v && typeof v === "object" && !Array.isArray(v)
    ? (v as Record<string, unknown>)
    : null;
}

function cookieHeader(creds: ViaplayAccountCreds): string {
  const parts: string[] = [];
  if (creds.session) parts.push(`session=${creds.session}`);
  if (creds.accessToken) parts.push(`accessToken=${creds.accessToken}`);
  if (creds.profileId) parts.push(`viaplay_profileId=${creds.profileId}`);
  if (creds.persistentLogin) parts.push(`persistentLogin=${creds.persistentLogin}`);
  return parts.join("; ");
}

export function authHeaders(creds: ViaplayAccountCreds): Record<string, string> {
  const headers: Record<string, string> = {
    Accept: "*/*",
    "Accept-Language": "nl,en;q=0.9,en-GB;q=0.8,en-US;q=0.7",
    Origin: "https://viaplay.com",
    Referer: "https://viaplay.com/",
    "User-Agent": VIAPLAY_USER_AGENT,
    Cookie: cookieHeader(creds),
  };
  const token = normalizeAccessToken(creds.accessToken);
  if (token) headers.Authorization = `VIAPLAY-AT ${token}`;
  return headers;
}

/**
 * Vernieuw session/accessToken via persistentLogin (zoals de webapp na cookie-expiry).
 * Zonder verse session-cookie geeft play.viaplay.com 403 of rare fallbacks.
 */
export async function refreshViaplaySession(
  creds: ViaplayAccountCreds,
  opts: { deviceKey: string; timeoutMs: number }
): Promise<ViaplayAccountCreds | null> {
  const pl = creds.persistentLogin?.trim();
  if (!pl) return null;

  const url = new URL("https://login.viaplay.com/api/persistentLogin/v1");
  url.searchParams.set("deviceKey", opts.deviceKey);
  url.searchParams.set(
    "returnurl",
    `https://content.viaplay.com/${opts.deviceKey}`
  );

  const res = await fetch(url.toString(), {
    headers: {
      Accept: "application/json",
      "Accept-Language": "nl,en;q=0.9",
      Origin: "https://viaplay.com",
      Referer: "https://viaplay.com/",
      "User-Agent": VIAPLAY_USER_AGENT,
      Cookie: `persistentLogin=${pl}`,
    },
    signal: AbortSignal.timeout(opts.timeoutMs),
  });

  const jar: Record<string, string> = {};
  const rawSet =
    typeof res.headers.getSetCookie === "function"
      ? res.headers.getSetCookie()
      : [];
  for (const sc of rawSet) {
    const m = sc.match(/^([^=]+)=([^;]*)/);
    if (m) jar[m[1]!] = m[2]!;
  }

  let body: Record<string, unknown> | null = null;
  try {
    body = (await res.json()) as Record<string, unknown>;
  } catch {
    body = null;
  }
  if (res.status !== 200 || !body?.success) return null;

  const sessionRaw = jar.session || "";
  const accessRaw =
    jar.accessToken ||
    (typeof asRecord(body.userData)?.accessToken === "string"
      ? String(asRecord(body.userData)!.accessToken)
      : "");
  if (!sessionRaw || !accessRaw) return null;

  let session = sessionRaw;
  try {
    session = decodeURIComponent(sessionRaw);
  } catch {
    /* keep raw */
  }
  const accessToken = normalizeAccessToken(accessRaw) || accessRaw.trim();
  const nextPl = jar.persistentLogin
    ? (() => {
        try {
          return decodeURIComponent(jar.persistentLogin);
        } catch {
          return jar.persistentLogin;
        }
      })()
    : pl;

  return {
    ...creds,
    session,
    accessToken,
    persistentLogin: nextPl,
  };
}

async function fetchJson(
  url: string,
  opts: {
    headers?: Record<string, string>;
    timeoutMs: number;
    method?: string;
  }
): Promise<{ status: number; json: unknown; text: string }> {
  const response = await fetch(url, {
    method: opts.method ?? "GET",
    headers: opts.headers,
    signal: AbortSignal.timeout(opts.timeoutMs),
  });
  const text = await response.text();
  let json: unknown = null;
  try {
    json = JSON.parse(text) as unknown;
  } catch {
    /* ignore */
  }
  return { status: response.status, json, text };
}

export type ViaplayOverview = {
  ok: boolean;
  status: number;
  partnerName: string | null;
  productNames: string[];
  summary: string;
  error?: string;
  /** Sessie werkt, maar pakketinfo ontbreekt/mislukt. */
  sessionOk?: boolean;
};

function normalizeAccessToken(raw: string | null | undefined): string | null {
  if (!raw) return null;
  const trimmed = raw.trim();
  if (!trimmed) return null;
  // Browser/HAR kan "VIAPLAY-AT …", "MTG-AT …" of "Bearer …" plakken
  return (
    trimmed.replace(/^(VIAPLAY-AT|MTG-AT|Bearer)\s+/i, "").trim() || null
  );
}

function accessTokenExpiryInfo(token: string): {
  expired: boolean;
  expMs: number | null;
} {
  try {
    const payload = JSON.parse(
      Buffer.from(token.split(".")[1]!.replace(/-/g, "+").replace(/_/g, "/"), "base64").toString()
    ) as { exp?: number };
    if (!payload.exp) return { expired: false, expMs: null };
    const expMs = payload.exp * 1000;
    return { expired: Date.now() >= expMs, expMs };
  } catch {
    return { expired: false, expMs: null };
  }
}

/**
 * Pakketinfo komt van account.mtg-api.com/overview.
 * Browser (HAR): Authorization: VIAPLAY-AT <jwt> — geen cookies, geen Bearer.
 */
export async function fetchAccountOverview(
  creds: ViaplayAccountCreds,
  timeoutMs: number
): Promise<ViaplayOverview> {
  const token = normalizeAccessToken(creds.accessToken);
  if (!token) {
    return {
      ok: false,
      status: 0,
      partnerName: null,
      productNames: [],
      summary: "",
      error: "Geen accessToken",
      sessionOk: false,
    };
  }

  const tokenInfo = accessTokenExpiryInfo(token);
  const headers: Record<string, string> = {
    Accept: "*/*",
    "Content-Type": "application/json",
    "Accept-Language": "nl,en-US;q=0.9,en;q=0.8",
    Origin: "https://viaplay.com",
    Referer: "https://viaplay.com/",
    "User-Agent": VIAPLAY_USER_AGENT,
    Authorization: `VIAPLAY-AT ${token}`,
  };

  let lastStatus = 0;
  let lastError = "Overview mislukt";
  try {
    const res = await fetchJson("https://account.mtg-api.com/overview", {
      headers,
      timeoutMs: Math.min(timeoutMs, 15_000),
    });
    lastStatus = res.status;
    const body = asRecord(res.json);
    if (res.status === 200 && body) {
      const parsed = parseOverviewBody(body);
      if (parsed.ok && parsed.summary) return parsed;
      lastError = "Overview gaf geen pakketinformatie terug";
    } else {
      lastError =
        (typeof body?.message === "string" && body.message) ||
        (typeof body?.userMessage === "string" && body.userMessage) ||
        (res.status === 403
          ? "Forbidden"
          : res.status === 401
            ? "Unauthorized"
            : `Overview HTTP ${res.status}`);
    }
  } catch (err) {
    lastError = err instanceof Error ? err.message : String(err);
  }

  let sessionOk = false;
  try {
    const ping = await fetchJson("https://content.viaplay.com/pcdash-nl?language=nl", {
      headers: { ...authHeaders(creds), Accept: "application/json" },
      timeoutMs: Math.min(timeoutMs, 12_000),
    });
    const root = asRecord(ping.json);
    sessionOk = Boolean(
      ping.status === 200 &&
        (asRecord(root?._links)?.["viaplay:userData"] ||
          asRecord(root?._links)?.["viaplay:logout"])
    );
  } catch {
    /* ignore */
  }

  if (
    sessionOk &&
    (lastStatus === 401 || lastStatus === 403 || /forbidden|unauthorized/i.test(lastError))
  ) {
    lastError = tokenInfo.expired
      ? "accessToken verlopen — vernieuw tokens en Check opnieuw"
      : `overview ${lastError} (Authorization moet VIAPLAY-AT zijn)`;
  }

  return {
    ok: false,
    status: lastStatus,
    partnerName: null,
    productNames: [],
    summary: "",
    error: sessionOk
      ? `Sessie geldig, pakketinfo niet opgehaald (${lastError})`
      : lastError,
    sessionOk,
  };
}

function packageLabel(raw: unknown): string | null {
  const rec = asRecord(raw);
  if (!rec) return null;
  for (const key of ["name", "displayName", "title", "productName"]) {
    const v = rec[key];
    if (typeof v === "string" && v.trim()) return v.trim();
  }
  return null;
}

/** Alleen echte overview-velden — geen aannames over abonnementstype. */
function parseOverviewBody(body: Record<string, unknown>): ViaplayOverview {
  const partner = asRecord(body.partnerInformation);
  const partnerName =
    typeof partner?.partnerDisplayName === "string"
      ? partner.partnerDisplayName.trim()
      : null;
  const productNames = Array.isArray(partner?.productNames)
    ? partner!.productNames.map((p) => String(p).trim()).filter(Boolean)
    : [];
  const pkg =
    packageLabel(body.package) ||
    packageLabel(body.contract) ||
    packageLabel(body.rolloverPackage) ||
    packageLabel(body.promotion);
  if (pkg && !productNames.includes(pkg)) productNames.push(pkg);

  const parts = [partnerName, productNames.join(", ")].filter(Boolean);
  return {
    ok: parts.length > 0,
    status: 200,
    partnerName,
    productNames,
    summary: parts.join(" · "),
  };
}

function walk(node: unknown, visit: (n: Record<string, unknown>) => void) {
  if (!node || typeof node !== "object") return;
  if (Array.isArray(node)) {
    for (const item of node) walk(item, visit);
    return;
  }
  const rec = node as Record<string, unknown>;
  visit(rec);
  for (const [k, v] of Object.entries(rec)) {
    if (k === "images") continue;
    walk(v, visit);
  }
}

export type ViaplayEpgProduct = {
  guid: string;
  title: string;
  subtitle: string | null;
  startMs: number;
  endMs: number;
  imageUrl: string | null;
  pageUrl: string | null;
  category: string | null;
  sportLabel: string | null;
  sportBucket: string | null;
};

function parseIsoMs(raw: unknown): number | null {
  if (typeof raw === "number" && Number.isFinite(raw) && raw > 0) {
    return raw > 1e12 ? raw : raw * 1000;
  }
  const t = String(raw ?? "").trim();
  if (!t) return null;
  const ms = Date.parse(t);
  return Number.isFinite(ms) ? ms : null;
}

function sportFromPageUrl(pageUrl: string | null): {
  category: string | null;
  sportLabel: string | null;
  sportBucket: string | null;
} {
  if (!pageUrl) return { category: null, sportLabel: null, sportBucket: null };
  try {
    const path = new URL(pageUrl).pathname.toLowerCase();
    // /pcdash-nl/sport/voetbal/... or /sport/motorsport/formule-1/...
    const m = path.match(/\/sport\/([^/]+)(?:\/([^/]+))?/i);
    const cat = m?.[1] ? decodeURIComponent(m[1]) : null;
    const sub = m?.[2] ? decodeURIComponent(m[2]) : null;
    const label = sub || cat;
    let bucket: string | null = null;
    if (cat) {
      if (/motor|formule|racing|f1/i.test(`${cat} ${sub || ""}`)) bucket = "racing";
      else if (/voetbal|football|soccer/i.test(cat)) bucket = "football";
      else if (/tennis/i.test(cat)) bucket = "tennis";
      else if (/hockey|ijshockey/i.test(cat)) bucket = "hockey";
      else bucket = "sport";
    }
    return {
      category: cat,
      sportLabel: label
        ? label.replace(/-/g, " ").replace(/\b\w/g, (c) => c.toUpperCase())
        : null,
      sportBucket: bucket,
    };
  } catch {
    return { category: null, sportLabel: null, sportBucket: null };
  }
}

function pickImage(content: Record<string, unknown> | null): string | null {
  if (!content) return null;
  const images = asRecord(content.images);
  if (!images) return null;
  for (const key of [
    "landscape",
    "coverart169",
    "hero169",
    "boxart",
    "coverart23",
    "cover",
    "hero",
    "event169",
  ]) {
    const img = asRecord(images[key]);
    const url = typeof img?.url === "string" ? img.url : null;
    if (url) return url;
  }
  for (const value of Object.values(images)) {
    const img = asRecord(value);
    if (typeof img?.url === "string") return img.url;
  }
  return null;
}

export async function fetchSportDays(
  deviceKey: string,
  timeoutMs: number
): Promise<string[]> {
  const url = `https://content.viaplay.com/${deviceKey}/sport/all?language=nl`;
  const res = await fetchJson(url, {
    headers: {
      Accept: "*/*",
      "User-Agent": VIAPLAY_USER_AGENT,
      Referer: "https://viaplay.com/",
    },
    timeoutMs,
  });
  if (res.status !== 200) {
    throw new Error(`Viaplay EPG days mislukt (${res.status})`);
  }
  const root = asRecord(res.json);
  const days = root?._links && asRecord(root._links)?.["viaplay:days"];
  const list = Array.isArray(days) ? days : [];
  const out: string[] = [];
  for (const d of list) {
    const href = typeof asRecord(d)?.href === "string" ? String(asRecord(d)!.href) : "";
    const m = href.match(/[?&]date=(\d{4}-\d{2}-\d{2})/i);
    if (m?.[1]) out.push(m[1]);
  }
  return [...new Set(out)];
}

export async function fetchEpgDay(
  deviceKey: string,
  date: string,
  timeoutMs: number
): Promise<ViaplayEpgProduct[]> {
  const url = `https://content.viaplay.com/${deviceKey}/sport/all?date=${encodeURIComponent(date)}&language=nl`;
  const res = await fetchJson(url, {
    headers: {
      Accept: "*/*",
      "User-Agent": VIAPLAY_USER_AGENT,
      Referer: "https://viaplay.com/",
    },
    timeoutMs,
  });
  if (res.status !== 200) {
    throw new Error(`Viaplay EPG ${date} mislukt (${res.status})`);
  }
  return extractProducts(res.json);
}

export async function fetchSportHighlights(
  deviceKey: string,
  timeoutMs: number
): Promise<ViaplayEpgProduct[]> {
  const url = `https://content.viaplay.com/${deviceKey}/sport?language=nl`;
  const res = await fetchJson(url, {
    headers: {
      Accept: "*/*",
      "User-Agent": VIAPLAY_USER_AGENT,
      Referer: "https://viaplay.com/",
    },
    timeoutMs,
  });
  if (res.status !== 200) return [];
  return extractProducts(res.json);
}

/** Catalog-item van de Viaplay sport-sectie (plank/rail). */
export type ViaplaySportRailItem = {
  guid: string;
  title: string;
  subtitle: string | null;
  imageUrl: string | null;
  /** sport | clip | series | other */
  kind: "sport" | "clip" | "series" | "other";
  /** Speelbaar via play-live (sport/EPG) of play.viaplay.com/byguid (clip/series). */
  playMode: "live" | "vod" | null;
  durationLabel: string | null;
  startMs: number | null;
  endMs: number | null;
  pageUrl: string | null;
};

export type ViaplaySportRail = {
  id: string;
  title: string;
  items: ViaplaySportRailItem[];
};

/** HAR: web speelt via stream-href uit de rail-lijst (contextualV2), niet pas na product-fetch. */
const streamHrefCache = new Map<string, { href: string; at: number }>();
const STREAM_HREF_TTL_MS = 15 * 60_000;

function rememberStreamHref(guid: string, href: string | null | undefined): void {
  const g = String(guid || "").trim();
  const h = typeof href === "string" ? href.trim() : "";
  if (!g || !h) return;
  streamHrefCache.set(g, { href: h, at: Date.now() });
}

function cachedStreamHref(guid: string): string | null {
  const hit = streamHrefCache.get(guid);
  if (!hit) return null;
  if (Date.now() - hit.at > STREAM_HREF_TTL_MS) {
    streamHrefCache.delete(guid);
    return null;
  }
  return hit.href;
}

function streamHref(product: Record<string, unknown>): string | null {
  const links = asRecord(product._links);
  const stream = asRecord(links?.["viaplay:stream"]);
  const href = typeof stream?.href === "string" ? stream.href : null;
  return href?.trim() || null;
}

function isPromoVodTitle(title: string | null | undefined): boolean {
  return /viaplay\s*presents|don'?t\s*go|viaplay\s*documentary/i.test(
    String(title || "")
  );
}

function parseDurationLabel(content: Record<string, unknown> | null): string | null {
  const duration = asRecord(content?.duration);
  if (typeof duration?.readable === "string" && duration.readable.trim()) {
    return duration.readable.trim();
  }
  const ms = Number(duration?.milliseconds);
  if (!Number.isFinite(ms) || ms <= 0) return null;
  const totalSec = Math.round(ms / 1000);
  const m = Math.floor(totalSec / 60);
  const s = totalSec % 60;
  if (m >= 60) {
    const h = Math.floor(m / 60);
    return `${h}:${String(m % 60).padStart(2, "0")}:${String(s).padStart(2, "0")}`;
  }
  return `${m}:${String(s).padStart(2, "0")}`;
}

function productTitle(content: Record<string, unknown> | null, guid: string): string {
  if (!content) return guid;
  if (typeof content.title === "string" && content.title.trim()) return content.title.trim();
  const series = asRecord(content.series);
  if (typeof series?.title === "string" && series.title.trim()) return series.title.trim();
  if (typeof content.originalTitle === "string" && content.originalTitle.trim()) {
    return content.originalTitle.trim();
  }
  return guid;
}

function productToRailItem(node: Record<string, unknown>): ViaplaySportRailItem | null {
  const system = asRecord(node.system);
  const content = asRecord(node.content);
  const guid = String(system?.guid ?? "").trim();
  if (!guid) return null;
  const type = String(node.type ?? "").trim().toLowerCase();
  const epg = asRecord(node.epg);
  const startMs = epg ? parseIsoMs(epg.start ?? epg.startTime) : null;
  const endMs = epg ? parseIsoMs(epg.end ?? epg.endTime ?? epg.stop) : null;
  const href = streamHref(node);
  const links = asRecord(node._links);
  const page =
    (typeof asRecord(links?.["viaplay:page"])?.href === "string"
      ? String(asRecord(links!["viaplay:page"])!.href)
      : null) ||
    (typeof asRecord(links?.self)?.href === "string"
      ? String(asRecord(links!.self)!.href)
      : null);

  let kind: ViaplaySportRailItem["kind"] = "other";
  if (type === "sport") kind = "sport";
  else if (type === "clip") kind = "clip";
  else if (type === "series" || type === "sportseries" || type === "episode") kind = "series";
  else if (type === "movie" || type === "film") kind = "series"; // docs/specials → VOD byguid

  let playMode: ViaplaySportRailItem["playMode"] = null;
  if (href?.includes("play-live.viaplay.com") || (kind === "sport" && startMs != null)) {
    playMode = "live";
  } else if (
    href?.includes("play.viaplay.com/api/stream/byguid") ||
    kind === "clip" ||
    (kind === "series" && type !== "sportseries")
  ) {
    // sportSeries is vaak een categorie-pagina zonder directe stream
    playMode = "vod";
  } else if (type === "movie" || type === "film") {
    playMode = "vod";
  }

  const title = productTitle(content, guid);
  const subtitle =
    String(
      content?.originalTitle ?? content?.synopsis ?? content?.description ?? ""
    ).trim() || null;

  rememberStreamHref(guid, href);

  return {
    guid,
    title,
    subtitle: subtitle === title ? null : subtitle,
    imageUrl: pickImage(content),
    kind,
    playMode,
    durationLabel: parseDurationLabel(content),
    startMs,
    endMs,
    pageUrl: page,
  };
}

function blocksFromPage(json: unknown): Array<Record<string, unknown>> {
  const root = asRecord(json);
  const embedded = asRecord(root?._embedded);
  const blocks = embedded?.["viaplay:blocks"];
  if (!Array.isArray(blocks)) return [];
  const out: Array<Record<string, unknown>> = [];
  for (const b of blocks) {
    const rec = asRecord(b);
    if (rec) out.push(rec);
  }
  return out;
}

function productsFromBlock(block: Record<string, unknown>): ViaplaySportRailItem[] {
  const embedded = asRecord(block._embedded);
  const products = embedded?.["viaplay:products"];
  if (!Array.isArray(products)) return [];
  const out: ViaplaySportRailItem[] = [];
  const seen = new Set<string>();
  for (const raw of products) {
    const node = asRecord(raw);
    if (!node) continue;
    const item = productToRailItem(node);
    if (!item || seen.has(item.guid)) continue;
    seen.add(item.guid);
    out.push(item);
  }
  return out;
}

async function fetchSportBlockPage(
  deviceKey: string,
  blockId: string,
  pageNumber: number,
  timeoutMs: number,
  creds?: ViaplayAccountCreds | null
): Promise<ViaplaySportRailItem[]> {
  const u = new URL(`https://content.viaplay.com/${deviceKey}/sport`);
  u.searchParams.set("blockId", blockId);
  u.searchParams.set("partial", "1");
  u.searchParams.set("pageNumber", String(pageNumber));
  u.searchParams.set("language", "nl");
  const headers: Record<string, string> = {
    Accept: "*/*",
    "User-Agent": VIAPLAY_USER_AGENT,
    Referer: "https://viaplay.com/sport",
  };
  if (creds) Object.assign(headers, authHeaders(creds));
  const res = await fetchJson(u.toString(), { headers, timeoutMs });
  if (res.status !== 200) return [];
  const blocks = blocksFromPage(res.json);
  const block = blocks[0] || asRecord(res.json);
  return block ? productsFromBlock(block) : [];
}

/**
 * Officiële Viaplay sport-sectie als hub-planken (HAR: /pcdash-nl/sport).
 * Lege list-blocks worden 1× bijgeladen via blockId&partial=1.
 */
export async function fetchSportRails(
  deviceKey: string,
  timeoutMs: number,
  creds?: ViaplayAccountCreds | null
): Promise<ViaplaySportRail[]> {
  const url = `https://content.viaplay.com/${deviceKey}/sport?language=nl`;
  const headers: Record<string, string> = {
    Accept: "*/*",
    "User-Agent": VIAPLAY_USER_AGENT,
    Referer: "https://viaplay.com/sport",
  };
  if (creds) Object.assign(headers, authHeaders(creds));
  const res = await fetchJson(url, { headers, timeoutMs });
  if (res.status !== 200) {
    throw new Error(`Viaplay sport-sectie mislukt (${res.status})`);
  }

  const skipTitles = /^(favorites|schema|featurebox)/i;
  const rails: ViaplaySportRail[] = [];

  for (const block of blocksFromPage(res.json)) {
    const type = String(block.type ?? "").trim().toLowerCase();
    if (type !== "list" && type !== "singleproductpromo") continue;
    const id = String(block.id ?? "").trim();
    const title = String(block.title ?? block.profileBlockTitle ?? "").trim();
    if (!id || !title || skipTitles.test(title)) continue;

    let items = productsFromBlock(block);
    if (!items.length) {
      try {
        items = await fetchSportBlockPage(deviceKey, id, 1, timeoutMs, creds);
      } catch {
        items = [];
      }
    }
    // Promo zonder embedded products: skip
    if (!items.length) continue;
    // Alleen speelbare items (geen categorie-tegels zoals sportSeries)
    const playable = items.filter((it) => it.playMode != null).slice(0, 40);
    if (!playable.length) continue;
    rails.push({ id, title, items: playable });
  }
  return rails;
}

function extractProducts(json: unknown): ViaplayEpgProduct[] {
  const out: ViaplayEpgProduct[] = [];
  const seen = new Set<string>();
  walk(json, (node) => {
    const system = asRecord(node.system);
    const content = asRecord(node.content);
    const epg = asRecord(node.epg);
    const guid = String(system?.guid ?? "").trim();
    if (!guid || !epg || seen.has(guid)) return;
    const startMs = parseIsoMs(epg.start ?? epg.startTime);
    const endMs = parseIsoMs(epg.end ?? epg.endTime ?? epg.stop);
    if (startMs == null || endMs == null || endMs <= startMs) return;
    seen.add(guid);
    const links = asRecord(node._links);
    const page =
      (typeof asRecord(links?.["viaplay:page"])?.href === "string"
        ? String(asRecord(links!["viaplay:page"])!.href)
        : null) ||
      (typeof asRecord(links?.self)?.href === "string"
        ? String(asRecord(links!.self)!.href)
        : null);
    const sport = sportFromPageUrl(page);
    out.push({
      guid,
      title: String(content?.title ?? system?.guid ?? guid).trim(),
      subtitle: String(content?.subtitle ?? content?.description ?? "").trim() || null,
      startMs,
      endMs,
      imageUrl: pickImage(content),
      pageUrl: page,
      category: sport.category,
      sportLabel: sport.sportLabel,
      sportBucket: sport.sportBucket,
    });
  });
  return out;
}

export async function playByMediaGuid(
  creds: ViaplayAccountCreds,
  mediaGuidRaw: string,
  opts: { deviceKey: string; timeoutMs: number }
): Promise<ViaplayPlayResult> {
  const mediaGuid = toMediaGuid(mediaGuidRaw);
  const u = new URL("https://play-live.viaplay.com/api/stream/bymediaguid");
  u.searchParams.set("deviceId", creds.deviceId || randomUUID());
  u.searchParams.set("deviceName", "web");
  u.searchParams.set("deviceType", "pc");
  u.searchParams.set("userAgent", VIAPLAY_USER_AGENT);
  u.searchParams.set("deviceKey", opts.deviceKey);
  u.searchParams.set("mediaGuid", mediaGuid);
  u.searchParams.set("nocc", "autoplayer");
  if (creds.profileId) u.searchParams.set("profileId", creds.profileId);

  const res = await fetchJson(u.toString(), {
    headers: authHeaders(creds),
    timeoutMs: opts.timeoutMs,
  });
  const body = asRecord(res.json);
  if (res.status !== 200 || !body) {
    const msg =
      (typeof body?.message === "string" && body.message) ||
      `play-live mislukt (${res.status})`;
    throw new Error(msg);
  }
  return parsePlayStreamBody(body, mediaGuid);
}

function parsePlayStreamBody(
  body: Record<string, unknown>,
  id: string
): ViaplayPlayResult {
  const links = asRecord(body._links);
  const media = asRecord(links?.["viaplay:media"]);
  const license =
    asRecord(links?.["viaplay:widevineLicense"]) || asRecord(links?.["viaplay:license"]);
  const mpdUrl = typeof media?.href === "string" ? media.href.trim() : "";
  if (!mpdUrl) throw new Error("Geen viaplay:media in play-response");
  const product = asRecord(body.product);
  const channel = asRecord(body.channel) || asRecord(asRecord(body.streamingSession)?.channel);
  return {
    mediaGuid: id,
    mpdUrl,
    licenseUrl: typeof license?.href === "string" ? license.href : null,
    licenseAuth: typeof license?.auth === "string" ? license.auth : null,
    channelName: typeof channel?.channelName === "string" ? channel.channelName : null,
    stationId: typeof channel?.stationId === "string" ? channel.stationId : null,
    title:
      typeof asRecord(product?.content)?.title === "string"
        ? String(asRecord(product!.content)!.title)
        : null,
  };
}

/**
 * Bouw play.viaplay.com URL uit templated stream-href (content-API).
 * RFC 6570 `{?deviceId,...}` → `?` (niet strippen: anders blijft `byguid&deviceKey=` over).
 */
export function expandViaplayStreamHref(
  hrefRaw: string,
  creds: ViaplayAccountCreds,
  opts: { deviceKey: string; guid?: string }
): string {
  const cleaned = hrefRaw
    .replace(/\{\?[^}]+\}/g, "?")
    .replace(/\?&/, "?")
    .replace(/\?{2,}/g, "?");
  const u = new URL(cleaned);
  u.searchParams.set("deviceId", creds.deviceId || randomUUID());
  u.searchParams.set("deviceName", "web");
  u.searchParams.set("deviceType", "pc");
  u.searchParams.set("userAgent", VIAPLAY_USER_AGENT);
  u.searchParams.set("deviceKey", opts.deviceKey);
  u.searchParams.set("cse", "true");
  u.searchParams.set("win10edge", "true");
  if (!u.searchParams.get("defaultAvailabilityContext")) {
    u.searchParams.set("defaultAvailabilityContext", "svod");
  }
  if (creds.profileId) u.searchParams.set("profileId", creds.profileId);
  const guid = opts.guid || u.searchParams.get("guid") || "";
  if (guid && !u.searchParams.get("templatedproducturl")) {
    u.searchParams.set(
      "templatedproducturl",
      `https://content.viaplay.com/{deviceKey}/sport/${guid}?partial=true`
    );
  }
  return u.toString();
}

function buildHarByguidUrl(
  creds: ViaplayAccountCreds,
  guid: string,
  opts: {
    deviceKey: string;
    productUrl: string;
    returnUrl: string;
    sectionPath: string;
    /** Rijkere contextualV2 uit rail-lijst (HAR). */
    contextualv2url?: string | null;
  }
): string {
  // Altijd canonieke producturl zoals web-HAR — geen profileId/extra query.
  const productUrlFinal = `https://content.viaplay.com/${opts.deviceKey}/sport/${guid}?partial=true`;
  const u = new URL("https://play.viaplay.com/api/stream/byguid");
  u.searchParams.set("deviceId", creds.deviceId || randomUUID());
  u.searchParams.set("deviceName", "web");
  u.searchParams.set("deviceType", "pc");
  u.searchParams.set("userAgent", VIAPLAY_USER_AGENT);
  u.searchParams.set("deviceKey", opts.deviceKey);
  u.searchParams.set("cse", "true");
  u.searchParams.set(
    "splitIOFlagIds",
    "all_sports_beyondLiveBeacon_on,web_player_pause_ads_on"
  );
  u.searchParams.set("guid", guid);
  u.searchParams.set("returnurl", opts.returnUrl);
  u.searchParams.set("producturl", productUrlFinal);
  u.searchParams.set(
    "contextualv2url",
    (opts.contextualv2url && String(opts.contextualv2url).trim()) ||
      `https://content.viaplay.com/${opts.deviceKey}/sport/${guid}?contextualV2=true&productType=clip`
  );
  u.searchParams.set(
    "templatedproducturl",
    `https://content.viaplay.com/{deviceKey}/sport/${guid}?partial=true`
  );
  u.searchParams.set("sectionPath", opts.sectionPath);
  u.searchParams.set("defaultAvailabilityContext", "svod");
  if (creds.profileId) u.searchParams.set("profileId", creds.profileId);
  u.searchParams.set("win10edge", "true");
  return u.toString();
}

function playBodyGuid(body: Record<string, unknown>): string | null {
  const product = asRecord(body.product);
  const system = asRecord(product?.system);
  return typeof system?.guid === "string" ? system.guid.trim() : null;
}

/** HAR-success: product-link + guid + productType=clip. Promo-docu faalt hierop. */
function assertVodPlayMatchesGuid(
  body: Record<string, unknown>,
  guid: string,
  played: ViaplayPlayResult
): void {
  const responseGuid = playBodyGuid(body);
  if (responseGuid && responseGuid !== guid) {
    throw new Error(`Viaplay gaf andere guid (${responseGuid}) i.p.v. ${guid}`);
  }
  if (isPromoVodTitle(played.title)) {
    throw new Error(`Viaplay gaf promo-stream (“${played.title}”)`);
  }
  const links = asRecord(body._links);
  for (const key of ["viaplay:product", "viaplay:productPage"] as const) {
    const href = asRecord(links?.[key])?.href;
    if (typeof href === "string" && href.trim() && !href.includes(guid)) {
      throw new Error(`Viaplay product-link mismatch (${key})`);
    }
  }
  const product = asRecord(body.product);
  const productType =
    typeof product?.productType === "string"
      ? product.productType.trim().toLowerCase()
      : "";
  if (/vp-sports-clip|sports-clip/i.test(guid) && productType && productType !== "clip") {
    throw new Error(`Viaplay productType “${productType}” i.p.v. clip`);
  }
  const durationMs = Number(body.duration);
  // Samenvattingen < ~2u; Don't go-feature is veel langer
  if (
    /vp-sports-clip|sports-clip/i.test(guid) &&
    Number.isFinite(durationMs) &&
    durationMs > 2.5 * 60 * 60 * 1000
  ) {
    throw new Error(`Viaplay gaf te lange stream (${Math.round(durationMs / 60000)} min)`);
  }
}

function contextualv2FromStreamHref(href: string | null | undefined): string | null {
  if (!href) return null;
  try {
    const cleaned = href
      .replace(/\{\?[^}]+\}/g, "?")
      .replace(/\?&/, "?")
      .replace(/\?{2,}/g, "?");
    return new URL(cleaned).searchParams.get("contextualv2url");
  } catch {
    return null;
  }
}

async function fetchProductStreamMeta(
  creds: ViaplayAccountCreds,
  productUrl: string,
  timeoutMs: number
): Promise<{ streamHref: string | null; title: string | null; guid: string | null }> {
  let url = productUrl;
  try {
    const u = new URL(productUrl);
    u.searchParams.set("partial", "true");
    if (creds.profileId && !u.searchParams.get("profileId")) {
      u.searchParams.set("profileId", creds.profileId);
    }
    url = u.toString();
  } catch {
    /* keep */
  }
  const res = await fetchJson(url, {
    headers: { ...authHeaders(creds), Accept: "application/json" },
    timeoutMs,
  });
  if (res.status !== 200) {
    return { streamHref: null, title: null, guid: null };
  }
  const root = asRecord(res.json);
  const embedded = asRecord(root?._embedded);
  const product =
    asRecord(embedded?.["viaplay:product"]) ||
    asRecord(root?.product) ||
    root;
  const links = asRecord(product?._links);
  const stream =
    asRecord(links?.["viaplay:stream"]) || asRecord(links?.["viaplay:templatedStream"]);
  const href = typeof stream?.href === "string" ? stream.href.trim() : null;
  const content = asRecord(product?.content);
  const system = asRecord(product?.system);
  const title =
    typeof content?.title === "string"
      ? content.title.trim()
      : typeof root?.title === "string"
        ? String(root.title).trim()
        : null;
  const guid = typeof system?.guid === "string" ? system.guid.trim() : null;
  return { streamHref: href, title, guid };
}

/**
 * VOD / clips / samenvattingen — HAR: play.viaplay.com/api/stream/byguid
 *
 * Web: rail stream-href → byguid (producturl/cse/contextualV2/win10edge) + session-cookie.
 * Zonder die context geeft Viaplay een 200 met promo-docu (“Don't go”) i.p.v. 403.
 */
export async function playByGuid(
  creds: ViaplayAccountCreds,
  guidRaw: string,
  opts: {
    deviceKey: string;
    timeoutMs: number;
    productUrl?: string | null;
    returnUrl?: string | null;
    sectionPath?: string | null;
  }
): Promise<ViaplayPlayResult> {
  const guid = String(guidRaw || "").trim();
  if (!guid) throw new Error("Geen Viaplay guid");

  const rawProduct = (opts.productUrl && String(opts.productUrl).trim()) || "";
  const productUrl =
    rawProduct && rawProduct.includes(guid)
      ? rawProduct
      : `https://content.viaplay.com/${opts.deviceKey}/sport/${guid}?partial=true`;

  const returnUrl =
    (opts.returnUrl && String(opts.returnUrl).trim()) ||
    `https://content.viaplay.com/${opts.deviceKey}/sport`;
  const sectionPath = (opts.sectionPath && String(opts.sectionPath).trim()) || "/sport";

  const listingHref = cachedStreamHref(guid);
  let productHref: string | null = null;
  let pageTitle: string | null = null;
  try {
    const meta = await fetchProductStreamMeta(creds, productUrl, opts.timeoutMs);
    pageTitle = meta.title;
    if (meta.streamHref) {
      productHref = meta.streamHref;
      rememberStreamHref(guid, meta.streamHref);
    }
  } catch {
    /* har-url hieronder */
  }

  const contextualv2url =
    contextualv2FromStreamHref(listingHref) ||
    contextualv2FromStreamHref(productHref);

  // Eerst exacte HAR-query (betrouwbaar), daarna eventuele stream-hrefs.
  const playUrls: string[] = [];
  const seen = new Set<string>();
  const pushUrl = (url: string) => {
    if (!url || seen.has(url)) return;
    seen.add(url);
    playUrls.push(url);
  };
  pushUrl(
    buildHarByguidUrl(creds, guid, {
      deviceKey: opts.deviceKey,
      productUrl,
      returnUrl,
      sectionPath,
      contextualv2url,
    })
  );
  for (const href of [listingHref, productHref]) {
    if (!href || !/play\.viaplay\.com\/api\/stream\/byguid/i.test(href)) continue;
    pushUrl(
      expandViaplayStreamHref(href, creds, { deviceKey: opts.deviceKey, guid })
    );
  }

  let lastError: Error | null = null;
  for (const playUrl of playUrls) {
    try {
      const res = await fetchJson(playUrl, {
        headers: authHeaders(creds),
        timeoutMs: opts.timeoutMs,
      });
      const body = asRecord(res.json);
      if (res.status !== 200 || !body) {
        const msg =
          (typeof body?.message === "string" && body.message) ||
          `play-byguid mislukt (${res.status})`;
        throw new Error(msg);
      }
      const played = parsePlayStreamBody(body, guid);
      assertVodPlayMatchesGuid(body, guid, played);
      if (!played.title && pageTitle && !isPromoVodTitle(pageTitle)) {
        played.title = pageTitle;
      }
      return played;
    } catch (err) {
      lastError = err instanceof Error ? err : new Error(String(err));
    }
  }

  throw lastError || new Error("Viaplay VOD-play mislukt");
}

/** Bouw MPD-URL met EPG start/stop kap (seconden). */
export function kapMpdUrl(
  mpdUrl: string,
  startMs: number,
  endMs: number
): string[] {
  const startSec = Math.floor(startMs / 1000);
  const stopSec = Math.floor(endMs / 1000);
  try {
    const u = new URL(mpdUrl);
    const file = u.pathname.split("/").pop() || "dash.mpd";
    const dir = mpdUrl.replace(/\/[^/]+$/, "");
    return [
      `${dir}/start/${startSec}/stop/${stopSec}/${file}`,
      `${dir}/start/${startSec}/stop/${stopSec}/index.mpd`,
      mpdUrl,
    ];
  } catch {
    return [mpdUrl];
  }
}

export async function fetchMpdXml(
  url: string,
  timeoutMs: number
): Promise<{ status: number; xml: string; url: string }> {
  const response = await fetch(url, {
    headers: {
      Accept: "*/*",
      "User-Agent": VIAPLAY_USER_AGENT,
      Referer: "https://viaplay.com/",
    },
    signal: AbortSignal.timeout(timeoutMs),
  });
  const xml = await response.text();
  return { status: response.status, xml, url };
}

export function extractPsshFromMpd(xml: string): string | null {
  const widevine = xml.match(
    /<ContentProtection\b[^>]*schemeIdUri=["']urn:uuid:edef8ba9-79d6-4ace-a3c8-27dcd51d21ed["'][\s\S]*?<\/ContentProtection>/i
  )?.[0];
  const fromCp = widevine?.match(
    /<(?:[\w-]+:)?pssh\b[^>]*>([^<]+)<\/(?:[\w-]+:)?pssh>/i
  )?.[1]?.trim();
  if (fromCp) return fromCp;
  return (
    xml.match(/<(?:[\w-]+:)?pssh\b[^>]*>([^<]+)<\/(?:[\w-]+:)?pssh>/i)?.[1]?.trim() ??
    null
  );
}

export function mpdHasContentProtection(xml: string): boolean {
  return /ContentProtection/i.test(xml) || /<(?:[\w-]+:)?pssh\b/i.test(xml);
}

/** Probe kap-candidates; prefer first 200 with MPD body. Prefer DRM if available. */
export async function resolveKapMpd(
  baseMpd: string,
  startMs: number,
  endMs: number,
  timeoutMs: number
): Promise<{ mpdUrl: string; xml: string; hasPssh: boolean; pssh: string | null }> {
  const candidates = kapMpdUrl(baseMpd, startMs, endMs);
  let fallback: { mpdUrl: string; xml: string } | null = null;
  for (const url of candidates) {
    try {
      const res = await fetchMpdXml(url, timeoutMs);
      if (res.status !== 200 || !/<MPD[\s>]/i.test(res.xml)) continue;
      const pssh = extractPsshFromMpd(res.xml);
      const hasPssh = !!pssh || mpdHasContentProtection(res.xml);
      if (hasPssh) {
        return { mpdUrl: res.url, xml: res.xml, hasPssh: true, pssh };
      }
      if (!fallback) fallback = { mpdUrl: res.url, xml: res.xml };
    } catch {
      /* next */
    }
  }
  if (fallback) {
    return {
      mpdUrl: fallback.mpdUrl,
      xml: fallback.xml,
      hasPssh: false,
      pssh: null,
    };
  }
  throw new Error("Geen bruikbare MPD (kap/base)");
}