HypeBot/src/discord/mod.rs

use std::collections::{HashMap, HashSet};
use std::sync::Arc;

use chrono::{DateTime, NaiveDateTime, Utc};
use serenity::async_trait;
use serenity::framework::standard::macros::help;
use serenity::framework::standard::macros::hook;
use serenity::framework::standard::{
    help_commands, Args, CommandError, CommandGroup, CommandResult, HelpOptions,
};
use serenity::model::gateway::Ready;
use serenity::model::id::UserId;
use serenity::model::prelude::{ChannelId, Message, Reaction, User};
use serenity::prelude::{Context, EventHandler};
use serenity::prelude::{TypeMap, TypeMapKey};
use serenity::utils::Colour;
use serenity::Result;
use strfmt::strfmt;
use tokio::sync::RwLockReadGuard;

use crate::database::models::{Event, NewEvent};
use crate::database::{get_all_events, get_event_by_id, get_event_by_msg_id, remove_event};
use crate::hypebot_config::HypeBotConfig;
use crate::reminder::Reminders;
use crate::{INTERESTED_EMOJI, UNINTERESTED_EMOJI};

pub mod events;

/// Struct for storing drafted events
#[derive(Debug, Clone, Default)]
pub struct DraftEvent {
    pub event: NewEvent,
    pub creator_id: u64,
}

impl TypeMapKey for DraftEvent {
    type Value = Arc<DraftEvent>;
}

/// Send a message to a reaction user
pub async fn send_message_to_reaction_users(ctx: &Context, reaction: &Reaction, msg_text: &str) {
    if let Ok(config) = get_config(&ctx.data.read().await).await {
        let db_link = config.db_url.clone();
        let message_id = reaction.message_id.0.to_string();

        let event = match get_event_by_msg_id(db_link, message_id) {
            Ok(event) => event,
            Err(e) => {
                if !matches!(e, diesel::result::Error::NotFound) {
                    error!("Error getting event from reaction {}", e);
                }
                return;
            }
        };

        let event_utc_time = DateTime::<Utc>::from_utc(event.event_time, Utc);
        let current_utc_time = chrono::offset::Utc::now();

        let msg;

        if event_utc_time > current_utc_time {
            // Format message
            let mut fmt = HashMap::new();
            fmt.insert("event".to_string(), event.event_name);
            msg = strfmt(msg_text, &fmt).unwrap();
        } else {
            msg = format!("**{}** has already started!", &event.event_name)
        }

        if let Ok(user) = reaction.user(&ctx).await {
            send_dm_message(&ctx, user, &msg).await;
        }
    }
}

/// Send a DM message to a user
pub async fn send_dm_message(ctx: &Context, user: User, message: &str) {
    if let Ok(dm_channel) = user.create_dm_channel(ctx).await {
        dm_channel
            .send_message(ctx, |m| m.content(message))
            .await
            .ok();
    }
}

/// Create a countdown link for the event
pub fn get_countdown_link(event_name: &str, utc: &DateTime<Utc>) -> String {
    let msg = event_name.replace(" ", "+");
    let time = utc.format("%G%m%dT%H%M").to_string();

    format!(
        "https://www.timeanddate.com/countdown/generic?iso={}&p0=&msg={}&font=sanserif&csz=1",
        time, msg
    )
}

/// Sends the event message to the event channel
pub async fn send_event_msg(
    ctx: &Context,
    config: &HypeBotConfig,
    channel_id: u64,
    event: &NewEvent,
    react: bool,
) -> Result<Message> {
    let channel = ctx.http.get_channel(channel_id).await?;

    let utc_time = DateTime::<Utc>::from_utc(event.event_time, Utc);

    let native_time = utc_time.with_timezone(&config.event_timezone);

    let ping_roles = config
        .ping_roles
        .clone()
        .into_iter()
        .map(|role| format!("<@&{}>", role))
        .collect::<Vec<String>>()
        .join(" ");

    // Send message
    let msg = channel.id().send_message(&ctx, |m| {
        m.embed(|e| {
            e.title(event.event_name.clone())
                .color(Colour::PURPLE)
                .description(format!(
                    "**{}**\n{}\n\n[Click Here For A Countdown]({})\n\nReact with {} below to receive event reminders!",
                    native_time.format("%A, %B %d @ %I:%M %P %t %Z"),
                    event.event_desc,
                    get_countdown_link(&event.event_name, &utc_time),
                    INTERESTED_EMOJI
                ))
                .thumbnail(event.thumbnail_link.clone())
                .footer(|f| f.text("Local Event Time"))
                .timestamp(utc_time.to_rfc3339())
                .field("Location", &event.event_loc, true)
                .field("Organizer", &event.organizer, true)
        }).content(ping_roles)
    }).await?;

    if react {
        // Add reacts
        msg.react(ctx, INTERESTED_EMOJI).await?;
        msg.react(ctx, UNINTERESTED_EMOJI).await?;
    }

    Ok(msg)
}

