siren/service/src/bot/guilds/routes.rs

use std::{sync::Arc, pin::Pin};

use actix_web::{get, post, web, HttpResponse, ResponseError};
use serde::{Serialize, Deserialize};
use serenity::model::prelude::{GuildChannel, ChannelType};
use siren::{ServiceError, Response};

use crate::{AppState, bot::commands::audio::{play::play_track, join}, bot::guilds::QueryGuild, auth::{Auth, verify_role}};

#[get("/guilds")]
async fn get_guilds(data: web::Data<Arc<AppState>>, auth: Auth) -> HttpResponse {
  if let Err(err) = verify_role(&auth, "admin") {
    return ResponseError::error_response(&err)
  };
  let guild_results = &data.http.get_guilds(None, None).await;
  let guilds = match guild_results {
    Ok(guilds) => guilds,
    Err(err) => return ResponseError::error_response(&ServiceError {
      status: 422,
      message: err.to_string()
    })
  };
  HttpResponse::Ok().json(Response {
    data: guilds,
    metadata: None
  })
}

#[get("/{id}/text")]
async fn get_text_channels(id: web::Path<String>, data: web::Data<Arc<AppState>>, auth: Auth) -> HttpResponse {
  if let Err(err) = verify_role(&auth, "admin") {
    return ResponseError::error_response(&err)
  };
  let channel_results = &data.http.get_channels(id.parse::<u64>().unwrap()).await;
  let channels = match channel_results {
    Ok(channels) => channels.iter().filter(|c| c.kind == ChannelType::Text).collect::<Vec<&GuildChannel>>(),
    Err(err) => return ResponseError::error_response(&ServiceError {
      status: 422,
      message: err.to_string()
    })
  };
  HttpResponse::Ok().json(Response {
    data: channels,
    metadata: None
  })
}

#[get("/{id}/voice")]
async fn get_voice_channels(id: web::Path<String>, data: web::Data<Arc<AppState>>, auth: Auth) -> HttpResponse {
  if let Err(err) = verify_role(&auth, "admin") {
    return ResponseError::error_response(&err)
  };
  let channel_results = &data.http.get_channels(id.parse::<u64>().unwrap()).await;
  let channels = match channel_results {
    Ok(channels) => channels.iter().filter(|c| c.kind == ChannelType::Voice).collect::<Vec<&GuildChannel>>(),
    Err(err) => return ResponseError::error_response(&ServiceError {
      status: 422,
      message: err.to_string()
    })
  };
  HttpResponse::Ok().json(Response {
    data: channels,
    metadata: None
  })
}

#[derive(Serialize, Deserialize)]
struct ChannelMessage {
  message: String
}

#[post("/{guild_id}/text/{channel_id}/message")]
async fn send_message(path: web::Path<(String, String)>, text: web::Json<ChannelMessage>, data: web::Data<Arc<AppState>>, auth: Auth) -> HttpResponse {
  if let Err(err) = verify_role(&auth, "admin") {
    return ResponseError::error_response(&err)
  };
  let (guild_id, channel_id) = path.into_inner();
  let guild_id = match guild_id.parse::<u64>() {
    Ok(id) => id,
    Err(err) => {
      return ResponseError::error_response(&ServiceError {
        status: 422,
        message: err.to_string()
      })
    }
  };
  let channel_id = match channel_id.parse::<u64>() {
    Ok(id) => id,
    Err(err) => {
      return ResponseError::error_response(&ServiceError {
        status: 422,
        message: err.to_string()
      })
    }
  };
  let channel_results = &data.http.get_channels(guild_id).await;
  let channels = match channel_results {
    Ok(channels) => channels,
    Err(err) => {
      return ResponseError::error_response(&ServiceError {
        status: 422,
        message: err.to_string()
      })
    }
  };
  
  let channel = match channels.iter().find(|c| c.id.0 == channel_id) {
    Some(channel) => channel,
    None => {
      return ResponseError::error_response(&ServiceError {
        status: 422,
        message: format!("Could not find channel with id {}", channel_id)
      })
    }
  };

  if let Err(err) = channel.say(&Pin::new(&data.http).get_ref(), &text.message).await {
    return ResponseError::error_response(&ServiceError {
      status: 422,
      message: err.to_string()
    })
  };

  HttpResponse::Ok().finish()
}

