path: root/src/commands/playback.rs

use either::{
    Left,
    Right,
};
use log::{
    debug,
    error,
    info,
    warn,
};
use serenity::{
    framework::standard::{
        macros::{
            command,
            group,
        },
        Args,
        CommandError,
        CommandResult,
    },
    futures::TryFutureExt,
    model::channel::Message,
    prelude::*,
};
use tap::{
    Conv,
    Pipe,
};

use crate::{
    audio::{
        parse_times,
        PlayArgs,
        PlayQueue,
        VoiceManager,
    },
    commands::sound_levels::*,
    util,
    CONFIG,
};

#[group]
#[commands(skip, pause, resume, list, die, mute, unmute, play, volume)]
#[only_in(guild)]
struct Playback;

pub async fn _play(ctx: &Context, msg: &Message, url: &str) -> CommandResult {
    use url::{
        Host,
        Url,
    };

    debug!("playing '{}'", url);
    if !url.starts_with("http") {
        warn!("got bad url argument to play: {}", url);
        util::send(ctx, msg.channel_id, "bAD LiNk", msg.tts).await?;
        return Ok(());
    }

    let url = match Url::parse(url) {
        Err(e) => {
            error!("bad url: {}", e);
            util::send(ctx, msg.channel_id, "INVALID URL", msg.tts).await?;
            return Ok(());
        },
        Ok(u) => u,
    };

    let host = url.host().and_then(|u| match u {
        Host::Domain(h) => Some(h.to_owned()),
        _ => None,
    });

    if host.map(|h| h.to_lowercase().contains("imgur")).unwrap_or(false) {
        info!("detected imgur link");

        if msg.author.id.get() == 106160362109272064 {
            util::send(ctx, msg.channel_id, "fuck you conway", true).await?;
        } else {
            util::send(ctx, msg.channel_id, "IMGUR IS BAD, YOU TRASH CAN MAN", msg.tts).await?;
        }

        return Ok(());
    }

    let (start, end) = parse_times(&msg.content);

    let queue_lock = ctx.data.write().await.get::<PlayQueue>().cloned().unwrap();
    let mut play_queue = queue_lock.write().unwrap();

    play_queue.general_queue.push_back(PlayArgs {
        initiator: msg.author.name.clone(),
        data: Left(url.conv::<String>()),
        sender_channel: msg.channel_id,
        start,
        end,
    });

    Ok(())
}

#[command]
pub async fn play(ctx: &Context, msg: &Message, mut args: Args) -> CommandResult {
    if args.len() == 0 {
        return _resume(ctx, msg).await;
    }

    let url = match args.single::<String>() {
        Ok(url) => url,
        Err(e) => {
            error!("unable to parse url from args: {}", e);
            return util::send(ctx, msg.channel_id, "BAD LINK", msg.tts)
                .await
                .map_err(CommandError::from);
        },
    };

    _play(ctx, msg, &url)
}

#[command]
pub async fn pause(ctx: &Context, msg: &Message, _: Args) -> CommandResult {
    let queue_lock = ctx.data.write().await.get::<PlayQueue>().cloned().unwrap();

    let done = || util::send(ctx, msg.channel_id, "r u srs", msg.tts).map_err(CommandError::from);
    let playing = {
        let play_queue = queue_lock.read().unwrap();

        let current_item = match play_queue.playing {
            Some(ref x) => x,
            None => return done().await,
        };

        let audio = current_item.audio.lock();
        audio.playing
    };

    if !playing {
        return done().await;
    }

    {
        let queue = queue_lock.write().unwrap();
        let ref audio = queue.playing.clone().unwrap().audio;
        audio.lock().pause();

        info!("paused playback");
    }

    Ok(())
}

#[command]
#[aliases("continue")]
pub async fn resume(ctx: &Context, msg: &Message, _: Args) -> CommandResult {
    _resume(ctx, msg).await
}

