use room::ws_context::WsUserContext;

use crate::error::AppTransportError;
use crate::handler::session::TransportSession;
use crate::handler::types::WsOutEvent;

pub(crate) async fn ping() -> Result<Option<WsOutEvent>, AppTransportError> {
    Ok(Some(WsOutEvent::Pong {
        protocol_version: crate::handler::types::WS_PROTOCOL_VERSION,
    }))
}

pub(crate) async fn subscribe(
    session: &TransportSession,
    room: models::RoomId,
) -> Result<Option<WsOutEvent>, AppTransportError> {
    let sub = session.subscribe_room(room).await.map_err(|e| {
        tracing::warn!(error = %e, "subscribe_room failed");
        AppTransportError::Internal
    })?;
    session.subscriptions.insert(room, sub);
    session.service.room.spawn_room_workers(room);
    session.refresh_project().await;
    Ok(None)
}

pub(crate) async fn unsubscribe(
    session: &TransportSession,
    room: models::RoomId,
) -> Result<Option<WsOutEvent>, AppTransportError> {
    session.unsubscribe_room(room).await;
    Ok(None)
}

pub(crate) async fn typing_start(
    session: &TransportSession,
    room: models::RoomId,
) -> Result<Option<WsOutEvent>, AppTransportError> {
    session.broadcast_typing(room, "start").await;
    Ok(None)
}

pub(crate) async fn typing_stop(
    session: &TransportSession,
    room: models::RoomId,
) -> Result<Option<WsOutEvent>, AppTransportError> {
    session.broadcast_typing(room, "stop").await;
    Ok(None)
}

pub(crate) async fn read_receipt(
    session: &TransportSession,
    room: models::RoomId,
    last_read_seq: i64,
) -> Result<Option<WsOutEvent>, AppTransportError> {
    let ctx = WsUserContext::new(session.user.user_id);
    session
        .service
        .room
        .room_user_state_update_read_seq(room, last_read_seq, &ctx)
        .await
        .map_err(|e| {
            tracing::warn!(error = %e, "room_user_state_update_read_seq failed");
            AppTransportError::Internal
        })?;
    Ok(None)
}