use lock_api::{MutexGuard, RawMutex};
use serenity;
use serenity::model::channel::Message;
use serenity::model::guild::Guild;
use serenity::model::id::GuildId;
use serenity::prelude::RwLock as SerRwLock;
use serenity::voice::Handler;

use std::sync::Arc;

// This imports `typemap`'s `Key` as `TypeMapKey`.
use serenity::prelude::*;

use super::prelude::*;

pub fn guild(ctx: &Context, msg: &Message) -> Result<Arc<SerRwLock<Guild>>, String> {
    match msg.guild(&ctx.cache) {
        Some(guild) => Ok(guild),
        None => {
            if msg
                .channel_id
                .say(&ctx.http, "Groups and DMs not supported")
                .is_err()
            {}

            Err("failed getting Guild".to_string())
        }
    }
}

pub fn guild_id(ctx: &Context, msg: &Message) -> Result<GuildId, String> {
    let guild = guild(ctx, msg)?;
    let guild_read = guild.read();

    Ok(guild_read.id)
}

pub fn handler<'a, T: RawMutex>(
    guild_id: GuildId,
    manager: &'a mut MutexGuard<'_, T, serenity::client::bridge::voice::ClientVoiceManager>,
) -> Option<&'a mut Handler> {
    manager.get_mut(guild_id)
}

pub fn channel_contains_author(
    ctx: &mut serenity::client::Context,
    msg: &serenity::model::channel::Message,
) -> bool {
    let (guild_id, voice_channel_id_bot) = {
        match ctx.data.read().get::<VoiceManager>().cloned() {
            Some(manager_lock) => {
                let mut manager = manager_lock.lock();
                let guild_id = match guild_id(ctx, msg) {
                    Ok(id) => id,
                    Err(_) => return true,
                };

                let handler = match handler(guild_id, &mut manager) {
                    Some(handler) => handler,
                    None => {
                        println!("error getting handler");
                        return true;
                    }
                };

                (
                    guild_id,
                    match handler.channel_id {
                        Some(id) => id,
                        None => {
                            println!("error getting channel_id for bot");
                            return true;
                        }
                    },
                )
            }
            None => return false,
        }
    };

    let author = &msg.author;

    let guild = match guild_id.to_guild_cached(&ctx) {
        Some(guild) => guild,
        None => {
            println!("error getting guild from cache");
            return true;
        }
    };

    let guild_lock = guild.read();

    let voice_state = match guild_lock.voice_states.get(&author.id) {
        Some(state) => state,
        None => {
            println!("error getting voice state from user {}", author.name);
            return false;
        }
    };

    if let Some(voice_channel_id_user) = voice_state.channel_id {
        if voice_channel_id_bot != voice_channel_id_user {
            return false;
        }
    }

    true
}