/// Updates the draft event stored in the context data
#[allow(clippy::too_many_arguments)]
pub async fn update_draft_event(
    ctx: &Context,
    event_name: String,
    event_desc: String,
    organizer: String,
    location: String,
    thumbnail: String,
    event_time: NaiveDateTime,
    creator_id: u64,
) -> CommandResult {
    let mut data = ctx.data.write().await;
    let draft_event = data
        .get_mut::<DraftEvent>()
        .ok_or_else(|| CommandError::from("Unable get draft event!".to_string()))?;

    let new_draft_event = DraftEvent {
        event: NewEvent {
            event_name,
            event_desc,
            event_loc: location,
            organizer,
            event_time,
            message_id: "".to_string(),
            thumbnail_link: thumbnail,
            reminder_sent: 0,
        },
        creator_id,
    };

    *draft_event = Arc::new(new_draft_event);

    Ok(())
}

/// Sends the draft event stored in the context data
pub async fn send_draft_event(ctx: &Context, channel: ChannelId) -> CommandResult {
    let data = ctx.data.read().await;
    let config = get_config(&data).await?;
    let draft_event = get_draft_event(&data).await?;

    channel
        .send_message(&ctx, |m| {
            m.content("Draft message, use the `confirm` command to post it.".to_string())
        })
        .await?;
    send_event_msg(ctx, &config, channel.0, &draft_event.event, false).await?;
    Ok(())
}

/// Gets the config from context data
pub async fn get_config(
    data: &RwLockReadGuard<'_, TypeMap>,
) -> std::result::Result<Arc<HypeBotConfig>, CommandError> {
    let config = data
        .get::<HypeBotConfig>()
        .ok_or_else(|| CommandError::from("Unable to get config".to_string()))?;

    Ok(config.clone())
}

/// Gets the draft event from context data
pub async fn get_draft_event(
    data: &RwLockReadGuard<'_, TypeMap>,
) -> std::result::Result<Arc<DraftEvent>, CommandError> {
    let draft_event = data
        .get::<DraftEvent>()
        .ok_or_else(|| CommandError::from("Unable to get queued event".to_string()))?;

    Ok(draft_event.clone())
}

/// Logs command errors to the logger
#[hook]
pub async fn log_error(
    _ctx: &Context,
    _msg: &Message,
    command_name: &str,
    result: std::result::Result<(), CommandError>,
) {
    match result {
        Ok(()) => (),
        Err(why) => error!("Command '{}' returned error {:?}", command_name, why),
    };
}

/// Checks if the user has permission to use this bot
#[hook]
pub async fn permission_check(ctx: &Context, msg: &Message, _command_name: &str) -> bool {
    if let Some(guild_id) = msg.guild_id {
        if let Ok(config) = get_config(&ctx.data.read().await).await {
            if let Ok(roles) = ctx.http.get_guild_roles(guild_id.0).await {
                for role in roles {
                    if config.event_roles.contains(&role.id.0) {
                        return match msg.author.has_role(&ctx, guild_id, role).await {
                            Ok(has_role) => has_role,
                            Err(_) => false,
                        };
                    }
                }
            }
        }
    }

    false
}

/// Schedule event reminders
pub async fn schedule_event(ctx: &Context, event: &Event) {
    let config = get_config(&ctx.data.read().await)
        .await
        .expect("Unable to get config");

    let mut data = ctx.data.write().await;

    let reminders = data.get_mut::<Reminders>().unwrap();

    reminders.add_reminders(event, &*config);
}

