Case Study: Webinar & Video Conferencing Platform

import http from "node:http";
import crypto from "node:crypto";

// ===========================================
// 1. TYPES
// ===========================================
type Role = "host" | "presenter" | "attendee";
type WebinarStatus = "waiting" | "live" | "ended";

interface Participant {
  id: string;
  name: string;
  role: Role;
  joinedAt: string;
  isMuted: boolean;
  isCameraOn: boolean;
  isScreenSharing: boolean;
  isHandRaised: boolean;
  handRaisedAt: number | null;
}

interface Question {
  id: string;
  authorId: string;
  authorName: string;
  content: string;
  votes: Set<string>;
  isAnswered: boolean;
  createdAt: string;
}

interface Poll {
  id: string;
  question: string;
  options: string[];
  votes: Map<string, number>; // optionIndex -> count
  voters: Set<string>;
  isOpen: boolean;
  createdAt: string;
}

interface BreakoutRoom {
  id: string;
  name: string;
  participantIds: Set<string>;
  createdAt: string;
}

interface WebinarSession {
  id: string;
  title: string;
  hostId: string;
  status: WebinarStatus;
  participants: Map<string, Participant>;
  waitingRoom: Map<string, Participant>;
  questions: Map<string, Question>;
  polls: Map<string, Poll>;
  breakoutRooms: Map<string, BreakoutRoom>;
  chat: Array<{ id: string; userId: string; name: string; content: string; timestamp: number }>;
  isRecording: boolean;
  createdAt: string;
  startedAt: string | null;
}

// ===========================================
// 2. WEBINAR MANAGER
// ===========================================
class WebinarManager {
  private sessions = new Map<string, WebinarSession>();

  create(hostId: string, hostName: string, title: string): WebinarSession {
    const session: WebinarSession = {
      id: crypto.randomUUID().slice(0, 8),
      title, hostId, status: "waiting",
      participants: new Map(),
      waitingRoom: new Map(),
      questions: new Map(),
      polls: new Map(),
      breakoutRooms: new Map(),
      chat: [], isRecording: false,
      createdAt: new Date().toISOString(), startedAt: null,
    };

    // Add host as first participant
    session.participants.set(hostId, {
      id: hostId, name: hostName, role: "host",
      joinedAt: new Date().toISOString(),
      isMuted: false, isCameraOn: true, isScreenSharing: false,
      isHandRaised: false, handRaisedAt: null,
    });

    this.sessions.set(session.id, session);
    return session;
  }

  join(webinarId: string, userId: string, name: string): { admitted: boolean; session?: WebinarSession } {
    const session = this.sessions.get(webinarId);
    if (!session) throw new Error("Webinar not found");

    const participant: Participant = {
      id: userId, name, role: "attendee",
      joinedAt: new Date().toISOString(),
      isMuted: true, isCameraOn: false, isScreenSharing: false,
      isHandRaised: false, handRaisedAt: null,
    };

    if (session.status === "waiting") {
      // Add to waiting room
      session.waitingRoom.set(userId, participant);
      return { admitted: false };
    }

    // Direct join if session is live
    session.participants.set(userId, participant);
    return { admitted: true, session };
  }

  admitFromWaiting(webinarId: string, userId: string): void {
    const session = this.sessions.get(webinarId);
    if (!session) throw new Error("Webinar not found");
    const participant = session.waitingRoom.get(userId);
    if (!participant) throw new Error("User not in waiting room");
    session.waitingRoom.delete(userId);
    session.participants.set(userId, participant);
  }

  leave(webinarId: string, userId: string): void {
    const session = this.sessions.get(webinarId);
    if (!session) return;
    session.participants.delete(userId);
    session.waitingRoom.delete(userId);
  }

  start(webinarId: string, hostId: string): WebinarSession {
    const session = this.sessions.get(webinarId);
    if (!session) throw new Error("Webinar not found");
    if (session.hostId !== hostId) throw new Error("Only host can start");
    session.status = "live";
    session.startedAt = new Date().toISOString();

    // Admit all waiting room participants
    for (const [id, p] of session.waitingRoom) {
      session.participants.set(id, p);
    }
    session.waitingRoom.clear();
    return session;
  }

