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

use crate::discord::helper::send_webhook_msg_to_player_channels;
use crate::game::global_data::GlobalData;
use crate::game::MessageSource;

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 mut 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)
        {
            let guild = msg.guild(&ctx.cache).await.unwrap();
            let user_msg = msg.content.clone();

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

            let msg_source = MessageSource::Player(Box::new(player_data.clone()));

            send_webhook_msg_to_player_channels(
                &ctx,
                &guild,
                &mut global_data,
                msg_source,
                &user_msg,
                Some(attachments),
            )
            .await
            .expect("Unable to send message to players");
        }
    }

    async fn ready(&self, ctx: Context, ready: Ready) {
        let mut data = ctx.data.write().await;

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

        let mut global_data = global_data.lock().await;

        let host_webhook = ctx
            .http
            .get_webhook_from_url(&global_data.cfg.host_webhook)
            .await
            .expect("Unable to open host webhook");

        global_data.host_webhook = Some(host_webhook);

        println!("{} is connected!", ready.user.name);
    }
}