# Add to docker-compose.yml for production
live-stream:
  image: tiangolo/nginx-rtmp
  container_name: payday-stream
  restart: unless-stopped
  ports:
    - "1935:1935"   # RTMP ingest (host streams to this)
    - "8080:80"     # HLS output (attendees watch via HTTP)
  volumes:
    - ./nginx/rtmp.conf:/etc/nginx/nginx.conf:ro
    - stream_data:/tmp/hls
  networks:
    payday-network:
      ipv4_address: 172.20.0.50

rtmp {
  server {
    listen 1935;
    chunk_size 4096;

    application live {
      live on;
      record off;

      # Verify stream key before allowing broadcast
      on_publish http://api:3000/api/v1/events/verify-stream-key;

      # HLS output for browser playback
      hls on;
      hls_path /tmp/hls;
      hls_fragment 3s;
      hls_playlist_length 60s;
    }
  }
}

http {
  server {
    listen 80;
    location /hls/ {
      types { application/vnd.apple.mpegurl m3u8; video/mp2t ts; }
      root /tmp;
      add_header Cache-Control no-cache;
      add_header Access-Control-Allow-Origin *;
    }
  }
}

// In EventsController:
@Post('verify-stream-key')
@Public()
async verifyStreamKey(@Body() body: { name: string; tcurl: string }) {
  // 'name' is the stream key sent by the broadcaster's OBS/software
  const event = await this.eventsService.findByStreamKey(body.name);
  if (!event || event.status !== 'published') {
    throw new ForbiddenException('Invalid stream key');
  }
  return { allowed: true };
}

// Frontend receives this URL after joining event room via Socket.io:
const hlsUrl = `http://yourdomain.com:8080/hls/${streamKey}/index.m3u8`;

// Use HLS.js in the browser:
const hls = new Hls();
hls.loadSource(hlsUrl);
hls.attachMedia(videoElement);

// Add mux-node to package.json
// In EventsService.createEvent():
const stream = await muxClient.Video.LiveStreams.create({
  playback_policy: ['signed'],  // requires JWT to view
  new_asset_settings: {
    playback_policy: ['public'],  // recording is public
  },
});

// Store in event record:
event.streamKey = stream.stream_key;        // Host uses this for OBS
event.streamPlaybackId = stream.playback_ids[0].id;  // Attendees use this URL

// Attendee stream URL:
const streamUrl = `https://stream.mux.com/${event.streamPlaybackId}.m3u8`;

1. Host creates event via POST /events
   → stream_key auto-generated (UUID) and stored in events table

2. Attendee RSVPs via POST /events/:id/rsvp
   → Confirmation email queued
   → Reminder notification queued for 1hr before starts_at

3. Host starts streaming (OBS → RTMP)
   → nginx-rtmp verifies stream key via API
   → HLS segments begin generating in /tmp/hls/

4. Host marks event live: PATCH /events/:id/go-live
   → events.status = 'live'
   → Socket.io emits event_started to all in event:{eventId} room
   → All attendees receive HLS stream URL in the event

5. Attendees watch via HLS.js in browser
   → ~5-10s latency (self-hosted RTMP)

6. Chat during event: uses existing Socket.io messaging
   → All attendees in event:{eventId} room can send messages
   → Messages displayed in real-time overlay

7. Host ends stream → OBS stops
   → HLS segments stop generating
   → Host calls PATCH /events/:id/complete
   → status = 'completed'
   → Optional: upload recording URL

8. Recording added:
   → PATCH /events/:id/complete { recordingUrl: "..." }
   → events.recording_url stored
   → All RSVPed attendees notified via email

// Server → Client (all attendees in event room)
event_started    → { eventId, streamUrl, startedAt }
event_ended      → { eventId, endedAt, recordingUrl? }
viewer_count     → { eventId, count }   // emit every 30s

// Client → Server
join_event       → { eventId }    // verified by RSVP check, joins room
leave_event      → { eventId }
send_event_chat  → { eventId, message }

// Server → Client (chat)
event_chat       → { userId, displayName, avatarUrl, message, sentAt }

# FFmpeg command to combine HLS → MP4 (run in media container or post-processing job)
ffmpeg -i /tmp/hls/{streamKey}/index.m3u8 -c copy /app/uploads/recordings/{eventId}.mp4