/// Send reminders
pub async fn send_reminders_task(ctx: &Context) {
    let duration = tokio::time::Duration::from_secs(1);
    loop {
        tokio::time::sleep(duration).await;
        let config = get_config(&ctx.data.read().await)
            .await
            .expect("Unable to get config");
        let event_channel_id = config.event_channel;

        let reminder_msg: Vec<&String> = match &config.reminders {
            None => return,
            Some(reminder_msg) => reminder_msg.iter().map(|r| &r.msg).collect(),
        };

        let mut data = ctx.data.write().await;
        let reminders = data
            .get_mut::<Reminders>()
            .unwrap();

        let current_reminders = reminders.get_reminders();

        for reminder in current_reminders {
            if let Ok(event) = get_event_by_id(config.db_url.clone(), reminder.event_id) {
                let message_id = event.message_id.parse::<u64>().unwrap_or_default();
                // Get message id
                if let Ok(message) = ctx.http.get_message(event_channel_id, message_id).await {
                    if let Ok(reaction_users) = message
                        .reaction_users(ctx, INTERESTED_EMOJI, None, None)
                        .await
                    {
                        // Build reminder message
                        let msg: String = reminder_msg[reminder.reminder_id]
                            .replace("{EVENT_NAME}", event.event_name.as_str());

                        // Send reminder to each reacted user
                        for user in reaction_users {
                            send_dm_message(ctx, user, &msg).await;
                        }
                    }
                }
            }
        }
    }
}

/// Delete event
pub async fn delete_event(ctx: &Context, event: &Event) -> CommandResult {
    let config = get_config(&ctx.data.read().await)
        .await
        .expect("Unable to get config");

    let message_id = event.message_id.parse::<u64>()?;
    let message = ctx
        .http
        .get_message(config.event_channel, message_id)
        .await?;
    let cancel_msg = format!("**{}** has been canceled!", event.event_name.clone());

    // Only send a cancel message if the even has not already happened
    if event.event_time > Utc::now().naive_utc() {
        if let Ok(reaction_users) = message
            .reaction_users(&ctx.http, INTERESTED_EMOJI, None, None)
            .await
        {
            for user in reaction_users {
                send_dm_message(ctx, user, &cancel_msg).await;
            }
        }
    }

    remove_event(config.db_url.clone(), event.id)?;

    message.delete(ctx).await?;

    if let Some(reminders) = ctx.data.write().await.get_mut::<Reminders>() {
        reminders.remove_reminders(&event);
    }

    Ok(())
}

#[help]
#[command_not_found_text = "Could not find: `{}`."]
#[strikethrough_commands_tip_in_guild("")]
async fn bot_help(
    context: &Context,
    msg: &Message,
    args: Args,
    help_options: &'static HelpOptions,
    groups: &[&'static CommandGroup],
    owners: HashSet<UserId>,
) -> CommandResult {
    help_commands::with_embeds(context, msg, args, help_options, groups, owners).await;
    Ok(())
}

/// Handler for Discord events
pub struct Handler;

#[async_trait]
impl EventHandler for Handler {
    /// On reaction add
    async fn reaction_add(&self, ctx: Context, reaction: Reaction) {
        let config = get_config(&ctx.data.read().await)
            .await
            .expect("Unable to get config");
        if reaction.channel_id.0 == config.event_channel
            && reaction.emoji.as_data().chars().next().unwrap() == INTERESTED_EMOJI
        {
            send_message_to_reaction_users(
                &ctx,
                &reaction,
                "Hello, you are now receiving reminders for **{event}**",
            )
            .await;
        }
    }

    /// On reaction remove
    async fn reaction_remove(&self, ctx: Context, reaction: Reaction) {
        let config = get_config(&ctx.data.read().await)
            .await
            .expect("Unable to get config");

        if reaction.channel_id.0 == config.event_channel
            && reaction.emoji.as_data().chars().next().unwrap() == INTERESTED_EMOJI
        {
            send_message_to_reaction_users(
                &ctx,
                &reaction,
                "Hello, you are no longer receiving reminders for **{event}**",
            )
            .await;
        }
    }

    /// On bot ready
    async fn ready(&self, ctx: Context, ready: Ready) {
        info!("Connected to Discord as {}", ready.user.name);

        // Schedule current events
        let config = get_config(&ctx.data.read().await)
            .await
            .expect("Unable to get config");
        for event in get_all_events(config.db_url.clone()).unwrap() {
            if event.reminder_sent == 0 {
                schedule_event(&ctx, &event).await;
            }
        }

        tokio::spawn(async move {
            send_reminders_task(&ctx).await;
        });
    }
}