  end(webinarId: string, hostId: string): WebinarSession {
    const session = this.sessions.get(webinarId);
    if (!session) throw new Error("Webinar not found");
    if (session.hostId !== hostId) throw new Error("Only host can end");
    session.status = "ended";
    return session;
  }

  // Role management
  promoteToPresenter(webinarId: string, userId: string): void {
    const session = this.sessions.get(webinarId);
    if (!session) throw new Error("Webinar not found");
    const p = session.participants.get(userId);
    if (!p) throw new Error("Participant not found");
    p.role = "presenter";
    p.isMuted = false;
    p.isCameraOn = true;
    p.isHandRaised = false;
    p.handRaisedAt = null;
  }

  demoteToAttendee(webinarId: string, userId: string): void {
    const session = this.sessions.get(webinarId);
    if (!session) throw new Error("Webinar not found");
    const p = session.participants.get(userId);
    if (!p) throw new Error("Participant not found");
    p.role = "attendee";
    p.isMuted = true;
    p.isCameraOn = false;
    p.isScreenSharing = false;
  }

  // Q&A
  submitQuestion(webinarId: string, userId: string, name: string, content: string): Question {
    const session = this.sessions.get(webinarId);
    if (!session) throw new Error("Webinar not found");
    const q: Question = {
      id: crypto.randomUUID().slice(0, 8),
      authorId: userId, authorName: name, content,
      votes: new Set([userId]), isAnswered: false,
      createdAt: new Date().toISOString(),
    };
    session.questions.set(q.id, q);
    return q;
  }

  upvoteQuestion(webinarId: string, questionId: string, userId: string): void {
    const session = this.sessions.get(webinarId);
    if (!session) throw new Error("Webinar not found");
    const q = session.questions.get(questionId);
    if (!q) throw new Error("Question not found");
    q.votes.add(userId);
  }

  getQuestions(webinarId: string): object[] {
    const session = this.sessions.get(webinarId);
    if (!session) return [];
    return [...session.questions.values()]
      .map(q => ({ ...q, votes: q.votes.size }))
      .sort((a, b) => b.votes - a.votes);
  }

  // Polls
  createPoll(webinarId: string, question: string, options: string[]): Poll {
    const session = this.sessions.get(webinarId);
    if (!session) throw new Error("Webinar not found");
    const poll: Poll = {
      id: crypto.randomUUID().slice(0, 8),
      question, options,
      votes: new Map(options.map((_, i) => [i, 0] as [number, number])),
      voters: new Set(), isOpen: true,
      createdAt: new Date().toISOString(),
    };
    // Initialize vote counts
    for (let i = 0; i < options.length; i++) poll.votes.set(i, 0);
    session.polls.set(poll.id, poll);
    return poll;
  }

  votePoll(webinarId: string, pollId: string, userId: string, optionIndex: number): void {
    const session = this.sessions.get(webinarId);
    if (!session) throw new Error("Webinar not found");
    const poll = session.polls.get(pollId);
    if (!poll) throw new Error("Poll not found");
    if (!poll.isOpen) throw new Error("Poll is closed");
    if (poll.voters.has(userId)) throw new Error("Already voted");
    poll.voters.add(userId);
    poll.votes.set(optionIndex, (poll.votes.get(optionIndex) || 0) + 1);
  }

  getPollResults(webinarId: string, pollId: string): object {
    const session = this.sessions.get(webinarId);
    if (!session) throw new Error("Webinar not found");
    const poll = session.polls.get(pollId);
    if (!poll) throw new Error("Poll not found");
    return {
      ...poll,
      votes: Object.fromEntries(poll.votes),
      totalVotes: poll.voters.size,
      voters: undefined,
    };
  }

  // Hand raising
  raiseHand(webinarId: string, userId: string): void {
    const session = this.sessions.get(webinarId);
    if (!session) throw new Error("Webinar not found");
    const p = session.participants.get(userId);
    if (!p) throw new Error("Not a participant");
    p.isHandRaised = true;
    p.handRaisedAt = Date.now();
  }

  lowerHand(webinarId: string, userId: string): void {
    const session = this.sessions.get(webinarId);
    if (!session) throw new Error("Webinar not found");
    const p = session.participants.get(userId);
    if (p) { p.isHandRaised = false; p.handRaisedAt = null; }
  }

