use std::sync::Arc;

use async_trait::async_trait;
use twilight_model::gateway::payload::incoming::MessageCreate;

use crate::framework::{
    commands::{context::CommandContext, get_command_parts},
    events::traits::{EventResult, OnMessageHandler},
    runtime::Runtime,
};

#[derive(Debug)]
pub struct CommandRunner;

#[async_trait]
impl<T: Send + Sync + 'static> OnMessageHandler<T> for CommandRunner {
    async fn on_message(&self, event: &MessageCreate, rt: Arc<Runtime<T>>) -> EventResult {
        if event.author.bot || event.author.system.unwrap_or(false) {
            return Ok(());
        }

        let prefixes = rt
            .get_prefixes(event.guild_id.map(|i| i.get()), Some(event.author.id.get()))
            .await;

        for prefix in &prefixes {
            if let Some(parts) = get_command_parts(prefix, &event.content) {
                let command = rt.commands.iter().find(|cmd| {
                    cmd.identifiers()
                        .contains(&parts.name.to_ascii_lowercase().as_str())
                });

                if let Some(command) = command {
                    let ctx = CommandContext::new(event, rt.clone(), &prefixes[0]);

                    for permission in command.permissions() {
                        if !permission
                            .check(&ctx)
                            .await
                            .inspect_err(|e| log::error!("Permission check failed: {e}"))?
                        {
                            return Ok(());
                        }
                    }

                    command.execute(ctx, parts.args).await?;

                    break;
                }
            }
        }

        Ok(())
    }
}