use std::sync::Arc;

use async_trait::async_trait;
use twilight_model::{gateway::payload::incoming::MessageCreate, id::Id};

use crate::{
    database::models::{Call, Channel, Message},
    framework::{
        events::traits::{EventResult, OnMessageHandler},
        runtime::Runtime,
    },
    groups::calls::{get_display_profile, moderation::escape_message},
    state::State,
};

#[derive(Debug)]
pub struct MessageRedirector;

#[async_trait]
impl OnMessageHandler<State> for MessageRedirector {
    async fn on_message(&self, event: &MessageCreate, rt: Arc<Runtime<State>>) -> 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;

        if prefixes.iter().any(|prefix| {
            event
                .content
                .to_ascii_lowercase()
                .starts_with(&prefix.to_ascii_lowercase())
        }) {
            return Ok(());
        }

        let Some(channel) = Channel::get_by_id(event.channel_id.get(), &rt.state.db)
            .await
            .inspect_err(|e| {
                log::error!(
                    "Failed to get channel from DB when processing message create event! {e:?}"
                );
            })?
        else {
            return Ok(());
        };

        let call = if let Some(call_id) = channel.call_id {
            if let Some(call) = Call::get_by_id(call_id, &rt.state.db)
                .await
                .inspect_err(|e| {
                    log::error!(
                        "Failed to get call from DB when processing message create event! {e:?}"
                    );
                })?
            {
                if !call.is_active() {
                    return Ok(());
                }

                call
            } else {
                log::error!(
                    "Call ID {} in channel {} does not correspond to an active call.",
                    call_id,
                    channel.id
                );
                return Ok(());
            }
        } else {
            return Ok(());
        };

        let Some(opposite_channel) = Channel::get_by_id(
            call.other_party_channel_id(event.channel_id.get()),
            &rt.state.db,
        )
        .await
        .inspect_err(|e| {
            log::error!(
                "Failed to get opposite channel from DB when processing message create event! {e:?}"
            );
        })?
        else {
            return Ok(());
        };

        let Some((webhook_id, webhook_token)) = opposite_channel
            .webhook_id
            .zip(opposite_channel.webhook_token)
        else {
            // Handle DM calls in the future.
            return Ok(());
        };

        let profile = get_display_profile(event);

        Message::build()
            .call_id(call.id)
            .message(event.0.clone())
            .profile(profile.clone())
            .build()
            .expect(
                "The message builder was missing either the call ID, the message, or the profile",
            )
            .insert(&rt.state.db)
            .await?;

        rt.http
            .execute_webhook(Id::new(webhook_id), &webhook_token)
            .allowed_mentions(None)
            .username(&profile.name)
            .avatar_url(&profile.avatar_url)
            .content(&escape_message(event))
            .await
            .inspect_err(|e| {
                log::error!(
                    "Failed to send message to webhook for call {} in channel {}: {e:?}",
                    call.id,
                    opposite_channel.id
                );
            })?;

        Ok(())
    }
}