/** Privacy-gated WebRTC transport for the shared office signaling contract. */
import {
  advanceScreenShareStreamCursor,
  isScreenShareGrantActive,
  parseScreenShareServerMessage,
} from "./signalingValidation.ts";
import {
  SCREEN_SHARE_SIGNALING_PROTOCOL_VERSION,
  type ScreenShareAccessGrant,
  type ScreenShareBinding,
  type ScreenShareClientMessage,
  type ScreenShareCredential,
  type ScreenShareParticipant,
  type ScreenSharePeerMessage,
  type ScreenShareResumeGrant,
  type ScreenShareRole,
  type ScreenShareServerMessage,
  type ScreenShareSignalPayload,
  type ScreenShareStreamCursor,
} from "./signalingTypes.ts";
import type { MediaAuthorizationDecision } from "./types.ts";

export type RemoteMediaRole = ScreenShareRole;
export type RemoteMediaStatus = "idle" | "connecting" | "live" | "reconnecting" | "stopped" | "revoked" | "disposed";

export interface RemoteMediaConsent { authorized: boolean; optedIn: boolean }
export interface RemoteMediaState {
  role: RemoteMediaRole;
  status: RemoteMediaStatus;
  binding: ScreenShareBinding;
  sessionId: string | null;
  participantCount: number;
  reconnectAttempt: number;
  hasRemoteVideo: boolean;
}
export interface RemoteMediaEndpoints { join: string; signal: string; events: string; leave: string }
export interface RemoteMediaTimers {
  setTimeout(callback: () => void, delayMs: number): ReturnType<typeof setTimeout>;
  clearTimeout(handle: ReturnType<typeof setTimeout>): void;
}
export interface RemoteOfficeMediaOptions {
  role: RemoteMediaRole;
  binding: ScreenShareBinding;
  /** Preferred: the app's authenticated fetch wrapper. Tokens remain in POST bodies. */
  authenticatedFetch?: typeof globalThis.fetch;
  fetch?: typeof globalThis.fetch;
  peerConnectionFactory?: (configuration?: RTCConfiguration) => RTCPeerConnection;
  peerConnectionConfiguration?: RTCConfiguration;
  endpoints?: Partial<RemoteMediaEndpoints>;
  timers?: RemoteMediaTimers;
  now?: () => number;
  reconnectBaseMs?: number;
  reconnectMaximumMs?: number;
  onStateChange?(state: RemoteMediaState): void;
  onError?(error: Error): void;
}
export interface PresenterStart {
  consent: RemoteMediaConsent;
  /** Caller-owned. Exactly one live video track is published and never stopped here. */
  stream: MediaStream;
  video: HTMLVideoElement;
}
export interface ViewerStart {
  /** A current `authorizeMediaSurface` decision with explicit viewer opt-in. */
  decision: MediaAuthorizationDecision;
  video: HTMLVideoElement;
}
export interface RemoteOfficeMedia {
  startPresenter(input: PresenterStart): Promise<void>;
  startViewer(input: ViewerStart): Promise<void>;
  state(): RemoteMediaState;
  stop(): Promise<void>;
  revoke(): Promise<void>;
  dispose(): Promise<void>;
}

interface PeerSlot {
  readonly id: string;
  readonly connection: RTCPeerConnection;
  readonly pendingIce: (RTCIceCandidateInit | null)[];
}
const ENDPOINTS: RemoteMediaEndpoints = {
  join: "/api/v1/media/join",
  signal: "/api/v1/media/signal",
  events: "/api/v1/media/events",
  leave: "/api/v1/media/leave",
};
const TIMERS: RemoteMediaTimers = {
  setTimeout: (callback, delay) => globalThis.setTimeout(callback, delay),
  clearTimeout: (handle) => globalThis.clearTimeout(handle),
};

