// examples/webrtc-lab/signaling/ 扩展为完整 API
import express from "express";
import crypto from "crypto";
import { AccessToken } from "livekit-server-sdk";

const app = express();
app.use(express.json());

function generateTurnCredentials(secret, identity, ttl = 86400) {
  const timestamp = Math.floor(Date.now() / 1000) + ttl;
  const username = `${timestamp}:${identity}`;
  const hmac = crypto.createHmac("sha1", secret);
  hmac.update(username);
  const credential = hmac.digest("base64");

  return {
    iceServers: [
      {
        urls: [
          "turn:turn.example.com:443?transport=tcp",
          "turns:turn.example.com:443?transport=tcp",
        ],
        username,
        credential,
      },
      { urls: "stun:stun.example.com:3478" },
    ],
  };
}

function generateLiveKitToken(roomId, identity, grants = {}) {
  const token = new AccessToken(
    process.env.LIVEKIT_API_KEY,
    process.env.LIVEKIT_API_SECRET,
    { identity, ttl: "24h" }
  );
  token.addGrant({
    roomJoin: true,
    room: roomId,
    canPublish: true,
    canSubscribe: true,
    canPublishData: true,
    ...grants,
  });
  return token.toJwt();
}

app.post("/rooms/join", async (req, res) => {
  const { roomId, identity } = req.body;
  if (!roomId || !identity) {
    return res.status(400).json({ error: "roomId and identity required" });
  }

  const token = await generateLiveKitToken(roomId, identity);
  const turn = generateTurnCredentials(process.env.TURN_SECRET, identity);

  console.log(JSON.stringify({
    layer: "signaling",
    event: "room_join",
    roomId,
    identity,
    timestamp: Date.now(),
  }));

  res.json({
    token,
    livekitUrl: process.env.LIVEKIT_URL || "ws://localhost:7880",
    iceServers: turn.iceServers,
    roomId,
    identity,
  });
});

app.listen(3000, () => console.log("API server :3000"));

import { Track } from "livekit-client";

async function shareScreen(room) {
  await room.localParticipant.setScreenShareEnabled(true, {
    simulcast: true,
    videoEncoding: { maxBitrate: 3_000_000, maxFramerate: 15 },
  });
}

room.on(RoomEvent.TrackSubscribed, (track, publication, participant) => {
  if (track.source === Track.Source.ScreenShare) {
    const el = track.attach();
    document.getElementById("screen-share").appendChild(el);
  }
});

import { Room } from "livekit-client";

async function loadTest(roomId, count) {
  const results = [];
  for (let i = 0; i < count; i++) {
    const identity = `bot-${i}`;
    const res = await fetch("/api/rooms/join", {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({ roomId, identity }),
    });
    const { token, livekitUrl } = await res.json();

    const room = new Room();
    const start = Date.now();
    try {
      await room.connect(livekitUrl, token);
      results.push({
        identity,
        connectTime: Date.now() - start,
        state: room.state,
      });
    } catch (err) {
      results.push({ identity, connectTime: -1, state: "failed", error: err.message });
    }
  }
  console.table(results);
  const success = results.filter((r) => r.state === "connected").length;
  const avgConnect = results
    .filter((r) => r.connectTime > 0)
    .reduce((s, r) => s + r.connectTime, 0) / success;
  console.log(`Success: ${success}/${count}, Avg connect: ${avgConnect}ms`);
}

function ReconnectHandler({ roomId, identity, livekitUrl }) {
  const room = useRoomContext();

  useEffect(() => {
    if (!room) return;

    room.on(RoomEvent.Reconnecting, () => {
      console.log(JSON.stringify({ layer: "ice", event: "reconnecting", roomId }));
    });

    room.on(RoomEvent.Reconnected, () => {
      console.log(JSON.stringify({ layer: "ice", event: "reconnected", roomId }));
    });

    room.on(RoomEvent.Disconnected, async (reason) => {
      if (reason === DisconnectReason.CLIENT_INITIATED) return;
      try {
        const res = await fetch("/api/rooms/join", {
          method: "POST",
          headers: { "Content-Type": "application/json" },
          body: JSON.stringify({ roomId, identity }),
        });
        const { token } = await res.json();
        await room.connect(livekitUrl, token);
      } catch (err) {
        console.error("Reconnect failed:", err);
      }
    });
  }, [room, roomId, identity, livekitUrl]);

  return null;
}

