use serenity;
use serenity::voice::ffmpeg;

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

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

#[command]
fn skip(ctx: &mut Context, msg: &Message, _: 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(());
    }

    if let Some(mut manager_lock) = ctx.data.lock().get::<VoiceManager>().cloned() {
        let mut manager = manager_lock.lock();

        let guild_id = match guild_id(msg.channel_id) {
            Some(id) => id,
            None => {
                println!("error getting guild id");
                print_error!(msg.channel_id.say("error getting guild id"));

                return Ok(());
            }
        };

        if let Some(handler) = handler(guild_id, &mut manager) {
            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(());
                }
            };

            let mut playlist = media.playlist_mut();
            let mut song = media.song_mut();

            // if current song is the last song in this playlist, just return
            if playlist.is_empty() {
                print_error!(msg
                    .channel_id
                    .say("playlist is empty, no next song available"));

                return Ok(());
            } else {
                // remove the current song from the playlist
                let first = playlist.remove(0);

                // stop the current song from playing
                handler.stop();

                // load next song into memory
                let source = match ffmpeg(first.name.clone()) {
                    Ok(mpeg) => mpeg,
                    Err(_) => {
                        playlist.clear();
                        *song = None;

                        return Ok(());
                    }
                };

                // start the next song if possible
                /*
                match self.media.next_callback.borrow().as_ref() {
                    Some(callback) => {
                        *song = Some(handler.play_returning_and_callback(source, callback.clone()));
                        let song_name = self.media.name_mut()?;
                        *song_name.borrow_mut() = first.name.clone();

                        print_error!(msg
                            .channel_id
                            .say(format!("Skipped current song, now playing: {}", first.name)));
                    }
                    None => println!("error getting callback from media"),
                }
                */
                *song = Some(handler.play_returning(source));
                *media.song_name_mut() = first.name.clone();

                print_error!(msg
                    .channel_id
                    .say(format!("Skipped current song, now playing: {}", first.name)));
            }
        }
    }

    Ok(())
}