RMusicBot/src/player/commands/play.rs

use parking_lot;

use std::cell::RefCell;
use std::ops::{Deref, DerefMut};
use std::sync::{Arc, MutexGuard};

use rand::{seq::SliceRandom, thread_rng};

use super::super::prelude::*;

use rusqlite::params;

use serenity::prelude::*;
use serenity::voice::LockedAudio;
use serenity::{
    framework::standard::{macros::command, Args, CommandResult},
    model::channel::Message,
};

#[command]
fn play(ctx: &mut Context, msg: &Message, args: Args) -> CommandResult {
    if !channel_contains_author(ctx, msg) {
        println!(
            "user {} is not in the same voice channel as the bot",
            msg.author.name
        );
        return Ok(());
    }

    let data = ctx.data.read();
    let mut media = match data.get_mut::<MediaData>() {
        Ok(media) => media,
        Err(_) => {
            msg.channel_id.say("could not find media data");
            return Ok(());
        }
    };

    if args.len() == 0 {
        if !Self::check_for_continue(self.media.song_mut()?) {
            print_error!(msg.channel_id.say("Must provide a URL to a video or audio"));
        }
    } else if args.len() == 1 {
        let arg = match args.single::<String>() {
            Ok(arg) => arg,
            // can't happen, since we tested for length == 1
            Err(_) => return Ok(()),
        };

        if arg == "--local" {
            self.handle_local_request(ctx, msg)?;
        } else if arg.starts_with("http") {
            self.handle_http_request(ctx, msg, &arg)?;
        } else {
            self.handle_song_request(ctx, msg, &arg)?;
        }
    } else {
        print_error!(msg.channel_id.say("Unsupported argument list"));
    }

    Ok(())
}

fn check_for_continue(song_lock: MutexGuard<RefCell<Option<LockedAudio>>>) -> bool {
    match song_lock.borrow_mut().deref_mut() {
        Some(song) => {
            let song_clone = song.clone();
            let mut audio_lock = song_clone.lock();

            audio_lock.play();
            true
        }
        None => false,
    }
}

fn check_join_channel(
    manager_lock: &Arc<parking_lot::Mutex<serenity::client::bridge::voice::ClientVoiceManager>>,
    msg: &serenity::model::channel::Message,
) {
    let guild = match msg.guild() {
        Some(guild) => guild,
        None => {
            display_error!(msg.channel_id.say("Groups and DMs not supported"));

            return;
        }
    };

    let guild_id = guild.read().id;

    let channel_id = guild
        .read()
        .voice_states
        .get(&msg.author.id)
        .and_then(|voice_state| voice_state.channel_id);

    let connect_to = match channel_id {
        Some(channel) => channel,
        None => {
            display_error!(msg.reply("Not in a voice channel"));

            return;
        }
    };

    let mut manager = manager_lock.lock();

    manager.join(guild_id, connect_to);
}

fn append_songs(
    media: &mut MediaData,
    ctx: &mut serenity::client::Context,
    msg: &serenity::model::channel::Message,
    mut source: Vec<Song>,
) -> Result<(), String> {
    {
        let playlist_mutex = self.media.playlist_mut()?;
        playlist_mutex.borrow_mut().append(&mut source);
    }

    if let Some(manager_lock) = ctx.data.lock().get::<VoiceManager>().cloned() {
        Self::check_join_channel(&manager_lock, msg);

        let check_finished = {
            let media_clone = self.media.clone();
            let channel_id = msg.channel_id;
            let manager_lock_clone = manager_lock.clone();

            Arc::new(move || {
                let callback = match media_clone.next_callback.borrow().deref() {
                    Some(callback) => callback.clone(),
                    None => {
                        println!("next_callback not set!");
                        return;
                    }
                };

                MediaData::next_song(&media_clone, channel_id, &manager_lock_clone, callback);
            })
        };

        MediaData::start_playing(&self.media, check_finished, msg.channel_id, &manager_lock);
    }

    Ok(())
}

