use std::{error::Error, sync::Arc};

use async_trait::async_trait;
use deadpool_redis::redis::AsyncTypedCommands;
use itertools::Itertools;
use time::{Duration, UtcDateTime};
use twilight_http::{api_error::ApiError, error::ErrorType};
use twilight_model::{
    gateway::payload::incoming::{MessageCreate, MessageDelete, MessageUpdate},
    id::Id,
};
use twilight_util::{
    builder::embed::{EmbedAuthorBuilder, EmbedBuilder, EmbedFooterBuilder, ImageSource},
    snowflake::Snowflake,
};

use crate::{
    constants::{COLOR_WHITE, COLOR_YELLOW},
    database::models::{Call, Channel, Message, Participant, User, UserIncident},
    discord::{images, sanitizing::SanitizeDiscordMarkdown},
    extras::Extras,
    framework::{
        commands::extras::ExtrasGetter,
        events::traits::{
            EventResult, OnMessageDeleteHandler, OnMessageEditHandler, OnMessageHandler,
        },
        interactions::components::ActionRow,
        runtime::Runtime,
    },
    groups::calls::{
        components::{CodeOfConductButton, NeedHelpButton},
        embeds,
        masks::{get_mask_avatar_url, get_mask_display_name},
        moderation::{Action, Rule, escape_message},
    },
    state::State,
    utils::{ellipse, i64_to_u64},
};

async fn penalize_user(
    user: User,
    message: Message,
    broken_rules: Vec<Arc<dyn Rule>>,
    rt: &Runtime<State, Extras>,
) -> Result<(), Box<dyn Error>> {
    let reason = format!(
        "You broke the following rules during a call:\n{}",
        broken_rules
            .iter()
            .map(|rule| format!("- {}", rule.name()))
            .join("\n")
    );

    let new_incident = user
        .incident(
            reason.clone(),
            Some(message.data.clone()),
            None,
            &rt.state.db,
        )
        .await?;

    let dm_channel = rt
        .http
        .create_private_channel(Id::new(user.id))
        .await?
        .model()
        .await?;

    let embed = if new_incident.is_first_incident {
        embeds::first_warning_embed(&rt.app, &message, broken_rules)
    } else if new_incident.counting_incidents == 0 {
        embeds::repeat_warning_embed(&rt.app, &message, broken_rules)
    } else if new_incident.counting_incidents == 1 {
        embeds::first_ban_embed(&rt.app, &message, broken_rules)
    } else {
        embeds::final_ban_embed(&rt.app, &message, broken_rules)
    };

    rt.http
        .create_message(dm_channel.id)
        .embeds(&[embed])
        .components(&[ActionRow::new(&[
            (None, Arc::new(CodeOfConductButton)),
            (None, Arc::new(NeedHelpButton)),
        ])
        .build()])
        .await?;

    Ok(())
}

#[derive(Debug)]
pub struct CallMessageHandler;

