use serenity::async_trait;
use serenity::client::{Context, EventHandler};
use serenity::model::channel::Message;
use serenity::model::gateway::Ready;
use serenity::model::prelude::AttachmentType;
use serenity::utils::parse_emoji;

use crate::game::global_data::GlobalData;
use crate::game::message_router::{dispatch_message, MessageDest};
use crate::game::message_router::{Median, MessageSource, WoxlfMessage};

pub struct Handler {}

#[async_trait]
impl EventHandler for Handler {
    async fn message(&self, ctx: Context, msg: Message) {
        if msg.author.bot {
            return;
        }

        if msg.content.starts_with('$') {
            return;
        }

        let data = ctx.data.read().await;

        let global_data = data.get::<GlobalData>().unwrap();

        let global_data = global_data.lock().await;

        if global_data.game_state.is_none() {
            // no game in progress
            return;
        }

        if let Some(player_data) = global_data
            .game_state()
            .unwrap()
            .get_player_from_channel(msg.channel_id.0)
        {
            // Don't process message if the player is dead
            if !player_data.alive {
                return;
            }

            let user_msg = msg.content.clone();

            let re = regex::Regex::new(r"<a?:.+:\d+>").unwrap();

            for emoji_cap in re.captures_iter(&user_msg) {
                if let Some(emoji) = parse_emoji(&emoji_cap[0]) {
                    if !msg
                        .guild(&ctx.cache)
                        .unwrap()
                        .emojis
                        .contains_key(&emoji.id)
                    {
                        msg.reply(&ctx.http, "Your messages contains custom emojis from outside this guild and has been blocked.").await.unwrap();
                        return;
                    }
                }
            }

            let attachments: Vec<AttachmentType> = msg
                .attachments
                .iter()
                .map(|a| AttachmentType::Image((a.url).parse().unwrap()))
                .collect();

            let woxlf_msg = WoxlfMessage::default()
                .source(MessageSource::Player(Box::new(player_data.clone())))
                .dest(MessageDest::Broadcast)
                .median(Median::Webhook)
                .content(&user_msg)
                .attachments(attachments)
                .clone();

            dispatch_message(&ctx, &global_data, woxlf_msg)
                .await
                .expect("Unable to send message to players");
        }
    }

    async fn ready(&self, _ctx: Context, ready: Ready) {
        println!("{} is connected!", ready.user.name);
    }
}