fn handle_http_request(
    media: &mut MediaData,
    ctx: &mut serenity::client::Context,
    msg: &serenity::model::channel::Message,
    url: &String,
) -> Result<(), String> {
    let sql = self.media.lock_db()?;

    let mut stmt = match sql.prepare("SELECT name FROM Vulva3 WHERE link = ?") {
        Ok(statement) => statement,
        Err(_) => return Err("failed preparing data base access".to_string()),
    };

    let rows = match stmt.query_map(&[url], |row| row.get(0) as rusqlite::Result<String>) {
        Ok(rows) => rows,
        Err(_) => return Err("failed querying rows".to_string()),
    };

    let mut names = Vec::new();
    for name_result in rows {
        let name = match name_result {
            Ok(name) => name,
            Err(_) => return Err("failed getting name from row".to_string()),
        };

        names.push(name);
    }

    if names.len() > 0 {
        print_error!(msg.channel_id.say("song already loaded!"));

        self.append_songs(
            ctx,
            msg,
            names.iter().map(|n| Song { name: n.clone() }).collect(),
        )?;

        return Ok(());
    }

    let source = match youtube_dl(&url) {
        Ok(source) => source,
        Err(why) => {
            println!("Err starting source: {:?}", why);

            print_error!(msg
                .channel_id
                .say(format!("Error using youtube-dl: {}", why)));

            return Ok(());
        }
    };

    let mut info = if source.len() == 1 {
        "Finished downloading song:".to_string()
    } else {
        "Finished downloading songs:".to_string()
    };

    for song in &source {
        info = format!("{}\n\t{}", info, song.name);

        if sql
            .execute(
                "INSERT INTO Vulva3 (name, link)
                    VALUES (?1, ?2)",
                params![song.name, url],
            )
            .is_err()
        {
            return Err("failed inserting songs into db".to_string());
        }
    }

    print_error!(msg.channel_id.say(info));

    self.append_songs(ctx, msg, source)?;

    Ok(())
}

fn handle_local_request(
    media: &mut MediaData,
    ctx: &mut serenity::client::Context,
    msg: &serenity::model::channel::Message,
) -> Result<(), String> {
    let sql = self.media.lock_db()?;

    let mut stmt = match sql.prepare("SELECT name FROM Vulva3") {
        Ok(statement) => statement,
        Err(_) => return Err("failed preparing data base access".to_string()),
    };

    let rows = match stmt.query_map(params![], |row| row.get(0) as rusqlite::Result<String>) {
        Ok(rows) => rows,
        Err(_) => return Err("failed querying rows".to_string()),
    };

    let mut songs = Vec::new();
    for name_result in rows {
        let name = match name_result {
            Ok(name) => name,
            Err(_) => return Err("failed getting name from row".to_string()),
        };

        songs.push(Song { name });
    }

    let mut rng = thread_rng();
    songs.shuffle(&mut rng);

    self.append_songs(ctx, msg, songs)?;

    Ok(())
}

fn handle_song_request(
    media: &mut MediaData,
    ctx: &mut serenity::client::Context,
    msg: &serenity::model::channel::Message,
    pattern: &str,
) -> Result<(), String> {
    let sql = self.media.lock_db()?;

    let mut stmt = match sql.prepare(&format!(
        "SELECT name FROM Vulva3 WHERE name LIKE '%{}%'",
        pattern
    )) {
        Ok(statement) => statement,
        Err(_) => return Err("failed preparing data base access".to_string()),
    };

    let rows = match stmt.query_map(params![], |row| row.get(0) as rusqlite::Result<String>) {
        Ok(rows) => rows,
        Err(_) => return Err("failed querying rows".to_string()),
    };

    let mut songs = Vec::new();
    for name_result in rows {
        let name = match name_result {
            Ok(name) => name,
            Err(_) => return Err("failed getting name from row".to_string()),
        };

        songs.push(Song { name });
    }

    if !songs.is_empty() {
        let mut rng = thread_rng();
        songs.shuffle(&mut rng);

        self.append_songs(ctx, msg, songs)?;
    } else {
        print_error!(msg
            .channel_id
            .say(format!("no song found with pattern {}", pattern)));
    }

    Ok(())
}