import { ClientMonitor } from "@observertc/client-monitor-js";
import { ClientSampleEncoder } from "@observertc/samples-protobuf-codec";

// One encoder per client — it sends each sample as the delta from the previous one.
const encoder = new ClientSampleEncoder({ clientId: session.participantId });

const monitor = new ClientMonitor({
    clientId: session.participantId,
    callId: session.roomId,

    collectingPeriodInMs: 5000,     // the default; lower it to make detectors faster to judge
    samplingPeriodInMs: 10000,      // a multiple of the above — less upload volume

    congestionDetector: null,       // deprecated; take the two graded ones instead
    uplinkCongestionDetector: {},
    downlinkCongestionDetector: {},

    audioPlayoutSynthesisDetector: null,   // not acted on — don't build it

    appData: { appVersion: BUILD_VERSION },
});

monitor.attachments = {
    appVersion: BUILD_VERSION,
    region: session.region,
    tier: user.plan,
};

monitor.addSource(peerConnection);

// Ship telemetry.
monitor.on("sample-created", ({ sample }) => {
    navigator.sendBeacon(`/api/samples/${session.participantId}`, encoder.encode(sample));
});

// Route issues by how much you care.
monitor.on("issue", (issue) => {
    if (issue.type === "uplink-congestion" || issue.type === "cpulimitation") {
        alerting.notify(issue);
    } else {
        log.info("issue", issue.type, issue.payload);
    }
});

// Episode durations are the useful analytics event, not the raise.
monitor.on("issue-resolved", (resolved) => {
    analytics.track("quality_episode", {
        type: resolved.type,
        durationInMs: resolved.payload?.durationInMs,
    });
});

window.addEventListener("pagehide", () => monitor.close());

const SEVERITY = {
    "uplink-congestion": "critical",
    "downlink-congestion": "critical",
    cpulimitation: "critical",
    "dry-inbound-track": "critical",
    "dry-outbound-track": "critical",
    "stuck-decoder": "critical",
    "video-flow-disrupted": "warning",
    "av-desync": "warning",
    "invented-speech": "warning",
    "pixelated-video": "warning",
    "inbound-video-playout-discrepancy": "warning",
};

monitor.on("stats-collected", () => {
    const active = monitor.getActiveIssuesByType();

    const worst = active.reduce((acc, issue) => {
        const level = SEVERITY[issue.type] ?? "info";
        return level === "critical" ? "critical" : acc === "critical" ? acc : level;
    }, "ok");

    ui.setNetworkIndicator({
        level: worst,
        score: monitor.score,
        detail: active.map((i) => i.type),
    });
});

monitor.on("issue", async (issue) => {
    switch (issue.type) {
        case "uplink-congestion": {
            // The sending path is out of room — shed the most expensive stream first.
            await screenShare?.pause();
            ui.toast("Network is congested — screen share paused");
            break;
        }
        case "cpulimitation": {
            await sender.setParameters({
                ...sender.getParameters(),
                encodings: [{ maxBitrate: 300_000, scaleResolutionDownBy: 2 }],
            });
            break;
        }
        case "capture-source-lost": {
            // Terminal: the device is gone and the track will never produce another frame.
            ui.promptDeviceChange(issue.payload.trackId, issue.payload.deviceLabel);
            break;
        }
        case "silent-audio-source": {
            ui.toast("Your microphone is not picking anything up");
            break;
        }
        case "stuck-decoder": {
            // Per-consumer wedge — recreating the consumer is the documented remedy.
            if (issue.payload.variant === "decode") await recreateConsumer(issue.payload.trackId);
            break;
        }
    }
});

monitor.on("issue-resolved", async (resolved) => {
    if (resolved.type === "uplink-congestion") {
        await screenShare?.resume();
        ui.toast("Network recovered");
    }
});

