index.js

require("dotenv").config();

const path = require("path");
const express = require("express");
const axios = require("axios");
const db = require("./db");

const app = express();

const PORT = process.env.PORT || 5005;
const ATTENDEE_API_KEY = process.env.ATTENDEE_API_KEY;
const ATTENDEE_BASE_URL = process.env.ATTENDEE_BASE_URL;

app.use(express.json());
app.use(express.static(path.join(__dirname, "public")));

// ---------------------------
// SSE
// ---------------------------
/** @type {Set<import('http').ServerResponse>} */
const subscribers = new Set();

function sseBroadcast(msg) {
  const payload = `data: ${JSON.stringify(msg)}\n\n`;
  for (const res of subscribers) {
    try {
      res.write(payload);
    } catch {
      subscribers.delete(res);
      try {
        res.end();
      } catch {}
    }
  }
}

app.get("/stream", (req, res) => {
  res.setHeader("Content-Type", "text/event-stream");
  res.setHeader("Cache-Control", "no-cache");
  res.setHeader("Connection", "keep-alive");

  res.write(": connected\n\n");
  subscribers.add(res);

  req.on("close", () => {
    subscribers.delete(res);
    try {
      res.end();
    } catch {}
  });
});

// -------------------------------------
// Zoom webhook
// -------------------------------------
// Expects { event, payload } like Zoom RTMS webhooks.
// On meeting.rtms_started -> create an Attendee app_session.
app.post("/", async (req, res) => {
  const { event, payload } = req.body || {};

  console.log("Zoom webhook received:", req.body);

  // Always broadcast for visibility in the demo UI
  sseBroadcast({ source: "zoom", event, payload });

  if (!event || !payload) return res.status(400).send("Missing event/payload");
  if (!ATTENDEE_API_KEY || !ATTENDEE_BASE_URL) return res.status(500).send("Server not configured");

  try {
    if (event === "meeting.rtms_started") {
      const { meeting_uuid, rtms_stream_id, server_urls } = payload;
      const resp = await axios.post(
        `${ATTENDEE_BASE_URL}/api/v1/app_sessions`,
        { zoom_rtms: { meeting_uuid, rtms_stream_id, server_urls } },
        { headers: { Authorization: `Token ${ATTENDEE_API_KEY}` }, timeout: 15000 }
      );

      const session = db.sessions.create({
        id: resp.data.id,
        created_at: new Date().toISOString(),
        state: resp.data.state || "connecting",
        zoom_rtms: payload,
      });

      sseBroadcast({ source: "db", type: "session.created", session });
    }

    res.status(200).send("ok");
  } catch (err) {
    console.error("Zoom webhook error:", err.response?.data || err.message);
    // Still ack Zoom to avoid retries in this sample
    res.status(200).send("ok");
  }
});

// -------------------------------------
// Attendee webhook
// -------------------------------------
// Expects { trigger, data, app_session_id }.
app.post("/attendee-webhook", (req, res) => {
  const body = req.body;
  if (!body || typeof body !== "object") return res.status(400).send("invalid JSON");

  console.log("Attendee webhook received:", req.body);

  const { trigger, data, app_session_id } = body;

  // Always broadcast raw payload so the UI can react live
  sseBroadcast({ source: "attendee", trigger, data, app_session_id });

  if (trigger === "transcript.update" && app_session_id && data) {
    const transcript = db.transcripts.create({
      app_session_id,
      created_at: new Date().toISOString(),
      data,
    });
    sseBroadcast({ source: "db", type: "transcript.created", transcript });
  }

  if (trigger === "bot.state_change" && app_session_id && data?.new_state) {
    const updated = db.sessions.update(app_session_id, { state: data.new_state });
    if (updated) sseBroadcast({ source: "db", type: "session.updated", session: updated });
  }

  res.status(200).send("ok");
});

// -------------------------------------
// API for the demo UI
// -------------------------------------
app.get("/api/sessions", (_req, res) => res.json(db.sessions.getAll()));
app.get("/api/transcripts", (_req, res) => res.json(db.transcripts.getAll()));

app.get("/api/sessions/:id/recording", async (req, res) => {
  if (!ATTENDEE_API_KEY || !ATTENDEE_BASE_URL) {
    return res.status(500).json({ error: "Attendee API not configured" });
  }

  const sessionId = req.params.id;
  const session = db.sessions.getById(sessionId);
  if (!session) return res.status(404).json({ error: "Session not found" });
  if (session.state !== "ended") return res.status(400).json({ error: "Session not ended" });

  try {
    const resp = await axios.get(`${ATTENDEE_BASE_URL}/api/v1/app_sessions/${sessionId}/media`, {
      headers: { Authorization: `Token ${ATTENDEE_API_KEY}` },
      timeout: 15000,
    });
    res.json(resp.data);
  } catch (err) {
    console.error("Recording fetch error:", err.response?.data || err.message);
    res.status(err.response?.status || 500).json({ error: "Failed to fetch recording" });
  }
});

app.get("/", (_req, res) => {
  res.sendFile(path.join(__dirname, "public", "index.html"));
});

app.listen(PORT, () => {
  console.log(`Demo server listening on http://localhost:${PORT}`);
});