#[async_trait]
impl OnMessageHandler<State, Extras> for CallMessageHandler {
    async fn on_message(
        &self,
        event: &MessageCreate,
        rt: Arc<Runtime<State, Extras>>,
        _extras: Arc<dyn ExtrasGetter<State, Extras = Extras>>,
    ) -> EventResult {
        if event.author.bot || event.author.system.unwrap_or(false) {
            return Ok(());
        }

        if UtcDateTime::from_unix_timestamp(event.author.id.timestamp() / 1000).unwrap()
            > UtcDateTime::now() - Duration::days(30)
        {
            return Ok(());
        }

        if event.content.is_empty() {
            return Ok(());
        }

        let Some(guild_id) = event.guild_id else {
            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 mut user = User::create_or_update(
            event.author.clone(),
            &rt.state.db,
            &rt.state.color_queue_sender,
        )
        .await?;

        let user_incidents = UserIncident::get_for_user(event.author.id.get(), &rt.state.db)
            .await?
            .iter()
            .filter(|incident| incident.is_active())
            .count();

        if user_incidents > 0 {
            return Ok(());
        }

        if event.content.to_ascii_lowercase().starts_with("x ") {
            if !user.findings.contains("feature:hide-message") {
                user.findings.insert("feature:hide-message".into());
                user.insert(&rt.state.db).await?;

                rt
                    .http
                    .create_message(
                        event.channel_id
                    )
                    .content(
                        "✨ You found a hidden feature! Messages starting with `x` followed by a space will not be sent to the other party (nor moderated, i.e. you won't get banned for what you say in them)."
                    )
                    .reply(event.id)
                    .await?;
            }

            return Ok(());
        }

        let Some(mut 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.clone())
        else {
            // Handle DM calls in the future.
            return Ok(());
        };

        let (content, rules) = escape_message(event);

        let message: Message;

        let replying_to = if let Some(reference) = &event.reference {
            if let Some(replying_to_message_id) = reference.message_id {
                Message::get_by_call_and_message_id(
                    call.id,
                    replying_to_message_id.get(),
                    &rt.state.db,
                )
                .await?
            } else {
                None
            }
        } else {
            None
        };
        let replying_to_id = replying_to.as_ref().map(|i| i.message_id);

        let participant = Participant::get_or_create(
            user.id,
            event.channel_id.get(),
            call.id,
            event
                .member
                .clone()
                .and_then(|member| member.nick)
                .or(event.author.global_name.clone())
                .unwrap_or(event.author.name.clone()),
            images::get_avatar_url(
                event
                    .member
                    .clone()
                    .and_then(|inner| inner.avatar)
                    .or(event.author.avatar),
                event.author.id.get(),
                event.author.discriminator as u64,
                event
                    .member
                    .as_ref()
                    .and_then(|member| member.avatar)
                    .map(|_| guild_id.get()),
            ),
            user.is_masked,
            &rt.state.db,
        )
        .await?;

        if rules
            .iter()
            .any(|rule| rule.action() == &Action::BlockAndPenalty)
        {
            rt.http
                .create_message(event.channel_id)
                .content(
                    "🚩 Your message has been blocked because it broke Payphone's code of conduct. Check your DMs for more information.",
                )
                .await?;

            rt.http
                .create_message(Id::new(opposite_channel.id))
                .content(&format!(
                    "🚩 **{}** Sent a message that was blocked.\n-# If you see an inappropiate message, please report it using `Message > Apps > Report Message`.",
                    participant.display_name().sanitize(false)
                ))
                .await?;

            message = Message::build()
                .call_id(call.id)
                .message(event.0.clone())
                .participant(participant)
                .is_censored(!rules.is_empty())
                .replying_to_message_id(replying_to_id)
                .build()
                .expect(
                    "The message builder was missing either the call ID, the message, or the profile",
                );
        } else {
            let mut embeds = vec![];

            if let Some(replying_to) = replying_to {
                if let Some((propagation_channel_id, propagation_message_id)) = replying_to
                    .data
                    .propagation_channel_id
                    .zip(replying_to.data.propagation_message_id)
                {
                    let (display_name, avatar_url) =
                        if let Some(mask) = &replying_to.data.author_mask {
                            (
                                if i64_to_u64(propagation_channel_id) != event.channel_id.get() {
                                    get_mask_display_name(mask)
                                } else {
                                    format!(
                                        "{} ({})",
                                        get_mask_display_name(mask),
                                        replying_to.data.author_name
                                    )
                                },
                                get_mask_avatar_url(mask).expect("Failed to get mask avatar URL"),
                            )
                        } else {
                            (
                                replying_to.data.author_name.clone(),
                                replying_to.data.author_avatar_url.clone(),
                            )
                        };

                    let message_link = if i64_to_u64(propagation_channel_id) == channel.id {
                        format!(
                            "https://discord.com/channels/{}/{}/{}",
                            opposite_channel.server_id, opposite_channel.id, replying_to.message_id
                        )
                    } else {
                        format!(
                            "https://discord.com/channels/{}/{}/{}",
                            channel.server_id, propagation_channel_id, propagation_message_id
                        )
                    };

                    let replying_to_user =
                        User::get_by_id(replying_to.author_id, &rt.state.db).await?;

                    embeds.push(
                        EmbedBuilder::new()
                            .author(
                                EmbedAuthorBuilder::new(format!("Replying to {display_name}",))
                                    .icon_url(ImageSource::url(avatar_url).unwrap())
                                    .url(message_link),
                            )
                            .color(if replying_to.data.author_mask.is_some() {
                                COLOR_WHITE
                            } else {
                                replying_to_user
                                    .and_then(|i| i.color.map(|c| c as u32))
                                    .unwrap_or(COLOR_WHITE)
                            })
                            .description(ellipse(replying_to.data.content, 100))
                            .build(),
                    );
                }
            }

            if participant.is_masked {
                let last_message =
                    Message::get_last_by_author_id(call.id, event.author.id.get(), &rt.state.db)
                        .await?;

                if last_message
                    .map(|lm| lm.data.author_mask.is_none())
                    .unwrap_or(true)
                {
                    embeds.push(
                        EmbedBuilder::new()
                            .color(COLOR_YELLOW)
                            .description(format!(
                                "🎭 **{}** is wearing a mask! Their real identity is hidden.",
                                participant.display_name()
                            ))
                            .footer(EmbedFooterBuilder::new(format!(
                                "You can set your own mask using {}mask on.",
                                prefixes[0]
                            )))
                            .build(),
                    );
                }
            }

            let mut redis = rt.state.redis.get().await?;

            redis
                .zadd(
                    "active-calls",
                    format!("{}:{}", call.id, channel.id),
                    UtcDateTime::now().unix_timestamp(),
                )
                .await?;

            let message_sent = match rt
                .http
                .execute_webhook(Id::new(webhook_id), &webhook_token)
                .allowed_mentions(None)
                .username(&participant.display_name())
                .avatar_url(&participant.avatar_url())
                .content(&content.sanitize_mentions())
                .embeds(&embeds)
                .wait()
                .await
                .inspect_err(|e| {
                    log::error!(
                        "Failed to send message to webhook for call {} in channel {}: {e:?}",
                        call.id,
                        opposite_channel.id
                    );
                }) {
                Ok(message) => message,
                Err(e) => {
                    if let ErrorType::Response {
                        error: ApiError::General(error),
                        ..
                    } = e.kind()
                    {
                        if error.code == 10015 {
                            log::debug!("Webhook not found, updating...");
                            opposite_channel
                                .update_webhook(&rt.state.db, &rt.http)
                                .await?;
                        }
                    }
                    return Ok(());
                }
            }
            .model()
            .await?;

            message = Message::build()
                .call_id(call.id)
                .message(event.0.clone())
                .participant(participant)
                .is_censored(!rules.is_empty())
                .replying_to_message_id(replying_to_id)
                .propagation_message_id(message_sent.id.get())
                .propagation_channel_id(opposite_channel.id)
                .build()
                .expect(
                    "The message builder was missing either the call ID, the message, or the profile",
                );
        }

        message.insert(&rt.state.db).await?;

        if rules
            .iter()
            .any(|rule| rule.action() == &Action::BlockAndPenalty)
        {
            penalize_user(user, message, rules, &rt).await?;
        }

        Ok(())
    }
}

#[derive(Debug)]
pub struct CallMessageEditHandler;

#[async_trait]
impl OnMessageEditHandler<State, Extras> for CallMessageEditHandler {
    async fn on_message_edit(
        &self,
        event: &MessageUpdate,
        rt: Arc<Runtime<State, Extras>>,
    ) -> EventResult {
        if event.edited_timestamp.is_none() {
            return Ok(());
        }

        log::trace!(
            "Edited message was '{}' sent by {} (bot? {:?})",
            event.content,
            event.author.id.get(),
            event.author.bot
        );

        let Some(channel) = Channel::get_by_id(event.channel_id.get(), &rt.state.db).await? 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? {
                if !call.is_active() {
                    return Ok(());
                }

                call
            } else {
                return Ok(());
            }
        } else {
            return Ok(());
        };