  getHandRaisedQueue(webinarId: string): object[] {
    const session = this.sessions.get(webinarId);
    if (!session) return [];
    return [...session.participants.values()]
      .filter(p => p.isHandRaised)
      .sort((a, b) => (a.handRaisedAt || 0) - (b.handRaisedAt || 0))
      .map(p => ({ id: p.id, name: p.name, raisedAt: p.handRaisedAt }));
  }

  // Breakout rooms
  createBreakoutRooms(webinarId: string, count: number): BreakoutRoom[] {
    const session = this.sessions.get(webinarId);
    if (!session) throw new Error("Webinar not found");
    const rooms: BreakoutRoom[] = [];
    const attendees = [...session.participants.values()].filter(p => p.role === "attendee");
    const perRoom = Math.ceil(attendees.length / count);

    for (let i = 0; i < count; i++) {
      const room: BreakoutRoom = {
        id: `room_${i + 1}`, name: `Room ${i + 1}`,
        participantIds: new Set(), createdAt: new Date().toISOString(),
      };
      const start = i * perRoom;
      const end = Math.min(start + perRoom, attendees.length);
      for (let j = start; j < end; j++) room.participantIds.add(attendees[j].id);
      session.breakoutRooms.set(room.id, room);
      rooms.push(room);
    }
    return rooms;
  }

  closeBreakoutRooms(webinarId: string): void {
    const session = this.sessions.get(webinarId);
    if (session) session.breakoutRooms.clear();
  }

  // Chat
  sendChat(webinarId: string, userId: string, name: string, content: string): object {
    const session = this.sessions.get(webinarId);
    if (!session) throw new Error("Webinar not found");
    const msg = { id: crypto.randomUUID().slice(0, 8), userId, name, content, timestamp: Date.now() };
    session.chat.push(msg);
    if (session.chat.length > 500) session.chat.shift();
    return msg;
  }

  // Recording
  toggleRecording(webinarId: string): boolean {
    const session = this.sessions.get(webinarId);
    if (!session) throw new Error("Webinar not found");
    session.isRecording = !session.isRecording;
    console.log(`[RECORDING] ${session.isRecording ? "Started" : "Stopped"} for ${webinarId}`);
    return session.isRecording;
  }

  getSession(id: string): WebinarSession | null {
    return this.sessions.get(id) || null;
  }

  getSessionInfo(id: string): object | null {
    const s = this.sessions.get(id);
    if (!s) return null;
    return {
      id: s.id, title: s.title, status: s.status,
      participantCount: s.participants.size,
      waitingRoomCount: s.waitingRoom.size,
      isRecording: s.isRecording,
      presenters: [...s.participants.values()].filter(p => p.role !== "attendee").map(p => ({ id: p.id, name: p.name, role: p.role })),
      questionCount: s.questions.size,
      activePollCount: [...s.polls.values()].filter(p => p.isOpen).length,
      breakoutRoomCount: s.breakoutRooms.size,
    };
  }
}

// ===========================================
// 3. HTTP SERVER
// ===========================================
const manager = new WebinarManager();

function parseBody(req: http.IncomingMessage): Promise<unknown> {
  return new Promise((resolve, reject) => {
    const chunks: Buffer[] = [];
    req.on("data", (c) => chunks.push(c));
    req.on("end", () => {
      try { resolve(JSON.parse(Buffer.concat(chunks).toString())); }
      catch { reject(new Error("Invalid JSON")); }
    });
  });
}

function json(res: http.ServerResponse, status: number, data: unknown): void {
  res.writeHead(status, { "Content-Type": "application/json" });
  res.end(JSON.stringify(data));
}