function copyBinding(value: ScreenShareBinding): ScreenShareBinding {
  for (const key of ["officeId", "levelId", "screenId"] as const) {
    if (typeof value[key] !== "string" || value[key].length < 1 || value[key].length > 128) {
      throw new TypeError(`remote media: invalid ${key}`);
    }
  }
  if (value.roomId !== null && (typeof value.roomId !== "string" || value.roomId.length < 1 || value.roomId.length > 128)) {
    throw new TypeError("remote media: invalid roomId");
  }
  return { ...value };
}
function sameBinding(a: ScreenShareBinding, b: ScreenShareBinding): boolean {
  return a.officeId === b.officeId && a.levelId === b.levelId && a.roomId === b.roomId && a.screenId === b.screenId;
}
function asError(reason: unknown, fallback: string): Error { return reason instanceof Error ? reason : new Error(fallback); }
function requestId(number: number): string { return `tera-media-${number}`; }
function sdp(value: RTCSessionDescriptionInit): ScreenShareSignalPayload {
  if ((value.type !== "offer" && value.type !== "answer") || typeof value.sdp !== "string") {
    throw new Error("remote media: local SDP is invalid");
  }
  return { kind: "sdp", descriptionType: value.type, sdp: value.sdp };
}
function remoteDescription(signal: Extract<ScreenShareSignalPayload, { kind: "sdp" }>): RTCSessionDescriptionInit {
  return { type: signal.descriptionType, sdp: signal.sdp };
}

/**
 * Capture-free and storage-free by construction. The adapter never invokes a
 * media acquisition API, calls `play`, records, uploads media, or exposes the
 * server grant in state/events. It owns peer connections and received tracks;
 * the presenter's input stream, video, and track remain caller-owned.
 */