monitor.on("stats-collected", () => {
    const snapshot = {
        timestamp: Date.now(),
        score: monitor.score,
        scoreReasons: monitor.scoreReasons,
        cpuUtilization: monitor.cpuUtilization,

        bitrates: {
            sendingAudio: monitor.sendingAudioBitrate,
            sendingVideo: monitor.sendingVideoBitrate,
            receivingAudio: monitor.receivingAudioBitrate,
            receivingVideo: monitor.receivingVideoBitrate,
        },

        capacity: {
            availableIn: monitor.totalAvailableIncomingBitrate,
            availableOut: monitor.totalAvailableOutgoingBitrate,
        },

        rttMs: (monitor.avgRttInSec ?? 0) * 1000,

        connections: monitor.peerConnections.map((pc) => ({
            id: pc.peerConnectionId,
            iceState: pc.iceState,
            turn: pc.usingTURN,
            tcp: pc.usingTCP,
            rttMs: (pc.avgRttInSec ?? 0) * 1000,
            congested: pc.congested,
            score: pc.calculatedStabilityScore?.value,
        })),

        tracks: monitor.tracks.map((t) => {
            const rtp = t.direction === "inbound" ? t.getInboundRtp() : t.highestLayer;
            return {
                id: t.track.id,
                kind: t.kind,
                direction: t.direction,
                bitrate: t.bitrate,
                fps: rtp?.ewmaFps,
                loss: t.fractionLost,
                flow: t.direction === "inbound" ? t.frameFlowState : undefined,
                score: t.calculatedScore?.value,
                label: t.attachments?.mediaType,
            };
        }),

        activeIssues: monitor.getActiveIssuesByType().map((i) => ({
            type: i.type,
            key: i.key,
            openForMs: Date.now() - i.raisedAt,
        })),
    };

    dashboard.push(snapshot);
});

// 1. Screen share. Nothing in getStats() reveals that an INBOUND track is a screen share,
//    and PixelatedVideoDetector refuses to judge one — a static slide legitimately spends
//    almost nothing per pixel. An undeclared screen share is judged as camera video.
monitor.setInboundTrackContext(remoteTrackId, { contentType: "screenshare" });

// Outbound is auto-detected from track.getSettings().displaySurface where the browser
// reports one; declare it where it does not. Declaring 'camera' on a genuinely moving
// captured surface opts it back into capture-bottleneck detection.
monitor.setOutboundTrackContext(screenTrack.id, { contentType: "camera" });

// 2. Lip sync. An SFU forwards audio and video as independent streams with no signalled
//    relationship, so AVDesyncPlayoutDetector reports inputsUnavailable until you pair them.
monitor.setInboundTrackContext(audioTrackId, { linkedVideoTrackId: videoTrackId });

// 3. Presented size. A blocky picture costs more full-screen than in a thumbnail.
monitor.setInboundTrackContext(remoteTrackId, { videoTag: videoElement });

// 4. Pauses. A receiver can be created ALREADY paused — a mediasoup consumer, for one — and
//    its stats appear a collection or more later, so this is declared rather than derived.
monitor.setInboundTrackContext(remoteTrackId, { paused: true });

monitor.getTrackMonitor(camTrack.id).attachments    = { mediaType: "camera" };
monitor.getTrackMonitor(screenTrack.id).attachments = { mediaType: "screen-share" };

// mediasoup: what the default remote-track resolver reads server-side
monitor.getTrackMonitor(producer.track.id).attachments = { producerId: producer.id, direction: "send" };
monitor.getTrackMonitor(consumer.track.id).attachments = { consumerId: consumer.id, producerId: consumer.producerId, direction: "recv" };

import { useEffect, useRef, useState } from "react";
import { ClientMonitor } from "@observertc/client-monitor-js";

export function useClientMonitor(peerConnection, { clientId, callId }) {
    const monitorRef = useRef(null);
    const [quality, setQuality] = useState({ score: 5, issues: [] });

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

        const monitor = new ClientMonitor({
            clientId,
            callId,
            collectingPeriodInMs: 5000,
            samplingPeriodInMs: 5000,
            bufferClientSamplesUntilSubscriber: true,   // nothing is lost before the effect runs
        });
        monitorRef.current = monitor;
        monitor.addSource(peerConnection);

        monitor.on("stats-collected", () => {
            setQuality({
                score: monitor.score ?? 5,
                rttMs: (monitor.avgRttInSec ?? 0) * 1000,
                issues: monitor.getActiveIssuesByType().map((i) => i.type),
            });
        });

        monitor.on("sample-created", ({ sample }) => {
            fetch("/api/samples", {
                method: "POST",
                headers: { "Content-Type": "application/json" },
                body: JSON.stringify(sample),
            }).catch(() => {});
        });

        return () => {
            monitor.close();
            monitorRef.current = null;
        };
    }, [peerConnection, clientId, callId]);

    return { quality, monitor: monitorRef };
}

import express from "express";

const app = express();
app.use(express.json({ limit: "2mb" }));

app.post("/api/samples", (req, res) => {
    const sample = req.body;
    if (!sample?.clientId || !sample?.callId) return res.sendStatus(400);

    store.append(sample);           // your archive
    observer.accept(sample);        // live analysis

    res.sendStatus(200);
});