        let Some(mut message) =
            Message::get_by_call_and_message_id(call.id, event.id.get(), &rt.state.db).await?
        else {
            return Ok(());
        };

        let opposite_channel_id = call.other_party_channel_id(event.channel_id.get());
        let Some(opposite_channel) = Channel::get_by_id(opposite_channel_id, &rt.state.db).await?
        else {
            return Ok(());
        };

        if let Some(propagation_message_id) = message.data.propagation_message_id {
            let (content, rules) = escape_message(event);

            if rules
                .iter()
                .any(|rule| rule.action() == &Action::BlockAndPenalty)
            {
                rt.http
                    .create_message(event.channel_id)
                    .content(
                        "🚩 Your message's edit has been blocked because it broke Payphone's code of conduct. Check your DMs for more information.",
                    )
                    .reply(event.id)
                    .await?;

                let user = User::create_or_update(
                    event.author.clone(),
                    &rt.state.db,
                    &rt.state.color_queue_sender,
                )
                .await?;

                penalize_user(user, message, rules, &rt).await?;

                return Ok(());
            }

            if let Some((webhook_id, webhook_token)) = opposite_channel
                .webhook_id
                .zip(opposite_channel.webhook_token)
            {
                rt.http
                    .update_webhook_message(
                        Id::new(webhook_id),
                        &webhook_token,
                        Id::new(i64_to_u64(propagation_message_id)),
                    )
                    .content(Some(&content))
                    .await?;

                message.data.content = content;
                message.data.is_edited = true;
                message.data.is_censored = !rules.is_empty();

                message.insert(&rt.state.db).await?;
            }
        }

        Ok(())
    }
}

#[derive(Debug)]
pub struct CallMessageDeleteHandler;

#[async_trait]
impl OnMessageDeleteHandler<State, Extras> for CallMessageDeleteHandler {
    async fn on_message_delete(
        &self,
        event: &MessageDelete,
        rt: Arc<Runtime<State, Extras>>,
    ) -> EventResult {
        let Some(channel) = Channel::get_by_id(event.channel_id.get(), &rt.state.db).await? 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? {
                if !call.is_active() {
                    return Ok(());
                }

                call
            } else {
                return Ok(());
            }
        } else {
            return Ok(());
        };

        let Some(mut message) =
            Message::get_by_call_and_message_id(call.id, event.id.get(), &rt.state.db).await?
        else {
            return Ok(());
        };

        let opposite_channel_id = call.other_party_channel_id(event.channel_id.get());
        let Some(opposite_channel) = Channel::get_by_id(opposite_channel_id, &rt.state.db).await?
        else {
            return Ok(());
        };

        if let Some(propagation_message_id) = message.data.propagation_message_id {
            if let Some((webhook_id, webhook_token)) = opposite_channel
                .webhook_id
                .zip(opposite_channel.webhook_token)
            {
                rt.http
                    .delete_webhook_message(
                        Id::new(webhook_id),
                        &webhook_token,
                        Id::new(i64_to_u64(propagation_message_id)),
                    )
                    .await?;

                message.data.is_deleted = true;

                message.insert(&rt.state.db).await?;
            }
        }

        Ok(())
    }
}