#[derive(Serialize, Deserialize)]
struct PlayRequest {
  track_url: String
}

#[post("/{guild_id}/voice/{channel_id}/play")]
async fn play(path: web::Path<(String, String)>, play_request: web::Json<PlayRequest>, data: web::Data<Arc<AppState>>, auth: Auth) -> HttpResponse {
  if let Err(err) = verify_role(&auth, "admin") {
    return ResponseError::error_response(&err)
  };
  let (guild_id, channel_id) = path.into_inner();
  let guild_id = match guild_id.parse::<u64>() {
    Ok(id) => id,
    Err(err) => {
      return ResponseError::error_response(&ServiceError { status: 422, message: err.to_string() })
    }
  };
  let channel_id = match channel_id.parse::<u64>() {
    Ok(id) => id,
    Err(err) => {
      return ResponseError::error_response(&ServiceError { status: 422, message: err.to_string() })
    }
  };
  let http = Pin::new(&data.http).get_ref();
  let guild = match http.get_guild(guild_id).await {
    Ok(guild) => guild,
    Err(err) => {
      return ResponseError::error_response(&ServiceError { status: 422, message: err.to_string() })
    }
  };
  let channel = match http.get_channel(channel_id).await {
    Ok(channel) => channel,
    Err(err) => {
      return ResponseError::error_response(&ServiceError { status: 422, message: err.to_string() })
    }
  };

  let manager = Arc::clone(&data.songbird);

  match join(Arc::clone(&manager), &guild.id, &channel.id()).await {
    Ok(_) => {
      match play_track(Arc::clone(&data.songbird), guild.id, play_request.track_url.to_string()).await {
        Ok(_) => HttpResponse::Ok().finish(),
        Err(err) => {
          return ResponseError::error_response(&err)
        }
      }
    },
    Err(err) => {
      return ResponseError::error_response(&ServiceError { status: 500, message: err.to_string() })
    }
  }
}

#[post("/{guild_id}/voice/stop")]
async fn stop(path: web::Path<String>, data: web::Data<Arc<AppState>>, auth: Auth) -> HttpResponse {
  if let Err(err) = verify_role(&auth, "admin") {
    return ResponseError::error_response(&err)
  };
  let guild_id = path.into_inner();
  let guild_id = match guild_id.parse::<u64>() {
    Ok(id) => id,
    Err(err) => {
      return ResponseError::error_response(&ServiceError {
        status: 422,
        message: err.to_string()
      })
    }
  };

  if let Some(handler_lock) = data.songbird.get(guild_id) {
    let handler = handler_lock.lock().await;
    handler.queue().stop();
  }

  HttpResponse::Ok().finish()
}

#[post("/{guild_id}/voice/resume")]
async fn resume(path: web::Path<String>, data: web::Data<Arc<AppState>>, auth: Auth) -> HttpResponse {
  if let Err(err) = verify_role(&auth, "admin") {
    return ResponseError::error_response(&err)
  };
  let guild_id = path.into_inner();
  let guild_id = match guild_id.parse::<u64>() {
    Ok(id) => id,
    Err(err) => {
      return ResponseError::error_response(&ServiceError {
        status: 422,
        message: err.to_string()
      })
    }
  };

  if let Some(handler_lock) = data.songbird.get(guild_id) {
    let handler = handler_lock.lock().await;
    if let Err(err) = handler.queue().resume() {
      return ResponseError::error_response(&ServiceError {
        status: 422,
        message: err.to_string()
      })
    }
  }

  HttpResponse::Ok().finish()
}

