wsb-daemon 0.258.6441

use wsb::prelude::*;
use axum::{
    extract::{Path, State},
    http::StatusCode,
    Json,
};

use super::sessions::ErrorResponse;
use crate::web::machine_web::MachineWeb;

pub async fn list_starred(
    State(state): State<MachineWeb>,
) -> Result<Json<serde_json::Value>, (StatusCode, Json<ErrorResponse>)> {
    let db = state.db.clone();

    let ids = tokio::task::spawn_blocking(move || db.list_starred())
        .await
        .unwrap_or_else(|e| Err(anyhow::anyhow!("join error: {}", e)))
        .map_err(|e| {
            (
                StatusCode::INTERNAL_SERVER_ERROR,
                Json(ErrorResponse {
                    error: e.to_string(),
                }),
            )
        })?;
    Ok(Json(serde_json::json!({ "session_ids": ids })))
}

pub async fn star_session(
    State(state): State<MachineWeb>,
    Path(id): Path<String>,
) -> Result<StatusCode, (StatusCode, Json<ErrorResponse>)> {
    let db = state.db.clone();
    let id_check = id.clone();

    let session = tokio::task::spawn_blocking(move || db.get_session(&id_check))
        .await
        .unwrap_or_else(|e| Err(anyhow::anyhow!("join error: {}", e)))
        .map_err(|e| {
            (
                StatusCode::INTERNAL_SERVER_ERROR,
                Json(ErrorResponse {
                    error: e.to_string(),
                }),
            )
        })?;

    if session.is_none() {
        return Err((
            StatusCode::NOT_FOUND,
            Json(ErrorResponse {
                error: "session not found".to_string(),
            }),
        ));
    }

    tokio::task::spawn_blocking({
        let db = state.db.clone();
        move || db.star_session(&id)
    })
    .await
    .unwrap_or_else(|e| Err(anyhow::anyhow!("join error: {}", e)))
    .map_err(|e| {
        (
            StatusCode::INTERNAL_SERVER_ERROR,
            Json(ErrorResponse {
                error: e.to_string(),
            }),
        )
    })?;
    Ok(StatusCode::NO_CONTENT)
}

pub async fn unstar_session(
    State(state): State<MachineWeb>,
    Path(id): Path<String>,
) -> Result<StatusCode, (StatusCode, Json<ErrorResponse>)> {
    tokio::task::spawn_blocking({
        let db = state.db.clone();
        move || db.unstar_session(&id)
    })
    .await
    .unwrap_or_else(|e| Err(anyhow::anyhow!("join error: {}", e)))
    .map_err(|e| {
        (
            StatusCode::INTERNAL_SERVER_ERROR,
            Json(ErrorResponse {
                error: e.to_string(),
            }),
        )
    })?;
    Ok(StatusCode::NO_CONTENT)
}

#[derive(Deserialize)]
pub struct BulkStarRequest {
    pub session_ids: Vec<String>,
}

pub async fn bulk_star(
    State(state): State<MachineWeb>,
    Json(body): Json<BulkStarRequest>,
) -> Result<StatusCode, (StatusCode, Json<ErrorResponse>)> {
    let db = state.db.clone();
    let ids = body.session_ids;

    tokio::task::spawn_blocking(move || db.bulk_star(&ids))
        .await
        .unwrap_or_else(|e| Err(anyhow::anyhow!("join error: {}", e)))
        .map_err(|e| {
            (
                StatusCode::INTERNAL_SERVER_ERROR,
                Json(ErrorResponse {
                    error: e.to_string(),
                }),
            )
        })?;
    Ok(StatusCode::NO_CONTENT)
}