// examples/webrtc-lab/signaling/ 扩展
import crypto from "crypto";

function generateTurnCredentials(secret, identity, ttlSeconds = 86400) {
  const timestamp = Math.floor(Date.now() / 1000) + ttlSeconds;
  const username = `${timestamp}:${identity}`;
  const hmac = crypto.createHmac("sha1", secret);
  hmac.update(username);
  const credential = hmac.digest("base64");

  return {
    username,
    credential,
    ttl: ttlSeconds,
    iceServers: [
      {
        urls: [
          "turn:turn.example.com:443?transport=tcp",
          "turn:turn.example.com:443?transport=udp",
          "turns:turn.example.com:443?transport=tcp",
        ],
        username,
        credential,
      },
      {
        urls: "stun:stun.example.com:3478",
      },
    ],
  };
}

app.post("/rooms/join", (req, res) => {
  const { roomId, identity } = req.body;
  const turnCreds = generateTurnCredentials(process.env.TURN_SECRET, identity);
  res.json({
    roomId,
    identity,
    iceServers: turnCreds.iceServers,
  });
});

async function selectBestTurn(turnServers) {
  const results = await Promise.all(
    turnServers.map(async (server) => {
      const start = performance.now();
      try {
        const pc = new RTCPeerConnection({ iceServers: [server] });
        pc.createDataChannel("probe");
        const offer = await pc.createOffer();
        await pc.setLocalDescription(offer);
        await new Promise((resolve) => {
          pc.onicecandidate = (e) => {
            if (e.candidate?.type === "relay") resolve();
            if (!e.candidate) resolve();
          };
          setTimeout(resolve, 3000);
        });
        pc.close();
        return { server, rtt: performance.now() - start };
      } catch {
        return { server, rtt: Infinity };
      }
    })
  );
  return results.sort((a, b) => a.rtt - b.rtt)[0].server;
}

const pc = new RTCPeerConnection({
  iceServers: [{
    urls: "turn:localhost:3478",
    username: "test",
    credential: "test123",
  }],
});
pc.createDataChannel("test");
pc.createOffer().then((o) => pc.setLocalDescription(o));
pc.onicecandidate = (e) => {
  if (e.candidate) console.log(e.candidate.type, e.candidate.address);
};

const stats = await pc.getStats();
stats.forEach((r) => {
  if (r.type === "candidate-pair" && r.state === "succeeded" && r.nominated) {
    console.log("Local:", r.localCandidateType, "Remote:", r.remoteCandidateType);
  }
});

// examples/webrtc-lab/client/ch02-p2p-basic 扩展
class WebRTCMetricsCollector {
  constructor(pc, intervalMs = 5000) {
    this.pc = pc;
    this.intervalMs = intervalMs;
    this.timer = null;
    this.onMetrics = null;
    this.sessionId = crypto.randomUUID();
  }

  start() {
    this.timer = setInterval(() => this.collect(), this.intervalMs);
  }

  stop() {
    clearInterval(this.timer);
  }