#[post("/{guild_id}/voice/pause")]
async fn pause(path: web::Path<String>, data: web::Data<Arc<AppState>>, auth: Auth) -> HttpResponse {
  if let Err(err) = verify_role(&auth, "admin") {
    return ResponseError::error_response(&err)
  };
  let guild_id = path.into_inner();
  let guild_id = match guild_id.parse::<u64>() {
    Ok(id) => id,
    Err(err) => {
      return ResponseError::error_response(&ServiceError {
        status: 422,
        message: err.to_string()
      })
    }
  };

  if let Some(handler_lock) = data.songbird.get(guild_id) {
    let handler = handler_lock.lock().await;
    if let Err(err) = handler.queue().pause() {
      return ResponseError::error_response(&ServiceError {
        status: 422,
        message: err.to_string()
      })
    }
  }

  HttpResponse::Ok().finish()
}

#[derive(Serialize, Deserialize)]
struct SetVolume {
  volume: String
}

#[get("/{guild_id}/voice/volume")]
async fn get_volume(path: web::Path<String>, auth: Auth) -> HttpResponse {
  if let Err(err) = verify_role(&auth, "admin") {
    return ResponseError::error_response(&err)
  };
  let guild_id = path.into_inner();
  let guild_id = match guild_id.parse::<u64>() {
    Ok(id) => id,
    Err(err) => {
      return ResponseError::error_response(&ServiceError {
        status: 422,
        message: err.to_string()
      })
    }
  };

  let volume = match QueryGuild::get(guild_id as i64) {
    Ok(guild) => guild.volume,
    Err(err) => {
      return ResponseError::error_response(&ServiceError {
        status: 422,
        message: err.to_string()
      })
    }
  };

  HttpResponse::Ok().json(volume)
}

#[post("/{guild_id}/voice/volume")]
async fn set_volume(path: web::Path<String>, volume: web::Json::<SetVolume>, data: web::Data<Arc<AppState>>, auth: Auth) -> HttpResponse {
  if let Err(err) = verify_role(&auth, "admin") {
    return ResponseError::error_response(&err)
  };
  let guild_id = path.into_inner();
  let guild_id = match guild_id.parse::<u64>() {
    Ok(id) => id,
    Err(err) => {
      return ResponseError::error_response(&ServiceError {
        status: 422,
        message: err.to_string()
      })
    }
  };

  let volume = volume.volume.parse::<i32>().unwrap_or(0);
  let manager = Arc::clone(&data.songbird);
  let http = Arc::clone(&data.http);
  let guild = match http.get_guild(guild_id).await {
    Ok(guild) => guild,
    Err(err) => {
      return ResponseError::error_response(&ServiceError { status: 422, message: err.to_string() })
    }
  };
  crate::bot::commands::audio::volume::set_volume(manager, guild.id, volume).await;

  HttpResponse::Ok().finish()
}

#[post("/{guild_id}/voice/skip")]
async fn skip(path: web::Path<String>, data: web::Data<Arc<AppState>>, auth: Auth) -> HttpResponse {
  if let Err(err) = verify_role(&auth, "admin") {
    return ResponseError::error_response(&err)
  };
  let guild_id = path.into_inner();
  let guild_id = match guild_id.parse::<u64>() {
    Ok(id) => id,
    Err(err) => {
      return ResponseError::error_response(&ServiceError {
        status: 422,
        message: err.to_string()
      })
    }
  };

  if let Some(handler_lock) = data.songbird.get(guild_id) {
    let handler = handler_lock.lock().await;
    if let Err(err) = handler.queue().skip() {
      return ResponseError::error_response(&ServiceError {
        status: 422,
        message: err.to_string()
      })
    }
  }

  HttpResponse::Ok().finish()
}

pub fn init_routes(config: &mut web::ServiceConfig) {
  config
    .service(get_guilds)
    .service(web::scope("guilds")
      .service(get_text_channels)
      .service(get_voice_channels)
      .service(send_message)
      .service(play)
      .service(stop)
      .service(resume)
      .service(pause)
      .service(set_volume)
      .service(get_volume)
      .service(skip)
  );
}