// native-webkit.mjs — the Mac app in a call with Safari's engine.
//
// Driven by TestNativeMacWebKit (make native-webkit). 2026-10-03: Till,
// on an iPhone in Safari, said a call with Paul on the Mac app "kept
// cutting in and out", with nothing recorded. This is the nearest this
// machine gets: Playwright's WebKit with its mock camera and microphone,
// on macOS, against the shipping app core (CallsInterop). It is NOT iOS
// Safari — no cellular radio, no background suspension, no audio session
// interruptions, no Low Power Mode — and it cannot shape packet loss or
// jitter (that needs root for dnctl/pfctl). What it can hold:
//
//   - media both ways, and what was negotiated: the codecs each way and
//     Opus's in-band FEC;
//   - the app's sender giving way on a thin path (its bandwidth estimate
//     capped, as `uplink` does) while WebKit keeps decoding and hearing;
//   - the tab coming back after the system ended its camera and
//     microphone (iOS does, in the background): the room opens them again
//     and the app hears and sees it again (room.js comeBack).
//
//   node test/browser/native-webkit.mjs <origin> <room> <binary>
import { webkit } from 'playwright';
import { spawn } from 'node:child_process';
import { createInterface } from 'node:readline';
import assert from 'node:assert/strict';

const [origin, room, binary] = process.argv.slice(2);
const browser = await webkit.launch({ headless: true });
const context = await browser.newContext({ permissions: ['camera', 'microphone'] });
await context.addCookies([{ name: process.env.CALLS_COOKIE_NAME, value: process.env.CALLS_COOKIE_A, url: origin }]);
const page = await context.newPage();
await page.addInitScript(() => {
  const Native = window.RTCPeerConnection;
  window.__pcs = new Set();
  window.RTCPeerConnection = class extends Native {
    constructor(...args) { super(...args); window.__pcs.add(this); }
  };
  // The streams the room opened, so the test can end their tracks as the
  // system would.
  window.__gum = [];
  const gum = navigator.mediaDevices.getUserMedia.bind(navigator.mediaDevices);
  navigator.mediaDevices.getUserMedia = async (c) => {
    const s = await gum(c);
    window.__gum.push(s);
    return s;
  };
});

let native;
let sample = null;
let exited = false;
const wait = async (predicate, label, seconds = 40) => {
  const until = Date.now() + seconds * 1000;
  while (Date.now() < until) {
    if (exited) throw new Error('native executable exited');
    if (await predicate()) return;
    await new Promise((r) => setTimeout(r, 250));
  }
  throw new Error(label + ': ' + JSON.stringify(sample && sample.stats));
};

// What WebKit is receiving from the app and sending to it, off its own
// connection's stats.
const webkitStats = () => page.evaluate(async () => {
  const out = { videoIn: null, audioIn: null, videoOut: null, audioOut: null, fec: null, pair: null };
  for (const pc of window.__pcs) {
    if (pc.connectionState !== 'connected') continue;
    const stats = await pc.getStats();
    const codecs = {};
    stats.forEach((r) => { if (r.type === 'codec') codecs[r.id] = r; });
    stats.forEach((r) => {
      const codec = r.codecId && codecs[r.codecId] ? codecs[r.codecId].mimeType + (codecs[r.codecId].sdpFmtpLine ? ' ' + codecs[r.codecId].sdpFmtpLine : '') : '';
      if (r.type === 'inbound-rtp' && r.kind === 'video') {
        out.videoIn = { codec, framesDecoded: r.framesDecoded || 0, width: r.frameWidth || 0, height: r.frameHeight || 0,
          fps: r.framesPerSecond || 0, bytes: r.bytesReceived || 0, lost: r.packetsLost || 0, freezes: r.freezeCount || 0 };
      }
      if (r.type === 'inbound-rtp' && r.kind === 'audio') {
        out.audioIn = { codec, bytes: r.bytesReceived || 0, energy: r.totalAudioEnergy || 0, concealed: r.concealedSamples || 0,
          samples: r.totalSamplesReceived || 0, lost: r.packetsLost || 0, fecRecovered: r.fecPacketsReceived || 0 };
      }
      if (r.type === 'outbound-rtp' && r.kind === 'video') out.videoOut = { codec, frames: r.framesEncoded || 0 };
      if (r.type === 'outbound-rtp' && r.kind === 'audio') out.audioOut = { codec, bytes: r.bytesSent || 0 };
      if (r.type === 'candidate-pair' && r.nominated && r.state === 'succeeded') out.pair = { rtt: r.currentRoundTripTime };
    });
    const sdp = (pc.remoteDescription && pc.remoteDescription.sdp) || '';
    const opus = /a=rtpmap:(\d+) opus\/48000/i.exec(sdp);
    if (opus) {
      const fmtp = new RegExp('a=fmtp:' + opus[1] + ' ([^\\r\\n]*)').exec(sdp);
      out.fec = fmtp ? fmtp[1] : '';
    }
    break;
  }
  return out;
});