const server = http.createServer(async (req, res) => {
  const url = new URL(req.url || "/", `http://${req.headers.host}`);
  const method = req.method || "GET";

  try {
    // POST /api/webinars — Create
    if (url.pathname === "/api/webinars" && method === "POST") {
      const body = await parseBody(req) as any;
      const session = manager.create(body.hostId || "host", body.hostName || "Host", body.title || "Untitled Webinar");
      json(res, 201, manager.getSessionInfo(session.id)); return;
    }

    const idMatch = url.pathname.match(/^\/api\/webinars\/([^/]+)(?:\/(.+))?$/);
    if (!idMatch) {
      if (url.pathname === "/health") { json(res, 200, { status: "ok" }); return; }
      json(res, 404, { error: "Not found" }); return;
    }

    const [, webinarId, action] = idMatch;

    // GET /api/webinars/:id
    if (!action && method === "GET") {
      const info = manager.getSessionInfo(webinarId);
      if (!info) { json(res, 404, { error: "Not found" }); return; }
      json(res, 200, info); return;
    }

    const body = method !== "GET" ? await parseBody(req) as any : {};

    switch (action) {
      case "join":
        if (method !== "POST") break;
        const result = manager.join(webinarId, body.userId, body.name);
        json(res, 200, result); return;

      case "leave":
        if (method !== "POST") break;
        manager.leave(webinarId, body.userId);
        json(res, 200, { left: true }); return;

      case "start":
        if (method !== "POST") break;
        manager.start(webinarId, body.hostId);
        json(res, 200, manager.getSessionInfo(webinarId)); return;

      case "end":
        if (method !== "POST") break;
        manager.end(webinarId, body.hostId);
        json(res, 200, manager.getSessionInfo(webinarId)); return;

      case "promote":
        if (method !== "POST") break;
        manager.promoteToPresenter(webinarId, body.userId);
        json(res, 200, { promoted: body.userId }); return;

      case "demote":
        if (method !== "POST") break;
        manager.demoteToAttendee(webinarId, body.userId);
        json(res, 200, { demoted: body.userId }); return;

      case "questions":
        if (method === "GET") { json(res, 200, { questions: manager.getQuestions(webinarId) }); return; }
        if (method === "POST") {
          const q = manager.submitQuestion(webinarId, body.userId, body.name, body.content);
          json(res, 201, { ...q, votes: q.votes.size }); return;
        }
        break;

      case "polls":
        if (method !== "POST") break;
        const poll = manager.createPoll(webinarId, body.question, body.options);
        json(res, 201, { id: poll.id, question: poll.question, options: poll.options }); return;

      case "hand-raise":
        if (method !== "POST") break;
        if (body.action === "lower") { manager.lowerHand(webinarId, body.userId); }
        else { manager.raiseHand(webinarId, body.userId); }
        json(res, 200, { queue: manager.getHandRaisedQueue(webinarId) }); return;

      case "breakout-rooms":
        if (method === "POST") {
          const rooms = manager.createBreakoutRooms(webinarId, body.count || 4);
          json(res, 201, { rooms: rooms.map(r => ({ id: r.id, name: r.name, participantCount: r.participantIds.size })) }); return;
        }
        if (method === "DELETE") {
          manager.closeBreakoutRooms(webinarId);
          json(res, 200, { closed: true }); return;
        }
        break;

      case "chat":
        if (method === "POST") {
          const msg = manager.sendChat(webinarId, body.userId, body.name, body.content);
          json(res, 201, msg); return;
        }
        if (method === "GET") {
          const s = manager.getSession(webinarId);
          json(res, 200, { messages: s?.chat.slice(-50) || [] }); return;
        }
        break;

      case "recording/start":
        json(res, 200, { recording: manager.toggleRecording(webinarId) }); return;

      case "recording/stop":
        json(res, 200, { recording: manager.toggleRecording(webinarId) }); return;
    }

    // Handle question upvote and poll vote
    const qUpvote = url.pathname.match(/^\/api\/webinars\/([^/]+)\/questions\/([^/]+)\/upvote$/);
    if (qUpvote && method === "POST") {
      manager.upvoteQuestion(qUpvote[1], qUpvote[2], body.userId);
      json(res, 200, { upvoted: true }); return;
    }

    const pVote = url.pathname.match(/^\/api\/webinars\/([^/]+)\/polls\/([^/]+)\/vote$/);
    if (pVote && method === "POST") {
      manager.votePoll(pVote[1], pVote[2], body.userId, body.optionIndex);
      json(res, 200, manager.getPollResults(pVote[1], pVote[2])); return;
    }

    json(res, 404, { error: "Not found" });
  } catch (err: any) {
    json(res, 400, { error: err.message || "Internal server error" });
  }
});

const PORT = parseInt(process.env.PORT || "3000");
server.listen(PORT, () => console.log(`Webinar Platform on http://localhost:${PORT}`));
process.on("SIGTERM", () => server.close());