  async collect() {
    const stats = await this.pc.getStats();
    const snapshot = {
      sessionId: this.sessionId,
      timestamp: Date.now(),
      connectionState: this.pc.connectionState,
      iceConnectionState: this.pc.iceConnectionState,
      outbound: [],
      inbound: [],
      candidatePair: null,
    };

    stats.forEach((r) => {
      switch (r.type) {
        case "outbound-rtp":
          snapshot.outbound.push({
            kind: r.kind,
            rid: r.rid,
            ssrc: r.ssrc,
            bytesSent: r.bytesSent,
            packetsSent: r.packetsSent,
            framesEncoded: r.framesEncoded,
            targetBitrate: r.targetBitrate,
            qualityLimitationReason: r.qualityLimitationReason,
            frameWidth: r.frameWidth,
            frameHeight: r.frameHeight,
          });
          break;
        case "inbound-rtp":
          snapshot.inbound.push({
            kind: r.kind,
            ssrc: r.ssrc,
            bytesReceived: r.bytesReceived,
            packetsReceived: r.packetsReceived,
            packetsLost: r.packetsLost,
            jitter: r.jitter,
            framesDecoded: r.framesDecoded,
            framesDropped: r.framesDropped,
            frameWidth: r.frameWidth,
            frameHeight: r.frameHeight,
          });
          break;
        case "candidate-pair":
          if (r.state === "succeeded" && r.nominated) {
            snapshot.candidatePair = {
              localCandidateType: r.localCandidateType,
              remoteCandidateType: r.remoteCandidateType,
              currentRoundTripTime: r.currentRoundTripTime,
              availableOutgoingBitrate: r.availableOutgoingBitrate,
              bytesSent: r.bytesSent,
              bytesReceived: r.bytesReceived,
            };
          }
          break;
      }
    });

    this.onMetrics?.(snapshot);
    return snapshot;
  }
}

const collector = new WebRTCMetricsCollector(pc, 5000);
collector.onMetrics = (m) => {
  console.log("[Metrics]", JSON.stringify(m, null, 2));
};
collector.start();

let firstFrameTime = null;
const joinTime = Date.now();

pc.getReceivers().forEach((receiver) => {
  if (receiver.track?.kind === "video") {
    const checkFirstFrame = setInterval(async () => {
      const stats = await pc.getStats(receiver);
      stats.forEach((r) => {
        if (r.type === "inbound-rtp" && r.framesDecoded > 0 && !firstFrameTime) {
          firstFrameTime = Date.now();
          console.log("First frame:", firstFrameTime - joinTime, "ms");
          clearInterval(checkFirstFrame);
        }
      });
    }, 100);
  }
});

// Layer 1: Signaling — examples/webrtc-lab/signaling/server.js 扩展
console.log(JSON.stringify({
  layer: "signaling",
  event: "offer_sent",
  roomId: "meeting-123",
  peerId: "p1",
  targetPeerId: "p2",
  sdpType: "offer",
  timestamp: Date.now(),
}));

// Layer 2: ICE/DTLS
pc.oniceconnectionstatechange = () => {
  console.log(JSON.stringify({
    layer: "ice",
    event: "state_change",
    iceConnectionState: pc.iceConnectionState,
    connectionState: pc.connectionState,
    timestamp: Date.now(),
  }));
};

// Layer 3: Media (每 5s 采样)
collector.onMetrics = (m) => {
  console.log(JSON.stringify({ layer: "media", roomId: "meeting-123", ...m }));
};

// 伪代码：用 Trace ID 串联三层
const span = tracer.startSpan("webrtc.session");
span.setAttribute("room.id", roomId);
span.setAttribute("peer.id", peerId);

pc.oniceconnectionstatechange = () => {
  span.addEvent("ice.state", { state: pc.iceConnectionState });
};

collector.onMetrics = (m) => {
  span.setAttribute("media.target_bitrate", m.outbound[0]?.targetBitrate);
};

async function reportMetrics(pc, roomId, identity) {
  const stats = await pc.getStats();
  const payload = { roomId, identity, timestamp: Date.now(), metrics: {} };

  stats.forEach((r) => {
    if (r.type === "inbound-rtp") {
      payload.metrics[`inbound_${r.kind}_packets_lost`] = r.packetsLost;
      payload.metrics[`inbound_${r.kind}_jitter`] = r.jitter;
      payload.metrics[`inbound_${r.kind}_fps`] = r.framesPerSecond;
    }
    if (r.type === "outbound-rtp") {
      payload.metrics[`outbound_${r.kind}_target_bitrate`] = r.targetBitrate;
      payload.metrics[`outbound_${r.kind}_quality_limitation`] = r.qualityLimitationReason;
    }
    if (r.type === "candidate-pair" && r.state === "succeeded" && r.nominated) {
      payload.metrics.rtt = r.currentRoundTripTime;
      payload.metrics.available_outgoing_bitrate = r.availableOutgoingBitrate;
      payload.metrics.candidate_type = r.localCandidateType;
    }
  });

  await fetch("/api/metrics", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify(payload),
  });
}