src/lib/elements/video/videoStreaming.svelte.ts

/**
 * Video Streaming System - Input/Output Architecture
 * Clean separation between input sources and output destinations
 */

import { video } from '@robothub/transport-server-client';
import type { video as videoTypes } from '@robothub/transport-server-client';
import { settings } from '$lib/runes/settings.svelte';

// Input/Output state using runes
export class VideoStreamingState {
  // Input state (what you're viewing)
  input = $state({
    type: null as 'local-camera' | 'remote-stream' | null,
    stream: null as MediaStream | null,
    client: null as videoTypes.VideoConsumer | null,
    roomId: null as string | null,
  });

  // Output state (what you're broadcasting)
  output = $state({
    active: false,
    client: null as videoTypes.VideoProducer | null,
    roomId: null as string | null,
  });

  // Room listing state
  rooms = $state<videoTypes.RoomInfo[]>([]);
  roomsLoading = $state(false);

  // Derived state
  get hasInput() {
    return this.input.type !== null && this.input.stream !== null;
  }

  get hasOutput() {
    return this.output.active;
  }

  get canOutput() {
    // Can only output if input is local camera (not remote stream)
    return this.input.type === 'local-camera' && this.input.stream !== null;
  }

  get currentStream() {
    return this.input.stream;
  }
}

// Create global instance
export const videoStreaming = new VideoStreamingState();

// External action functions
export const videoActions = {

  // Room management
  async listRooms(workspaceId: string): Promise<videoTypes.RoomInfo[]> {
    videoStreaming.roomsLoading = true;
    try {
      const client = new video.VideoClientCore(settings.transportServerUrl);
      const rooms = await client.listRooms(workspaceId);
      videoStreaming.rooms = rooms;
      return rooms;
    } catch (error) {
      console.error('Failed to list rooms:', error);
      videoStreaming.rooms = [];
      return [];
    } finally {
      videoStreaming.roomsLoading = false;
    }
  },

  // Input actions
  async connectLocalCamera(): Promise<{ success: boolean; error?: string }> {
    try {
      // Get local camera stream - no server connection needed for local viewing
      const stream = await navigator.mediaDevices.getUserMedia({
        video: { width: 1280, height: 720 },
        audio: true
      });

      // First disconnect any existing input to avoid conflicts
      await this.disconnectInput();

      // Update input state - purely local, no server interaction
      videoStreaming.input.type = 'local-camera';
      videoStreaming.input.stream = stream;
      videoStreaming.input.client = null;
      videoStreaming.input.roomId = null;

      console.log('Local camera connected (local viewing only)');
      return { success: true };
    } catch (error) {
      console.error('Failed to connect local camera:', error);
      return { success: false, error: error instanceof Error ? error.message : String(error) };
    }
  },

  async connectRemoteStream(workspaceId: string, roomId: string): Promise<{ success: boolean; error?: string }> {
    try {
      // First disconnect any existing input
      await this.disconnectInput();

      const consumer = new video.VideoConsumer(settings.transportServerUrl);
      const connected = await consumer.connect(workspaceId, roomId, 'consumer-id');
      
      if (!connected) {
        throw new Error('Failed to connect to remote stream');
      }

      // Start receiving video
      await consumer.startReceiving();

      // Set up stream receiving
      consumer.on('streamReceived', (stream: MediaStream) => {
        videoStreaming.input.stream = stream;
      });

      // Update input state
      videoStreaming.input.type = 'remote-stream';
      videoStreaming.input.client = consumer;
      videoStreaming.input.roomId = roomId;

      console.log('Remote stream connected');
      return { success: true };
    } catch (error) {
      console.error('Failed to connect remote stream:', error);
      return { success: false, error: error instanceof Error ? error.message : String(error) };
    }
  },

  async disconnectInput(): Promise<void> {
    // Stop local camera tracks if any
    if (videoStreaming.input.stream && videoStreaming.input.type === 'local-camera') {
      videoStreaming.input.stream.getTracks().forEach(track => track.stop());
    }

    // Disconnect remote client if any
    if (videoStreaming.input.client) {
      videoStreaming.input.client.disconnect();
    }

    // Reset input state
    videoStreaming.input.type = null;
    videoStreaming.input.stream = null;
    videoStreaming.input.client = null;
    videoStreaming.input.roomId = null;

    console.log('Input disconnected');
  },

  // Output actions
  async startOutput(workspaceId: string): Promise<{ success: boolean; error?: string; roomId?: string }> {
    if (!videoStreaming.canOutput) {
      return { success: false, error: 'Cannot output - input must be local camera' };
    }

    try {
      const producer = new video.VideoProducer(settings.transportServerUrl);
      
      // Create room
      const roomData = await producer.createRoom(workspaceId);
      const connected = await producer.connect(roomData.workspaceId, roomData.roomId, 'producer-id');
      
      if (!connected) {
        throw new Error('Failed to connect producer');
      }

      // Use the current input stream for output by starting camera with existing stream
      if (videoStreaming.input.stream) {
        // We need to use the producer's startCamera method properly
        // For now, we'll start a new camera stream since we can't directly use existing stream
        await producer.startCamera({
          video: { width: 1280, height: 720 },
          audio: true
        });
      }

      // Update output state
      videoStreaming.output.active = true;
      videoStreaming.output.client = producer;
      videoStreaming.output.roomId = roomData.roomId;

      // Refresh room list
      await this.listRooms(workspaceId);

      console.log('Output started, room created:', roomData.roomId);
      return { success: true, roomId: roomData.roomId };
    } catch (error) {
      console.error('Failed to start output:', error);
      return { success: false, error: error instanceof Error ? error.message : String(error) };
    }
  },

  async stopOutput(): Promise<void> {
    if (videoStreaming.output.client) {
      videoStreaming.output.client.disconnect();
    }

    // Reset output state
    videoStreaming.output.active = false;
    videoStreaming.output.client = null;
    videoStreaming.output.roomId = null;

    console.log('Output stopped');
  },

  // Utility functions
  async refreshRooms(workspaceId: string): Promise<void> {
    await this.listRooms(workspaceId);
  },

  getAvailableRooms(): videoTypes.RoomInfo[] {
    return videoStreaming.rooms.filter(room => room.participants.producer !== null);
  },

  getRoomById(roomId: string): videoTypes.RoomInfo | undefined {
    return videoStreaming.rooms.find(room => room.id === roomId);
  }
};