Sistema de Comunicação por WebSockets

┌──────────────────────────────────────────────────────────────────────┐
│                         FRONTEND (React/JS)                          │
│  ┌──────────────────┐   ┌──────────────────┐   ┌─────────────────┐  │
│  │  Text WebSocket  │   │ Audio WebSocket  │   │ Robot WebSocket │  │
│  │  (Chat)          │   │  (Chat)          │   │ (Checkpoints)   │  │
│  └────────┬─────────┘   └────────┬─────────┘   └────────┬────────┘  │
└───────────┼──────────────────────┼──────────────────────┼───────────┘
            │                      │                       │
            ▼                      ▼                       ▼
┌──────────────────────────────────────────────────────────────────────┐
│                      BACKEND (Actix-Web + Rust)                      │
│  ┌────────────────────────────────────────────────────────────────┐  │
│  │              Broadcast Server (Central Hub - Chat)             │  │
│  │  - Conexões de texto e áudio                                   │  │
│  │  - Broadcast de mensagens                                      │  │
│  │  - Conversão Texto→Áudio (TTS)                                 │  │
│  │  - Exclusão de eco por cliente                                 │  │
│  └────────────────────────────────────────────────────────────────┘  │
│                                                                       │
│  ┌────────────────────────────────────────────────────────────────┐  │
│  │         Robot Client + Frontend Server (Checkpoints)           │  │
│  │  - Cliente WebSocket → Conecta ao servidor Python do robô      │  │
│  │  - Servidor WebSocket → Aceita conexões do frontend            │  │
│  │  - Relay inteligente de eventos e comandos                     │  │
│  │  - Atualização automática do banco de dados (PostgreSQL)       │  │
│  └────────────────────────────────────────────────────────────────┘  │
│        ▲                                             │                │
│        │ WebSocket Client                            │ Broadcast      │
│        │ (tokio-tungstenite)                         │ (actix-ws)     │
└────────┼─────────────────────────────────────────────┼────────────────┘
         │                                             │
         ▼                                             ▼
┌──────────────────────────────────────────────────────────────────────┐
│                    ROBOT (Python + aiohttp)                          │
│  ┌────────────────────────────────────────────────────────────────┐  │
│  │              WebSocket Server (move_path.py)                   │  │
│  │  - Recebe comandos do backend (play, stop, get_status)         │  │
│  │  - Envia eventos de checkpoint em tempo real                   │  │
│  │  - Controla movimento físico do robô via WebRTC               │  │
│  └────────────────────────────────────────────────────────────────┘  │
└──────────────────────────────────────────────────────────────────────┘
         ▲
         │ WebRTC (movimento físico)
         ▼
    🤖 Robô Físico

pub struct BroadcastServer {
    text_clients: HashMap<String, Recipient<BroadcastMessage>>,
    audio_clients: HashMap<String, Recipient<BroadcastAudio>>,
    ml_endpoint: String,
}

{
  "type": "text",
  "texto": "Qual é a história deste lugar?",
  "checkpoint_id": 123,
  "estado": "active",
  "question_topic": "história",
  "tour_id": 456
}

{
  "texto": "Este lugar tem uma história fascinante...",
  "message_type": "resposta"
}

Cliente envia áudio (base64)
→ AudioWebSocket decodifica áudio
→ STT transcreve para texto
→ Modelo recebe texto
→ Modelo retorna resposta
→ TTS converte resposta em áudio
→ Texto e áudio retornam ao cliente
→ Broadcast para outros clientes

Cliente envia texto
→ Modelo retorna resposta
→ TTS converte resposta em áudio
→ Sistema envia texto e áudio ao cliente
→ Broadcast para todos os clientes

POST /v1/modelo

pub struct RobotClient {
    robot_ip: String,
    writer: Arc<Mutex<Option<WsWriter>>>,
    frontend_tx: broadcast::Sender<FrontendEvent>,
    db_pool: PgPool,
}

RobotCommand::play()        // Executar próximo checkpoint
RobotCommand::stop()        // Parada de emergência
RobotCommand::get_status()  // Consultar status atual

// Quando checkpoint inicia
sqlx::query(
    "UPDATE checkpoints
     SET status = $1, inicio_real = $2
     WHERE tipo = $3 AND ordem = $4"
)
.bind("running")
.bind(inicio_dt)
.bind(&tipo)
.bind(ordem)
.execute(db_pool)
.await?;

// Quando checkpoint completa
sqlx::query(
    "UPDATE checkpoints
     SET status = $1, fim_real = $2
     WHERE tipo = $3 AND ordem = $4"
)
.bind("finished")
.bind(fim_dt)
.bind(&tipo)
.bind(ordem)
.execute(db_pool)
.await?;

pub async fn ws_frontend_handler(
    req: HttpRequest,
    stream: web::Payload,
    app_state: web::Data<AppState>,
) -> Result<HttpResponse, Error>

tokio::select! {
    // Recebe eventos do robô → Envia para frontend
    Ok(event) = frontend_rx.recv() => {
        session.text(json).await?;
    }

    // Recebe comandos do frontend → Envia para robô
    Some(Ok(msg)) = msg_stream.next() => {
        let cmd = serde_json::from_str::<FrontendCommand>(&text)?;
        robot_client.send_command(cmd).await?;
    }
}