try {
  page.on('pageerror', (e) => console.log('page error', String(e)));
  await page.goto(`${origin}/m/${room}`);
  await page.waitForFunction(() => !!window.meet);
  native = spawn(binary, [], { stdio: ['pipe', 'pipe', 'pipe'] });
  native.on('exit', () => { exited = true; });
  native.stdin.write(process.env.CALLS_NATIVE_INPUT + '\n');
  createInterface({ input: native.stdout }).on('line', (text) => {
    try {
      const value = JSON.parse(text);
      if (value.stats) sample = value;
    } catch {}
  });
  native.stderr.resume();
  // WebKit wants a gesture before a remote <video> may play with sound:
  // the room's "click anywhere" is that gesture.
  const nudge = setInterval(() => { page.mouse.click(5, 300).catch(() => {}); }, 2000);

  await wait(() => sample && sample.stats.framesDecoded > 15 && sample.stats.audioBytesReceived > 0,
    'the app decodes WebKit video and receives its audio');
  console.log('PASS the app decodes WebKit’s video and receives its audio');
  await wait(async () => {
    const s = await webkitStats();
    return s.videoIn && s.videoIn.framesDecoded > 15 && s.audioIn && s.audioIn.bytes > 0;
  }, 'WebKit decodes the app’s video and receives its audio');
  let s = await webkitStats();
  console.log('PASS WebKit decodes the app’s video and receives its audio');
  console.log('negotiated ' + JSON.stringify({
    appToWebKitVideo: s.videoIn.codec, appToWebKitAudio: s.audioIn.codec,
    webKitToAppVideo: s.videoOut && s.videoOut.codec, webKitToAppAudio: s.audioOut && s.audioOut.codec,
    opusFmtpFromApp: s.fec,
    received: { width: s.videoIn.width, height: s.videoIn.height, fps: s.videoIn.fps },
  }));
  assert.match(s.fec || '', /useinbandfec=1/, 'the app offers or answers Opus with in-band FEC');
  console.log('PASS Opus in-band FEC is negotiated from the app');

  // A thin path from the app: its bandwidth estimate capped at 300 kbit/s,
  // as a phone on a poor cellular link would hold it. The sender should
  // give way (resolution or rate) and the sound should carry on.
  native.stdin.write('uplink 300000\n');
  await new Promise((r) => setTimeout(r, 12000));
  const before = await webkitStats();
  await new Promise((r) => setTimeout(r, 5000));
  const after = await webkitStats();
  const kbps = ((after.videoIn.bytes - before.videoIn.bytes) * 8) / 5000;
  const decoded = after.videoIn.framesDecoded - before.videoIn.framesDecoded;
  const audioGrew = after.audioIn.bytes - before.audioIn.bytes;
  console.log('thin path ' + JSON.stringify({ videoKbps: Math.round(kbps), framesIn5s: decoded,
    width: after.videoIn.width, height: after.videoIn.height, audioBytesIn5s: audioGrew,
    concealed: after.audioIn.concealed - before.audioIn.concealed, freezes: after.videoIn.freezes }));
  assert.ok(kbps < 400, 'the app’s video gave way to the 300 kbit/s cap (' + Math.round(kbps) + ' kbit/s)');
  assert.ok(decoded > 10, 'WebKit kept decoding video on the thin path (' + decoded + ' frames in 5 s)');
  assert.ok(audioGrew > 5000, 'and kept receiving sound (' + audioGrew + ' bytes in 5 s)');
  console.log('PASS on a thin path the app gives way and WebKit keeps the picture and the sound');
  native.stdin.write('uplink 0\n');

  // The system ending the tab's camera and microphone, as iOS does with
  // Safari in the background, and the tab coming back to the front.
  const appBefore = { audio: sample.stats.audioBytesReceived, frames: sample.stats.framesDecoded };
  await page.evaluate(() => {
    for (const s of window.__gum) for (const t of s.getTracks()) t.stop();
    let shown = 'hidden';
    Object.defineProperty(document, 'visibilityState', { configurable: true, get: () => shown });
    Object.defineProperty(document, 'hidden', { configurable: true, get: () => shown === 'hidden' });
    document.dispatchEvent(new Event('visibilitychange'));
    window.__show = () => { shown = 'visible'; document.dispatchEvent(new Event('visibilitychange')); };
  });
  await new Promise((r) => setTimeout(r, 3000));
  const stalled = { audio: sample.stats.audioBytesReceived, frames: sample.stats.framesDecoded };
  await page.evaluate(() => window.__show());
  await wait(async () => {
    const local = await page.evaluate(() => window.meet.local());
    return local.length >= 2 && local.every((t) => t.state === 'live');
  }, 'the room opens the camera and microphone again when the tab is back', 15);
  console.log('PASS the room opens the camera and microphone again when the tab is back');
  const reopened = { audio: sample.stats.audioBytesReceived, frames: sample.stats.framesDecoded };
  await wait(() => sample.stats.audioBytesReceived > reopened.audio + 4000 && sample.stats.framesDecoded > reopened.frames + 15,
    'the app hears and sees WebKit again', 20);
  console.log('PASS the app hears and sees WebKit again ' + JSON.stringify({ appBefore, stalled, reopened,
    after: { audio: sample.stats.audioBytesReceived, frames: sample.stats.framesDecoded } }));

  clearInterval(nudge);
  native.stdin.write('leave\n');
  await new Promise((r) => setTimeout(r, 1000));
} catch (err) {
  console.log('FAIL ' + (err && err.message ? err.message : String(err)));
  process.exitCode = 1;
} finally {
  if (native && !exited) native.kill();
  await browser.close();
}