export function createRemoteOfficeMedia(options: RemoteOfficeMediaOptions): RemoteOfficeMedia {
  if (options.authenticatedFetch && options.fetch) throw new TypeError("remote media: provide one fetch adapter");
  const fetcher = options.authenticatedFetch ?? options.fetch ?? globalThis.fetch;
  if (typeof fetcher !== "function") throw new TypeError("remote media: fetch is required");
  const makePeer = options.peerConnectionFactory ?? ((configuration) => new RTCPeerConnection(configuration));
  const binding = copyBinding(options.binding);
  const endpoints = { ...ENDPOINTS, ...options.endpoints };
  const timers = options.timers ?? TIMERS;
  const now = options.now ?? Date.now;
  const reconnectBase = options.reconnectBaseMs ?? 500;
  const reconnectMaximum = options.reconnectMaximumMs ?? 15_000;
  if (!(reconnectBase > 0) || !Number.isFinite(reconnectBase) || reconnectMaximum < reconnectBase) {
    throw new RangeError("remote media: invalid reconnect bounds");
  }

  let status: RemoteMediaStatus = "idle";
  let grant: ScreenShareAccessGrant | null = null;
  let clientSequence = 0;
  let counter = 0;
  let cursor: ScreenShareStreamCursor | null = null;
  let participants: readonly ScreenShareParticipant[] = [];
  let presenter: PresenterStart | null = null;
  let viewer: ViewerStart | null = null;
  let receiverStream: MediaStream | null = null;
  let eventAbort: AbortController | null = null;
  let reconnectTimer: ReturnType<typeof setTimeout> | null = null;
  let renewalTimer: ReturnType<typeof setTimeout> | null = null;
  let reconnectAttempt = 0;
  let generation = 0;
  const peers = new Map<string, PeerSlot>();

  function state(): RemoteMediaState {
    return {
      role: options.role,
      status,
      binding: { ...binding },
      sessionId: grant?.credential.sessionId ?? null,
      participantCount: peers.size,
      reconnectAttempt,
      hasRemoteVideo: receiverStream !== null,
    };
  }
  function changed(): void { options.onStateChange?.(state()); }
  function setStatus(next: RemoteMediaStatus): void { status = next; changed(); }
  function envelope(): { protocolVersion: 1; sequence: number; timestampMs: number } {
    const result = { protocolVersion: SCREEN_SHARE_SIGNALING_PROTOCOL_VERSION, sequence: clientSequence, timestampMs: now() };
    clientSequence += 1;
    return result;
  }

  async function post(endpoint: string, message: ScreenShareClientMessage, signal?: AbortSignal): Promise<Response> {
    return fetcher(endpoint, {
      method: "POST",
      credentials: "same-origin",
      cache: "no-store",
      redirect: "error",
      headers: { Accept: "application/json", "Content-Type": "application/json" },
      body: JSON.stringify(message),
      signal,
    });
  }
  async function parsedResponse(response: Response): Promise<ScreenShareServerMessage> {
    if (!response.ok) throw new Error(`remote media request failed (${response.status})`);
    const parsed = parseScreenShareServerMessage(await response.json() as unknown);
    if (!parsed.ok) throw new Error(parsed.error);
    return parsed.value;
  }

  function releaseReceiver(): void {
    if (receiverStream) for (const track of receiverStream.getTracks()) track.stop();
    if (viewer?.video.srcObject === receiverStream) viewer.video.srcObject = null;
    receiverStream = null;
  }
  function closePeer(id: string): void {
    const slot = peers.get(id);
    if (!slot) return;
    slot.connection.onicecandidate = null;
    slot.connection.ontrack = null;
    slot.connection.onconnectionstatechange = null;
    slot.connection.close();
    peers.delete(id);
  }
  function closeTransport(): void {
    generation += 1;
    eventAbort?.abort();
    eventAbort = null;
    if (reconnectTimer !== null) timers.clearTimeout(reconnectTimer);
    reconnectTimer = null;
    if (renewalTimer !== null) timers.clearTimeout(renewalTimer);
    renewalTimer = null;
    for (const id of [...peers.keys()]) closePeer(id);
    releaseReceiver();
  }

  function resetPeerMesh(): void {
    for (const id of [...peers.keys()]) closePeer(id);
    releaseReceiver();
  }

  async function sendSignal(targetParticipantId: string, signal: ScreenShareSignalPayload): Promise<void> {
    if (!grant) throw new Error("remote media: signaling grant is missing");
    const request: ScreenShareClientMessage = {
      type: "screen-share-signal-request",
      ...envelope(),
      binding,
      credential: grant.credential,
      targetParticipantId,
      signal,
    };
    const response = await post(endpoints.signal, request);
    if (!response.ok) throw new Error(`remote media signal failed (${response.status})`);
  }

  function configurePeer(participant: ScreenShareParticipant): PeerSlot {
    const prior = peers.get(participant.participantId);
    if (prior) return prior;
    const activeGeneration = generation;
    const connection = makePeer(options.peerConnectionConfiguration);
    const slot: PeerSlot = { id: participant.participantId, connection, pendingIce: [] };
    peers.set(slot.id, slot);
    connection.onicecandidate = (event) => {
      if (generation !== activeGeneration) return;
      const signal: ScreenShareSignalPayload = event.candidate
        ? {
            kind: "ice-candidate",
            candidate: event.candidate.candidate,
            sdpMid: event.candidate.sdpMid,
            sdpMLineIndex: event.candidate.sdpMLineIndex,
            usernameFragment: event.candidate.usernameFragment,
          }
        : { kind: "ice-complete" };
      void sendSignal(slot.id, signal).catch((reason) => options.onError?.(asError(reason, "remote media ICE failed")));
    };
    connection.onconnectionstatechange = () => {
      if (connection.connectionState === "connected") { reconnectAttempt = 0; setStatus("live"); }
      else if (connection.connectionState === "failed" || connection.connectionState === "disconnected") scheduleReconnect();
    };
    if (options.role === "presenter") {
      const track = presenter?.stream.getVideoTracks()[0];
      if (!track || track.readyState !== "live") throw new Error("remote media: presenter track ended");
      connection.addTrack(track, presenter!.stream);
    } else {
      connection.addTransceiver("video", { direction: "recvonly" });
      connection.ontrack = (event) => {
        if (generation !== activeGeneration || status === "revoked" || status === "disposed") {
          event.track.stop();
          return;
        }
        releaseReceiver();
        receiverStream = event.streams[0] ?? new MediaStream([event.track]);
        viewer!.video.srcObject = receiverStream;
        changed();
      };
    }
    changed();
    return slot;
  }

  async function offer(participant: ScreenShareParticipant): Promise<void> {
    const connection = configurePeer(participant).connection;
    const description = await connection.createOffer();
    await connection.setLocalDescription(description);
    await sendSignal(participant.participantId, sdp(connection.localDescription ?? description));
  }

  async function reconcile(next: readonly ScreenShareParticipant[]): Promise<void> {
    if (!grant) return;
    const own = grant.credential.participantId;
    const allowed = next.filter((item) => item.participantId !== own && item.role !== options.role);
    const ids = new Set(allowed.map((item) => item.participantId));
    for (const id of [...peers.keys()]) if (!ids.has(id)) closePeer(id);
    participants = allowed;
    if (options.role === "presenter") {
      for (const participant of allowed) if (!peers.has(participant.participantId)) await offer(participant);
    } else {
      const presenterPeer = allowed.find((item) => item.role === "presenter");
      if (presenterPeer) configurePeer(presenterPeer);
    }
    changed();
  }

  async function applyPeerMessage(message: ScreenSharePeerMessage): Promise<void> {
    if (!grant || message.sessionId !== grant.credential.sessionId || !sameBinding(message.binding, binding)) return;
    const advanced = advanceScreenShareStreamCursor(cursor, message);
    if (!advanced.ok) return;
    cursor = advanced.value;
    if (message.type === "screen-share-stopped") {
      closeTransport();
      setStatus("stopped");
      return;
    }
    if (message.type === "screen-share-revoked") {
      if (message.scope === "session" || message.targetParticipantId === grant.credential.participantId) {
        closeTransport();
        grant = null;
        setStatus("revoked");
      } else if (message.targetParticipantId) closePeer(message.targetParticipantId);
      return;
    }
    if (message.type === "screen-share-participants") {
      await reconcile(message.participants);
      return;
    }
    if (message.targetParticipantId !== grant.credential.participantId) return;
    const from = participants.find((item) => item.participantId === message.fromParticipantId);
    if (!from) return;
    const connection = configurePeer(from).connection;
    if (message.signal.kind === "ice-complete") {
      if (connection.remoteDescription) await connection.addIceCandidate(null);
      else peers.get(from.participantId)?.pendingIce.push(null);
      return;
    }
    if (message.signal.kind === "ice-candidate") {
      const incoming: RTCIceCandidateInit = {
        candidate: message.signal.candidate,
        sdpMid: message.signal.sdpMid,
        sdpMLineIndex: message.signal.sdpMLineIndex,
        usernameFragment: message.signal.usernameFragment ?? undefined,
      };
      if (connection.remoteDescription) await connection.addIceCandidate(incoming);
      else peers.get(from.participantId)?.pendingIce.push(incoming);
      return;
    }
    await connection.setRemoteDescription(remoteDescription(message.signal));
    const slot = peers.get(from.participantId);
    if (slot) {
      for (const incoming of slot.pendingIce.splice(0)) await connection.addIceCandidate(incoming);
    }
    if (message.signal.descriptionType === "offer") {
      const answer = await connection.createAnswer();
      await connection.setLocalDescription(answer);
      await sendSignal(from.participantId, sdp(connection.localDescription ?? answer));
    }
  }

  async function readEvents(response: Response, activeGeneration: number, expectedRequestId: string): Promise<void> {
    if (!response.ok || !response.body) throw new Error(`remote media events failed (${response.status})`);
    const reader = response.body.getReader();
    const decoder = new TextDecoder();
    let buffer = "";
    let first = true;
    try {
      while (generation === activeGeneration) {
        const chunk = await reader.read();
        if (generation !== activeGeneration || chunk.done) break;
        buffer += decoder.decode(chunk.value, { stream: true }).replace(/\r/g, "");
        let boundary = buffer.indexOf("\n\n");
        while (boundary >= 0) {
          const block = buffer.slice(0, boundary);
          buffer = buffer.slice(boundary + 2);
          boundary = buffer.indexOf("\n\n");
          const data = block.split("\n").filter((line) => line.startsWith("data:"))
            .map((line) => line.slice(5).replace(/^ /, "")).join("\n");
          if (!data) continue;
          let raw: unknown;
          try { raw = JSON.parse(data); } catch { continue; }
          const parsed = parseScreenShareServerMessage(raw);
          if (!parsed.ok) continue;
          if (first) {
            first = false;
            if (parsed.value.type !== "screen-share-resume-grant" ||
                parsed.value.requestId !== expectedRequestId || !(await acceptGrant(parsed.value))) {
              throw new Error("remote media: event stream did not start with a valid resume grant");
            }
          } else if (parsed.value.type === "screen-share-signal-relay" ||
                     parsed.value.type === "screen-share-participants" ||
                     parsed.value.type === "screen-share-stopped" ||
                     parsed.value.type === "screen-share-revoked") {
            await applyPeerMessage(parsed.value);
          }
        }
      }
      if (generation === activeGeneration && first) throw new Error("remote media: event stream ended before resume grant");
    } finally { reader.releaseLock(); }
  }

  async function acceptGrant(message: ScreenShareResumeGrant): Promise<boolean> {
    const current = grant?.credential;
    if (!current || message.grant.credential.sessionId !== current.sessionId ||
        message.grant.credential.participantId !== current.participantId ||
        !sameBinding(message.binding, binding) || message.grant.credential.role !== options.role ||
        !isScreenShareGrantActive(message.grant, now())) return false;
    if (grant && (message.grant.credential.sessionId !== grant.credential.sessionId ||
        message.grant.credential.participantId !== grant.credential.participantId)) return false;
    grant = message.grant;
    clientSequence = message.nextClientSequence;
    cursor = { sessionId: message.grant.credential.sessionId, sequence: message.sequence, timestampMs: message.timestampMs };
    if (!message.continuous) resetPeerMesh();
    await reconcile(message.participants);
    scheduleRenewal();
    setStatus("connecting");
    return true;
  }

  function scheduleRenewal(): void {
    if (!grant || status === "revoked" || status === "stopped" || status === "disposed") return;
    if (renewalTimer !== null) timers.clearTimeout(renewalTimer);
    const delay = Math.max(1_000, grant.expiresAtMs - now() - 15_000);
    renewalTimer = timers.setTimeout(() => {
      renewalTimer = null;
      void startEvents().catch((reason) => {
        options.onError?.(asError(reason, "remote media lease renewal failed"));
        scheduleReconnect();
      });
    }, delay);
  }

  function scheduleReconnect(): void {
    if (!grant || status === "revoked" || status === "stopped" || status === "disposed" || reconnectTimer !== null) return;
    // A failed RTCPeerConnection is not recoverable by renewing the signaling
    // lease alone. Tear down the peer mesh and let the resume snapshot rebuild
    // it; presenter input tracks remain untouched and reusable.
    generation += 1;
    eventAbort?.abort();
    eventAbort = null;
    if (renewalTimer !== null) timers.clearTimeout(renewalTimer);
    renewalTimer = null;
    resetPeerMesh();
    setStatus("reconnecting");
    const delay = Math.min(reconnectMaximum, reconnectBase * 2 ** reconnectAttempt);
    reconnectAttempt += 1;
    reconnectTimer = timers.setTimeout(() => {
      reconnectTimer = null;
      void startEvents().catch((reason) => { options.onError?.(asError(reason, "remote media reconnect failed")); scheduleReconnect(); });
    }, delay);
  }

  async function startEvents(): Promise<void> {
    if (!grant) throw new Error("remote media: grant is missing");
    const activeGeneration = generation;
    eventAbort?.abort();
    const abort = new AbortController();
    eventAbort = abort;
    const request: ScreenShareClientMessage = {
      type: "screen-share-resume-request",
      ...envelope(),
      requestId: requestId(++counter),
      binding,
      credential: grant.credential,
      lastReceivedSequence: cursor?.sequence ?? 0,
    };
    try {
      const response = await post(endpoints.events, request, abort.signal);
      await readEvents(response, activeGeneration, request.requestId);
      if (generation === activeGeneration) scheduleReconnect();
    } catch (reason) {
      if (generation !== activeGeneration || abort.signal.aborted) return;
      throw reason;
    }
  }

  async function join(role: RemoteMediaRole, activeGeneration: number): Promise<void> {
    const id = requestId(++counter);
    const message: ScreenShareClientMessage = role === "presenter"
      ? { type: "screen-share-create-request", ...envelope(), requestId: id, binding, role }
      : { type: "screen-share-join-request", ...envelope(), requestId: id, binding, role, viewerOptIn: true };
    const response = await parsedResponse(await post(endpoints.join, message));
    const expected = role === "presenter" ? "screen-share-create-grant" : "screen-share-join-grant";
    if (response.type !== expected || response.requestId !== id || !sameBinding(response.binding, binding) ||
        response.grant.credential.role !== role || !isScreenShareGrantActive(response.grant, now())) {
      throw new Error("remote media: join grant is invalid");
    }
    if (generation !== activeGeneration || status === "disposed" || status === "revoked" || status === "stopped") {
      throw new Error("remote media: join was superseded");
    }
    grant = response.grant;
    clientSequence = response.nextClientSequence;
    cursor = { sessionId: response.grant.credential.sessionId, sequence: response.sequence, timestampMs: response.timestampMs };
    await reconcile(response.participants);
    scheduleRenewal();
    void startEvents().catch((reason) => { options.onError?.(asError(reason, "remote media events failed")); scheduleReconnect(); });
  }

  async function startPresenter(input: PresenterStart): Promise<void> {
    if (options.role !== "presenter") throw new Error("remote media: adapter is not a presenter");
    if (status === "disposed" || status === "revoked") throw new Error("remote media: session is terminal");
    if (!input.consent.authorized || !input.consent.optedIn) throw new Error("remote media: authorization and explicit opt-in are required");
    const tracks = input.stream.getVideoTracks().filter((track) => track.readyState === "live");
    if (tracks.length !== 1) throw new Error("remote media: presenter requires exactly one live screen track");
    input.video.autoplay = false;
    input.video.muted = true;
    closeTransport();
    grant = null;
    participants = [];
    presenter = input;
    viewer = null;
    setStatus("connecting");
    try {
      await join("presenter", generation);
    } catch (reason) {
      if (status === "connecting") {
        closeTransport();
        grant = null;
        presenter = null;
        setStatus("idle");
      }
      throw reason;
    }
  }

  async function startViewer(input: ViewerStart): Promise<void> {
    if (options.role !== "viewer") throw new Error("remote media: adapter is not a viewer");
    if (status === "disposed" || status === "revoked") throw new Error("remote media: session is terminal");
    if (!input.decision.authorized || !input.decision.optedIn || !input.decision.canView ||
        input.decision.surface.screenId !== binding.screenId || input.decision.surface.officeId !== binding.officeId ||
        input.decision.surface.source?.kind !== "live-stream") {
      throw new Error("remote media: a ready live-stream authorization decision is required");
    }
    input.video.autoplay = false;
    input.video.muted = true;
    closeTransport();
    grant = null;
    participants = [];
    viewer = input;
    presenter = null;
    setStatus("connecting");
    try {
      await join("viewer", generation);
    } catch (reason) {
      if (status === "connecting") {
        closeTransport();
        grant = null;
        viewer = null;
        setStatus("idle");
      }
      throw reason;
    }
  }

  async function leave(): Promise<void> {
    const credential = grant?.credential;
    closeTransport();
    participants = [];
    grant = null;
    if (!credential) return;
    // A presenter ending the whole share is always a stop. `revoke` is a
    // policy word locally, not permission to claim a moderator action on wire.
    const message: ScreenShareClientMessage = options.role === "presenter"
      ? {
          type: "screen-share-stop-request", ...envelope(), requestId: requestId(++counter), binding,
          credential: credential as ScreenShareCredential<"presenter">, reason: "presenter-stopped",
        }
      : {
          type: "screen-share-revoke-request", ...envelope(), requestId: requestId(++counter), binding,
          credential, scope: "participant",
          targetParticipantId: credential.participantId,
          reason: "viewer-left",
        };
    const response = await post(endpoints.leave, message);
    if (!response.ok) throw new Error(`remote media leave failed (${response.status})`);
  }

  async function stop(): Promise<void> {
    if (status === "disposed" || status === "stopped") return;
    try { await leave(); } finally { presenter = null; viewer = null; setStatus("stopped"); }
  }
  async function revoke(): Promise<void> {
    if (status === "disposed" || status === "revoked") return;
    try { await leave(); } finally { presenter = null; viewer = null; setStatus("revoked"); }
  }
  async function dispose(): Promise<void> {
    if (status === "disposed") return;
    try { await leave(); } finally { presenter = null; viewer = null; status = "disposed"; changed(); }
  }

  return { startPresenter, startViewer, state, stop, revoke, dispose };
}