pub enum RobotEvent {
    Connected { status: RobotStatus },
    CheckpointStarted { tipo: String, ordem: i32, status: String, inicio_real: String },
    CheckpointCompleted { tipo: String, ordem: i32, status: String, inicio_real: String, fim_real: String },
    EmergencyStop { tipo: Option<String>, ordem: Option<i32> },
    RobotConnected { status: String },
}

pub enum FrontendEvent {
    RobotStatus { robot_connected: bool, is_running: bool, current_checkpoint: Option<String> },
    CheckpointStarted { tipo: String, ordem: i32, status: String, inicio_real: DateTime<Utc> },
    CheckpointCompleted { tipo: String, ordem: i32, status: String, inicio_real: DateTime<Utc>, fim_real: DateTime<Utc> },
    EmergencyStop { tipo: Option<String>, ordem: Option<i32> },
    Error { message: String },
}

pub enum FrontendCommand {
    Play,
    Stop,
    GetStatus,
}

1. Frontend envia comando
   Frontend → Backend: { "command": "play" }

2. Backend encaminha para robô
   Backend (RobotClient) → Robot Server: { "action": "play" }

3. Robô inicia movimento
   Robot Server → Backend: { "event": "checkpoint_started", "tipo": "recepcao", "ordem": 1, ... }

4. Backend atualiza banco de dados
   UPDATE checkpoints SET status='running', inicio_real='2025-12-15T14:02:35Z' WHERE tipo='recepcao'

5. Backend relata para frontend
   Backend → Frontend: { "event": "checkpoint_started", "tipo": "recepcao", ... }

6. Frontend atualiza UI
   UI mostra: "🚀 Indo para Recepção..."
   Perguntas bloqueadas até chegada

7. Robô chega no destino
   Robot Server → Backend: { "event": "checkpoint_completed", "tipo": "recepcao", "fim_real": "..." }

8. Backend atualiza banco
   UPDATE checkpoints SET status='finished', fim_real='2025-12-15T14:08:12Z' WHERE tipo='recepcao'

9. Backend relata para frontend
   Backend → Frontend: { "event": "checkpoint_completed", "tipo": "recepcao", ... }

10. Frontend libera perguntas
    UI mostra: "✅ Chegou na Recepção! Faça suas perguntas"
    Perguntas do checkpoint 'recepcao' liberadas

1. Frontend envia stop
   Frontend → Backend: { "command": "stop" }

2. Backend encaminha
   Backend → Robot: { "action": "stop" }

3. Robô para imediatamente
   Robot Server → Backend: { "event": "emergency_stop", "tipo": "auditorio", "ordem": 2 }

4. Backend atualiza banco
   UPDATE checkpoints SET status='skipped' WHERE tipo='auditorio' AND status='running'

5. Backend notifica frontend
   Backend → Frontend: { "event": "emergency_stop", "tipo": "auditorio" }

6. Frontend mostra alerta
   UI: "🛑 Tour interrompido! Checkpoint 'Auditório' foi pulado"

{
  "message_type": "broadcast_text",
  "texto": "Resposta do modelo..."
}

{
  "message_type": "broadcast_audio",
  "audio_base64": "AAAAFJDSAIWEA..."
}

{
  "event": "checkpoint_started",
  "tipo": "recepcao",
  "ordem": 1,
  "status": "running",
  "inicio_real": "2025-12-15T14:02:35.123Z"
}

{
  "event": "checkpoint_completed",
  "tipo": "recepcao",
  "ordem": 1,
  "status": "finished",
  "inicio_real": "2025-12-15T14:02:35.123Z",
  "fim_real": "2025-12-15T14:08:12.456Z"
}

{
  "event": "robot_status",
  "robot_connected": true,
  "is_running": false,
  "current_checkpoint": "recepcao"
}

[settings.server]
host = "0.0.0.0"
port = 8081  # Backend Rust

[settings.database]
host = "aws-1-us-east-2.pooler.supabase.com"
username = "postgres.xxxxx"
password = "xxxxx"
database = "postgres"
port = 5432
max_connections = 5

[settings.robot]
ip = "127.0.0.1"  # IP do servidor Python do robô (localhost para testes)

# Terminal 1: Servidor Python do robô
cd 2025-2B-T12-EC08-ROBO
python move_path.py

# Terminal 2: Backend Rust
cd 2025-2B-T12-EC08-BACK
cargo run -- --config config.toml

# Terminal 3: Cliente de teste
cd 2025-2B-T12-EC08-BACK
python test_websocket.py interactive --url ws://localhost:8081/ws

✅ Conectado ao robô!
📡 Iniciando listener de eventos do robô
🤖 Status inicial do robô: robot_connected=false
▶️ Checkpoint INICIADO: recepcao (ordem: 1)
💾 Checkpoint atualizado no banco: recepcao -> running
✅ Checkpoint CONCLUÍDO: recepcao (status: finished)
💾 Checkpoint finalizado no banco: recepcao -> finished