server.js

const express = require("express")
const http = require("http")
const WebSocket = require("ws")
const { v4: uuidv4 } = require("uuid")
const path = require("path")

const app = express()
const server = http.createServer(app)
const wss = new WebSocket.Server({ server })

// Serve static files from 'public' directory
app.use(express.static(path.join(__dirname, "public")))

// Handle all routes with the single HTML file
app.get("*", (req, res) => {
  res.sendFile(path.join(__dirname, "public", "index.html"))
})

// WebSocket Session Management
const streams = new Map()
const sessionTimeouts = new Map()

// Clean up inactive sessions after 30 minutes
const SESSION_TIMEOUT = 30 * 60 * 1000 // 30 minutes

wss.on("connection", (ws, req) => {
  let sessionId = null
  let isHost = false
  const clientId = uuidv4()

  console.log(`Client connected: ${clientId}`)

  ws.on("message", (message) => {
    try {
      // Handle binary data (video stream)
      if (Buffer.isBuffer(message)) {
        if (isHost && streams.has(sessionId)) {
          const session = streams.get(sessionId)
          // Broadcast to all viewers
          session.viewers.forEach((viewer) => {
            if (viewer.ws.readyState === WebSocket.OPEN) {
              try {
                viewer.ws.send(message)
              } catch (error) {
                console.error(`Failed to send to viewer ${viewer.id}:`, error)
                session.viewers.delete(viewer)
              }
            }
          })
        }
        return
      }

      // Handle JSON control messages
      const data = JSON.parse(message)
      console.log(`Message from ${clientId}:`, data.type)

      switch (data.type) {
        case "start":
          handleStartSession(ws, data, clientId)
          break

        case "join":
          handleJoinSession(ws, data, clientId)
          break

        case "stop":
          handleStopSession(sessionId)
          break

        default:
          console.log(`Unknown message type: ${data.type}`)
      }
    } catch (error) {
      console.error(`Error processing message from ${clientId}:`, error)
      ws.send(
        JSON.stringify({
          type: "error",
          message: "Invalid message format",
        }),
      )
    }
  })

  ws.on("error", (error) => {
    console.error(`WebSocket error for ${clientId}:`, error)
  })

  ws.on("close", () => {
    console.log(`Client disconnected: ${clientId}`)
    handleClientDisconnect()
  })

  function handleStartSession(ws, data, clientId) {
    sessionId = data.sessionId || uuidv4()
    isHost = true

    // Create new session
    streams.set(sessionId, {
      host: { ws, id: clientId },
      viewers: new Set(),
      createdAt: Date.now(),
    })

    // Clear any existing timeout
    if (sessionTimeouts.has(sessionId)) {
      clearTimeout(sessionTimeouts.get(sessionId))
      sessionTimeouts.delete(sessionId)
    }

    ws.send(
      JSON.stringify({
        type: "sessionCreated",
        sessionId: sessionId,
      }),
    )

    console.log(`Session started: ${sessionId} by ${clientId}`)
    updateViewerCount(sessionId)
  }

  function handleJoinSession(ws, data, clientId) {
    sessionId = data.sessionId

    if (!streams.has(sessionId)) {
      ws.send(
        JSON.stringify({
          type: "error",
          message: "Session not found or has ended",
        }),
      )
      ws.close()
      return
    }

    const session = streams.get(sessionId)
    session.viewers.add({ ws, id: clientId })

    ws.send(
      JSON.stringify({
        type: "joined",
        sessionId: sessionId,
      }),
    )

    console.log(`Viewer joined session: ${sessionId} (${clientId})`)
    updateViewerCount(sessionId)
  }

  function handleStopSession(sessionId) {
    if (streams.has(sessionId)) {
      const session = streams.get(sessionId)

      // Notify all viewers
      session.viewers.forEach((viewer) => {
        if (viewer.ws.readyState === WebSocket.OPEN) {
          try {
            viewer.ws.send(
              JSON.stringify({
                type: "sessionEnded",
              }),
            )
            viewer.ws.close()
          } catch (error) {
            console.error(`Failed to notify viewer ${viewer.id}:`, error)
          }
        }
      })

      streams.delete(sessionId)
      console.log(`Session terminated: ${sessionId}`)
    }
  }

  function handleClientDisconnect() {
    if (isHost && sessionId && streams.has(sessionId)) {
      // Host disconnected, terminate session
      handleStopSession(sessionId)
    } else if (sessionId && streams.has(sessionId)) {
      // Viewer disconnected, remove from session
      const session = streams.get(sessionId)
      session.viewers.forEach((viewer) => {
        if (viewer.id === clientId) {
          session.viewers.delete(viewer)
        }
      })
      updateViewerCount(sessionId)
    }
  }

  function updateViewerCount(sessionId) {
    if (!streams.has(sessionId)) return

    const session = streams.get(sessionId)
    const count = session.viewers.size

    // Send to host
    if (session.host.ws.readyState === WebSocket.OPEN) {
      try {
        session.host.ws.send(
          JSON.stringify({
            type: "viewerCount",
            count: count,
          }),
        )
      } catch (error) {
        console.error(`Failed to send viewer count to host:`, error)
      }
    }

    // Send to all viewers
    session.viewers.forEach((viewer) => {
      if (viewer.ws.readyState === WebSocket.OPEN) {
        try {
          viewer.ws.send(
            JSON.stringify({
              type: "viewerCount",
              count: count,
            }),
          )
        } catch (error) {
          console.error(`Failed to send viewer count to viewer ${viewer.id}:`, error)
          session.viewers.delete(viewer)
        }
      }
    })
  }
})