async fn _resume(ctx: &Context, msg: &Message) -> CommandResult {
    let queue_lock = ctx.data.write().await.get::<PlayQueue>().cloned().unwrap();

    let done = || util::send(ctx, msg.channel_id, "r u srs", msg.tts).map_err(CommandError::from);
    let playing = {
        let play_queue = queue_lock.read().unwrap();

        let current_item = match play_queue.playing {
            Some(ref x) => x,
            None => {
                done().await?;
                return Ok(());
            },
        };

        let audio = current_item.audio.lock();
        audio.playing
    };

    if playing {
        done().await?;
        debug!("attempted to resume playback while sound was already playing");
        return Ok(());
    }

    {
        let queue = queue_lock.write().unwrap();
        let ref audio = queue.playing.clone().unwrap().audio;
        audio.lock().play();
        info!("playback resumed");
    }

    Ok(())
}

#[command]
#[aliases("next")]
pub async fn skip(ctx: &Context, _msg: &Message, _args: Args) -> CommandResult {
    let data = ctx.data.write().await;

    let mgr_lock = data.get::<VoiceManager>().cloned().unwrap();
    let mut manager = mgr_lock.lock();

    let queue_lock = data.get::<PlayQueue>().cloned().unwrap();

    if let Some(handler) = manager.get_mut(CONFIG.discord.guild()) {
        handler.stop();
        let mut play_queue = queue_lock.write().unwrap();
        play_queue.playing = None;
        info!("skipped currently-playing audio");
    } else {
        debug!("got skip with no handler attached");
    }

    Ok(())
}

#[command]
#[aliases("sudoku", "fuckoff", "stop")]
pub async fn die(ctx: &Context, msg: &Message, _: Args) -> CommandResult {
    let data = ctx.data.write().await;

    let mgr_lock = data.get::<VoiceManager>().cloned().unwrap();
    let mut manager = mgr_lock.lock();

    let queue_lock = data.get::<PlayQueue>().cloned().unwrap();

    {
        let mut play_queue = queue_lock.write().unwrap();

        play_queue.playing = None;
        play_queue.general_queue.clear();
        play_queue.meme_queue.clear();
    }

    if let Some(handler) = manager.get_mut(CONFIG.discord.guild()) {
        info!("killing playback");
        handler.stop();
        handler.leave();
    } else {
        util::send(ctx, msg.channel_id, "YOU die", msg.tts).await?;
        debug!("got die with no handler attached");
    }

    Ok(())
}

#[command]
#[aliases("queue")]
pub async fn list(ctx: &Context, msg: &Message, _: Args) -> CommandResult {
    let queue_lock = ctx.data.write().await.get::<PlayQueue>().cloned().unwrap();
    let play_queue = queue_lock.read().unwrap();

    let channel = msg.channel(&ctx).await.unwrap().guild().unwrap();

    info!("listing queue");
    match play_queue.playing {
        Some(ref info) => {
            let audio = info.audio.lock();
            let status = if audio.playing {
                "playing"
            } else {
                "paused:"
            };

            let playing_info = match info.init_args.data {
                Left(ref url) => format!(" `{}`", url),
                Right(_) => "memeing".to_owned(),
            };

            util::send(
                ctx,
                msg.channel_id,
                &format!("Currently {} {} ({})", status, playing_info, info.init_args.initiator),
                msg.tts,
            )
            .await?;
        },
        None => {
            debug!("`list` called with no items in queue");
            util::send(ctx, msg.channel_id, "Nothing is playing you meme", msg.tts).await?;
            return Ok(());
        },
    }

    play_queue
        .meme_queue
        .iter()
        .chain(play_queue.general_queue.iter())
        .pipe(serenity::futures::stream::iter)
        .for_each(|info| async move {
            let playing_info = match info.data {
                Left(ref url) => format!("`{}`", url),
                Right(_) => "meme".to_owned(),
            };

            let _ = channel.say(&ctx, &format!("{} ({})", playing_info, info.initiator)).await;
        })
        .await;

    Ok(())
}