// use crate::core::model::ApiClient;
// use crate::core::consts::*;
use crate::core::model::*;
use serenity::framework::standard::{
    Args,
    Command,
    CommandError,
    CommandOptions
};
use serenity::model::channel::Message;
use serenity::prelude::Context;
use std::sync::Arc;
use songbird::SerenityInit;

pub struct Join;
impl Command for Join {
    fn options(&self) -> Arc<CommandOptions> {
        let default = CommandOptions::default();
        let options = CommandOptions {
            // desc: Some("I see your a individual of culture...".to_string()),
            // usage: Some("[tags]".to_string()),
            // example: Some("minecraft".to_string()),
            guild_only: true,
            owner_privileges: false,
            ..default
        };
        Arc::new(options)
    }

    fn execute(&self, ctx: &mut Context, message: &Message, _args: Args) -> Result<(), CommandError> {
        // let guild_id = message.guild().unwrap().read().id;
        let guild = message.guild().unwrap();
        let guild_id = guild.read().id;
        
        let channel_id = message.guild().unwrap().read()
            .voice_states.get(&message.author.id)
            .and_then(|voice_state| voice_state.channel_id);

        let connect_to = match channel_id {
            Some(channel) => channel,
            None => {
                message.channel_id.say("You aren't in a voice channel... Only the people within a given voice channel can make me join.")?;

                return Ok(())
            }
        };

        let manager = songbird::get(ctx).unwrap().clone();
        // let (_, handler) = manager.join_gateway(guild_id, connect_to);

        let manager_lock = ctx.data.lock().get::<VoiceManager>().cloned()
            .expect("Expected VoiceManager in TypeMap.");
        let mut manager = manager_lock.lock();
        let has_joined = manager.join(guild_id, connect_to).is_some();

        if has_joined {
            drop(manager);

            loop {
                let vgu_lock = ctx.data.lock().get::<VoiceGuildUpdate>().unwrap();
                let mut vgu = vgu_lock.write();
                if vgu.contains(&guild_id) {
                    vgu.remove(&guild_id);
                    break;
                }
            }

            let manager_lock = ctx.data.lock().get::<VoiceManager>().cloned()
                .expect("Expected VoiceManager in TypeMap.");
            let manager = manager_lock.lock();

            let mut data = ctx.data.lock();
            let lava_client_lock = data.get_mut::<Lavalink>()
                .expect("Expected LavalinkClient in TypeMap.");
            let handler = manager.get(guild_id).unwrap();
            lava_client_lock.lock().create_session(guild_id, &handler);

            message.channel_id.say(format!("Joined {:?}", connect_to.name()))?;
        } else {
            message.channel_id.say("Error joining channel...")?;
        }

        Ok(())
    }
}

pub struct Leave;
impl Command for Leave {
    fn options(&self) -> Arc<CommandOptions> {
        let default = CommandOptions::default();
        let options = CommandOptions {
            // desc: Some("I see your a individual of culture...".to_string()),
            // usage: Some("[tags]".to_string()),
            // example: Some("minecraft".to_string()),
            guild_only: true,
            owner_privileges: false,
            ..default
        };
        Arc::new(options)
    }

    fn execute(&self, ctx: &mut Context, message: &Message, _args: Args) -> Result<(), CommandError> {
        let guild = message.guild().unwrap();
        let guild_id = guild.read().id;

        let manager_lock = ctx.data.lock().get::<VoiceManager>().cloned()
            .expect("Expected VoiceManager in TypeMap.");
        let mut manager = manager_lock.lock();
        let has_handler = manager.get(guild_id).is_some();

        if has_handler {
            manager.remove(guild_id);

            let mut data = ctx.data.lock();
            let lava_client_lock = data.get_mut::<Lavalink>()
                .expect("Expected LavalinkClient in TypeMap.");
            lava_client_lock.lock().destroy(guild_id);

            message.channel_id.say(format!("Left voice channel"))?;
        } else {
            message.channel_id.say("Error joining channel...")?;
        }

        Ok(())
    }
}