// Cleanup inactive sessions periodically
setInterval(
  () => {
    const now = Date.now()
    streams.forEach((session, sessionId) => {
      if (now - session.createdAt > SESSION_TIMEOUT) {
        console.log(`Cleaning up inactive session: ${sessionId}`)

        // Notify viewers
        session.viewers.forEach((viewer) => {
          if (viewer.ws.readyState === WebSocket.OPEN) {
            try {
              viewer.ws.send(
                JSON.stringify({
                  type: "sessionEnded",
                }),
              )
              viewer.ws.close()
            } catch (error) {
              console.error(`Failed to notify viewer during cleanup:`, error)
            }
          }
        })

        // Close host connection
        if (session.host.ws.readyState === WebSocket.OPEN) {
          try {
            session.host.ws.close()
          } catch (error) {
            console.error(`Failed to close host connection during cleanup:`, error)
          }
        }

        streams.delete(sessionId)
      }
    })
  },
  5 * 60 * 1000,
) // Check every 5 minutes

// Health check endpoint
app.get("/health", (req, res) => {
  res.json({
    status: "healthy",
    activeSessions: streams.size,
    uptime: process.uptime(),
  })
})

// Use environment PORT for deployment platforms like Render, Heroku, etc.
const PORT = process.env.PORT || 3000
const HOST = "0.0.0.0"

server.listen(PORT, HOST, () => {
  console.log(`Server running at http://localhost:${PORT}`)
  console.log(`Environment: ${process.env.NODE_ENV || "development"}`)
  console.log(`WebSocket server initialized`)
})

// Graceful shutdown
process.on("SIGTERM", () => {
  console.log("Shutting down server gracefully...")

  // Close all WebSocket connections
  wss.clients.forEach((client) => {
    if (client.readyState === WebSocket.OPEN) {
      client.send(
        JSON.stringify({
          type: "serverShutdown",
          message: "Server is shutting down",
        }),
      )
      client.close()
    }
  })

  // Close HTTP server
  server.close(() => {
    console.log("Server shutdown complete")
    process.exit(0)
  })
})

process.on("SIGINT", () => {
  console.log("Received SIGINT, shutting down gracefully...")
  process.emit("SIGTERM")
})

// Handle uncaught exceptions
process.on("uncaughtException", (error) => {
  console.error("Uncaught Exception:", error)
  process.exit(1)
})

process.on("unhandledRejection", (reason, promise) => {
  console.error("Unhandled Rejection at:", promise, "reason:", reason)
  process.exit(1)
})