use regex_command_attr::command;

use serenity::{
    cache::Cache,
    client::Context,
    http::CacheHttp,
    model::{
        channel::GuildChannel,
        channel::Message,
        guild::Guild,
        id::{ChannelId, GuildId, UserId},
        misc::Mentionable,
        webhook::Webhook,
    },
    Result as SerenityResult,
};

use crate::{
    check_subscription_on_message, command_help,
    consts::{
        CHARACTERS, DAY, HOUR, MAX_TIME, MINUTE, MIN_INTERVAL, REGEX_CHANNEL, REGEX_CHANNEL_USER,
        REGEX_CONTENT_SUBSTITUTION, REGEX_NATURAL_COMMAND_1, REGEX_NATURAL_COMMAND_2,
        REGEX_REMIND_COMMAND, THEME_COLOR,
    },
    framework::SendIterator,
    get_ctx_data,
    models::{ChannelData, GuildData, Timer, UserData},
    time_parser::{natural_parser, TimeParser},
};

use chrono::{offset::TimeZone, NaiveDateTime};

use rand::{rngs::OsRng, seq::IteratorRandom};

use sqlx::MySqlPool;

use num_integer::Integer;

use std::{
    collections::HashSet,
    convert::TryInto,
    default::Default,
    fmt::Display,
    string::ToString,
    time::{SystemTime, UNIX_EPOCH},
};

use regex::Captures;

fn shorthand_displacement(seconds: u64) -> String {
    let (days, seconds) = seconds.div_rem(&DAY);
    let (hours, seconds) = seconds.div_rem(&HOUR);
    let (minutes, seconds) = seconds.div_rem(&MINUTE);

    let time_repr = format!("{:02}:{:02}:{:02}", hours, minutes, seconds);

    format!("{} days, {}", days, time_repr)
}

fn longhand_displacement(seconds: u64) -> String {
    let (days, seconds) = seconds.div_rem(&DAY);
    let (hours, seconds) = seconds.div_rem(&HOUR);
    let (minutes, seconds) = seconds.div_rem(&MINUTE);

    let mut sections = vec![];

    for (var, name) in [days, hours, minutes, seconds]
        .iter()
        .zip(["days", "hours", "minutes", "seconds"].iter())
    {
        if *var > 0 {
            sections.push(format!("{} {}", var, name));
        }
    }

    sections.join(", ")
}

async fn create_webhook(
    ctx: impl CacheHttp,
    channel: GuildChannel,
    name: impl Display,
) -> SerenityResult<Webhook> {
    channel
        .create_webhook_with_avatar(
            ctx.http(),
            name,
            (
                include_bytes!(concat!(
                    env!("CARGO_MANIFEST_DIR"),
                    "/assets/",
                    env!(
                        "WEBHOOK_AVATAR",
                        "WEBHOOK_AVATAR not provided for compilation"
                    )
                )) as &[u8],
                env!("WEBHOOK_AVATAR"),
            ),
        )
        .await
}

#[command]
#[supports_dm(false)]
#[permission_level(Restricted)]
async fn pause(ctx: &Context, msg: &Message, args: String) {
    let (pool, lm) = get_ctx_data(&ctx).await;

    let language = UserData::language_of(&msg.author, &pool).await;
    let timezone = UserData::timezone_of(&msg.author, &pool).await;
    let meridian = UserData::meridian_of(&msg.author, &pool).await;

    let mut channel = ChannelData::from_channel(msg.channel(&ctx).await.unwrap(), &pool)
        .await
        .unwrap();

    if args.is_empty() {
        channel.paused = !channel.paused;
        channel.paused_until = None;

        channel.commit_changes(&pool).await;

        if channel.paused {
            let _ = msg
                .channel_id
                .say(&ctx, lm.get(&language, "pause/paused_indefinite"))
                .await;
        } else {
            let _ = msg
                .channel_id
                .say(&ctx, lm.get(&language, "pause/unpaused"))
                .await;
        }
    } else {
        let parser = TimeParser::new(&args, timezone);
        let pause_until = parser.timestamp();

        match pause_until {
            Ok(timestamp) => {
                let dt = NaiveDateTime::from_timestamp(timestamp, 0);

                channel.paused = true;
                channel.paused_until = Some(dt);

                channel.commit_changes(&pool).await;

                let content = lm.get(&language, "pause/paused_until").replace(
                    "{}",
                    &timezone
                        .timestamp(timestamp, 0)
                        .format(meridian.fmt_str())
                        .to_string(),
                );

                let _ = msg.channel_id.say(&ctx, content).await;
            }

            Err(_) => {
                let _ = msg
                    .channel_id
                    .say(&ctx, lm.get(&language, "pause/invalid_time"))
                    .await;
            }
        }
    }
}

#[command]
#[permission_level(Restricted)]
async fn offset(ctx: &Context, msg: &Message, args: String) {
    let (pool, lm) = get_ctx_data(&ctx).await;

    let user_data = UserData::from_user(&msg.author, &ctx, &pool).await.unwrap();

    if args.is_empty() {
        let prefix = GuildData::prefix_from_id(msg.guild_id, &pool).await;

        command_help(ctx, msg, lm, &prefix, &user_data.language, "offset").await;
    } else {
        let parser = TimeParser::new(&args, user_data.timezone());

        if let Ok(displacement) = parser.displacement() {
            if let Some(guild) = msg.guild(&ctx).await {
                let guild_data = GuildData::from_guild(guild, &pool).await.unwrap();

                sqlx::query!(
                    "
UPDATE reminders
    INNER JOIN `channels`
        ON `channels`.id = reminders.channel_id
    SET
        reminders.`time` = reminders.`time` + ?
    WHERE channels.guild_id = ?
                    ",
                    displacement,
                    guild_data.id
                )
                .execute(&pool)
                .await
                .unwrap();
            } else {
                sqlx::query!(
                    "
UPDATE reminders SET `time` = `time` + ? WHERE reminders.channel_id = ?
                    ",
                    displacement,
                    user_data.dm_channel
                )
                .execute(&pool)
                .await
                .unwrap();
            }

            let response = lm.get(&user_data.language, "offset/success").replacen(
                "{}",
                &displacement.to_string(),
                1,
            );

            let _ = msg.channel_id.say(&ctx, response).await;
        } else {
            let _ = msg
                .channel_id
                .say(&ctx, lm.get(&user_data.language, "offset/invalid_time"))
                .await;
        }
    }
}

#[command]
#[permission_level(Restricted)]
async fn nudge(ctx: &Context, msg: &Message, args: String) {
    let (pool, lm) = get_ctx_data(&ctx).await;

    let language = UserData::language_of(&msg.author, &pool).await;
    let timezone = UserData::timezone_of(&msg.author, &pool).await;

    let mut channel = ChannelData::from_channel(msg.channel(&ctx).await.unwrap(), &pool)
        .await
        .unwrap();

    if args.is_empty() {
        let content = lm
            .get(&language, "nudge/no_argument")
            .replace("{nudge}", &format!("{}s", &channel.nudge.to_string()));

        let _ = msg.channel_id.say(&ctx, content).await;
    } else {
        let parser = TimeParser::new(&args, timezone);
        let nudge_time = parser.displacement();

        match nudge_time {
            Ok(displacement) => {
                if displacement < i16::MIN as i64 || displacement > i16::MAX as i64 {
                    let _ = msg
                        .channel_id
                        .say(&ctx, lm.get(&language, "nudge/invalid_time"))
                        .await;
                } else {
                    channel.nudge = displacement as i16;

                    channel.commit_changes(&pool).await;

                    let response = lm.get(&language, "nudge/success").replacen(
                        "{}",
                        &displacement.to_string(),
                        1,
                    );

                    let _ = msg.channel_id.say(&ctx, response).await;
                }
            }

            Err(_) => {
                let _ = msg
                    .channel_id
                    .say(&ctx, lm.get(&language, "nudge/invalid_time"))
                    .await;
            }
        }
    }
}

enum TimeDisplayType {
    Absolute,
    Relative,
}

struct LookFlags {
    pub limit: u16,
    pub show_disabled: bool,
    pub channel_id: Option<u64>,
    time_display: TimeDisplayType,
}

impl Default for LookFlags {
    fn default() -> Self {
        Self {
            limit: u16::MAX,
            show_disabled: true,
            channel_id: None,
            time_display: TimeDisplayType::Relative,
        }
    }
}

impl LookFlags {
    fn from_string(args: &str) -> Self {
        let mut new_flags: Self = Default::default();

        for arg in args.split(' ') {
            match arg {
                "enabled" => {
                    new_flags.show_disabled = false;
                }

                "time" => {
                    new_flags.time_display = TimeDisplayType::Absolute;
                }

                param => {
                    if let Ok(val) = param.parse::<u16>() {
                        new_flags.limit = val;
                    } else {
                        if let Some(channel) = REGEX_CHANNEL
                            .captures(&arg)
                            .map(|cap| cap.get(1))
                            .flatten()
                            .map(|c| c.as_str().parse::<u64>().unwrap())
                        {
                            new_flags.channel_id = Some(channel);
                        }
                    }
                }
            }
        }

        new_flags
    }
}

struct LookReminder {
    id: u32,
    time: u32,
    channel: u64,
    content: String,
    description: Option<String>,
}

impl LookReminder {
    fn display_content(&self) -> String {
        if self.content.len() > 0 {
            self.content.clone()
        } else {
            self.description.clone().unwrap_or(String::from(""))
        }
    }
}

#[command("look")]
#[permission_level(Managed)]
async fn look(ctx: &Context, msg: &Message, args: String) {
    let (pool, lm) = get_ctx_data(&ctx).await;

    let language = UserData::language_of(&msg.author, &pool).await;
    let timezone = UserData::timezone_of(&msg.author, &pool).await;
    let meridian = UserData::meridian_of(&msg.author, &pool).await;

    let flags = LookFlags::from_string(&args);

    let enabled = if flags.show_disabled { "0,1" } else { "1" };

    let reminders = if let Some(guild_id) = msg.guild_id.map(|f| f.as_u64().to_owned()) {
        let channel_id = flags
            .channel_id
            .unwrap_or_else(|| msg.channel_id.as_u64().to_owned());

        sqlx::query_as!(
            LookReminder,
            "
SELECT
    reminders.id, reminders.time, channels.channel, messages.content, embeds.description
FROM
    reminders
INNER JOIN
    channels
ON
    reminders.channel_id = channels.id
INNER JOIN
    messages
ON
    messages.id = reminders.message_id
LEFT JOIN
    embeds
ON
    embeds.id = messages.embed_id
WHERE
    channels.guild_id = (SELECT id FROM guilds WHERE guild = ?) AND
    channels.channel = ? AND
    FIND_IN_SET(reminders.enabled, ?)
ORDER BY
    reminders.time
LIMIT
    ?
            ",
            guild_id,
            channel_id,
            enabled,
            flags.limit
        )
        .fetch_all(&pool)
        .await
    } else {
        sqlx::query_as_unchecked!(
            LookReminder,
            "
SELECT
    reminders.id, reminders.time, channels.channel, messages.content, embeds.description
FROM
    reminders
LEFT OUTER JOIN
    channels
ON
    channels.id = reminders.channel_id
INNER JOIN
    messages
ON
    messages.id = reminders.message_id
LEFT JOIN
    embeds
ON
    embeds.id = messages.embed_id
WHERE
    channels.channel = ? AND
    FIND_IN_SET(reminders.enabled, ?)
ORDER BY
    reminders.time
LIMIT
    ?
            ",
            msg.channel_id.as_u64(),
            enabled,
            flags.limit
        )
        .fetch_all(&pool)
        .await
    }
    .unwrap();

    if reminders.is_empty() {
        let _ = msg
            .channel_id
            .say(&ctx, lm.get(&language, "look/no_reminders"))
            .await;
    } else {
        let inter = lm.get(&language, "look/inter");

        let display = reminders.iter().map(|reminder| {
            let time_display = match flags.time_display {
                TimeDisplayType::Absolute => timezone
                    .timestamp(reminder.time as i64, 0)
                    .format(meridian.fmt_str())
                    .to_string(),

                TimeDisplayType::Relative => {
                    let now = SystemTime::now()
                        .duration_since(UNIX_EPOCH)
                        .unwrap()
                        .as_secs();

                    longhand_displacement((reminder.time as u64).checked_sub(now).unwrap_or(1))
                }
            };

            format!(
                "'{}' *{}* **{}**",
                reminder.display_content(),
                &inter,
                time_display
            )
        });

        let _ = msg.channel_id.say_lines(&ctx, display).await;
    }
}

#[command("del")]
#[permission_level(Managed)]
async fn delete(ctx: &Context, msg: &Message, _args: String) {
    let (pool, lm) = get_ctx_data(&ctx).await;

    let user_data = UserData::from_user(&msg.author, &ctx, &pool).await.unwrap();

    let _ = msg
        .channel_id
        .say(&ctx, lm.get(&user_data.language, "del/listing"))
        .await;

    let reminders = if let Some(guild_id) = msg.guild_id.map(|f| f.as_u64().to_owned()) {
        sqlx::query_as_unchecked!(
            LookReminder,
            "
SELECT
    reminders.id, reminders.time, channels.channel, messages.content, embeds.description
FROM
    reminders
LEFT OUTER JOIN
    channels
ON
    channels.id = reminders.channel_id
INNER JOIN
    messages
ON
    messages.id = reminders.message_id
LEFT JOIN
    embeds
ON
    embeds.id = messages.embed_id
WHERE
    channels.guild_id = (SELECT id FROM guilds WHERE guild = ?)
            ",
            guild_id
        )
        .fetch_all(&pool)
        .await
    } else {
        sqlx::query_as!(
            LookReminder,
            "
SELECT
    reminders.id, reminders.time, channels.channel, messages.content, embeds.description
FROM
    reminders
INNER JOIN
    messages
ON
    reminders.message_id = messages.id
LEFT JOIN
    embeds
ON
    embeds.id = messages.embed_id
INNER JOIN
    channels
ON
    channels.id = reminders.channel_id
WHERE
    channels.channel = ?
            ",
            msg.channel_id.as_u64()
        )
        .fetch_all(&pool)
        .await
    }
    .unwrap();

    let mut reminder_ids: Vec<u32> = vec![];

    let enumerated_reminders = reminders.iter().enumerate().map(|(count, reminder)| {
        reminder_ids.push(reminder.id);
        let time = user_data.timezone().timestamp(reminder.time as i64, 0);

        format!(
            "**{}**: '{}' *<#{}>* at {}",
            count + 1,
            reminder.display_content(),
            reminder.channel,
            time.format(user_data.meridian().fmt_str())
        )
    });

    let _ = msg.channel_id.say_lines(&ctx, enumerated_reminders).await;
    let _ = msg
        .channel_id
        .say(&ctx, lm.get(&user_data.language, "del/listed"))
        .await;

    let reply = msg
        .channel_id
        .await_reply(&ctx)
        .author_id(msg.author.id)
        .channel_id(msg.channel_id)
        .await;

    if let Some(content) = reply.map(|m| m.content.replace(",", " ")) {
        let parts = content
            .split(' ')
            .filter(|i| !i.is_empty())
            .collect::<Vec<&str>>();

        let valid_parts = parts
            .iter()
            .filter_map(|i| {
                i.parse::<usize>()
                    .ok()
                    .filter(|val| val > &0)
                    .map(|val| reminder_ids.get(val - 1))
                    .flatten()
            })
            .map(|item| item.to_string())
            .collect::<Vec<String>>();

        if parts.len() == valid_parts.len() {
            let joined = valid_parts.join(",");

            let count_row = sqlx::query!(
                "
SELECT COUNT(1) AS count FROM reminders WHERE FIND_IN_SET(id, ?)
                ",
                joined
            )
            .fetch_one(&pool)
            .await
            .unwrap();

            sqlx::query!(
                "
DELETE FROM reminders WHERE FIND_IN_SET(id, ?)
                ",
                joined
            )
            .execute(&pool)
            .await
            .unwrap();

            if let Some(guild_id) = msg.guild_id {
                let _ = sqlx::query!(
                    "
INSERT INTO events (event_name, bulk_count, guild_id, user_id) VALUES ('delete', ?, ?, ?)
                    ",
                    count_row.count,
                    guild_id.as_u64(),
                    user_data.id
                )
                .execute(&pool)
                .await;
            }

            let content = lm.get(&user_data.language, "del/count").replacen(
                "{}",
                &count_row.count.to_string(),
                1,
            );

            let _ = msg.channel_id.say(&ctx, content).await;
        } else {
            let content = lm
                .get(&user_data.language, "del/count")
                .replacen("{}", "0", 1);

            let _ = msg.channel_id.say(&ctx, content).await;
        }
    }
}

#[command("timer")]
#[permission_level(Managed)]
async fn timer(ctx: &Context, msg: &Message, args: String) {
    fn time_difference(start_time: NaiveDateTime) -> String {
        let unix_time = SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .unwrap()
            .as_secs() as i64;
        let now = NaiveDateTime::from_timestamp(unix_time, 0);

        let delta = (now - start_time).num_seconds();

        let (minutes, seconds) = delta.div_rem(&60);
        let (hours, minutes) = minutes.div_rem(&60);
        let (days, hours) = hours.div_rem(&24);

        format!("{} days, {:02}:{:02}:{:02}", days, hours, minutes, seconds)
    }

    let (pool, lm) = get_ctx_data(&ctx).await;

    let language = UserData::language_of(&msg.author, &pool).await;

    let mut args_iter = args.splitn(2, ' ');

    let owner = msg
        .guild_id
        .map(|g| g.as_u64().to_owned())
        .unwrap_or_else(|| msg.author.id.as_u64().to_owned());

    match args_iter.next() {
        Some("list") => {
            let timers = Timer::from_owner(owner, &pool).await;

            let _ = msg
                .channel_id
                .send_message(&ctx, |m| {
                    m.embed(|e| {
                        e.fields(timers.iter().map(|timer| {
                            (
                                &timer.name,
                                format!("⏳ `{}`", time_difference(timer.start_time)),
                                false,
                            )
                        }))
                    })
                })
                .await;
        }

        Some("start") => {
            let count = Timer::count_from_owner(owner, &pool).await;

            if count >= 25 {
                let _ = msg
                    .channel_id
                    .say(&ctx, lm.get(&language, "timer/limit"))
                    .await;
            } else {
                let name = args_iter
                    .next()
                    .map(|s| s.to_string())
                    .unwrap_or(format!("New timer #{}", count + 1));

                if name.len() <= 32 {
                    Timer::create(&name, owner, &pool).await;

                    let _ = msg
                        .channel_id
                        .say(&ctx, lm.get(&language, "timer/success"))
                        .await;
                } else {
                    let _ = msg
                        .channel_id
                        .say(
                            &ctx,
                            lm.get(&language, "timer/name_length")
                                .replace("{}", &name.len().to_string()),
                        )
                        .await;
                }
            }
        }

        Some("delete") => {
            if let Some(name) = args_iter.next() {
                let exists = sqlx::query!(
                    "
SELECT 1 as _r FROM timers WHERE owner = ? AND name = ?
                    ",
                    owner,
                    name
                )
                .fetch_one(&pool)
                .await;

                if exists.is_ok() {
                    sqlx::query!(
                        "
DELETE FROM timers WHERE owner = ? AND name = ?
                        ",
                        owner,
                        name
                    )
                    .execute(&pool)
                    .await
                    .unwrap();

                    let _ = msg
                        .channel_id
                        .say(&ctx, lm.get(&language, "timer/deleted"))
                        .await;
                } else {
                    let _ = msg
                        .channel_id
                        .say(&ctx, lm.get(&language, "timer/not_found"))
                        .await;
                }
            } else {
                let _ = msg
                    .channel_id
                    .say(&ctx, lm.get(&language, "timer/help"))
                    .await;
            }
        }

        _ => {
            let prefix = GuildData::prefix_from_id(msg.guild_id, &pool).await;

            command_help(ctx, msg, lm, &prefix, &language, "timer").await;
        }
    }
}

#[derive(PartialEq)]
enum RemindCommand {
    Remind,
    Interval,
}

enum ReminderScope {
    User(u64),
    Channel(u64),
}

impl ReminderScope {
    fn mention(&self) -> String {
        match self {
            Self::User(id) => format!("<@{}>", id),
            Self::Channel(id) => format!("<#{}>", id),
        }
    }
}

#[derive(PartialEq, Eq, Hash, Debug)]
enum ReminderError {
    LongTime,
    LongInterval,
    PastTime,
    ShortInterval,
    InvalidTag,
    InvalidTime,
    InvalidExpiration,
    NeedSubscription,
    DiscordError(String),
}

impl std::fmt::Display for ReminderError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.to_response())
    }
}

impl std::error::Error for ReminderError {}

trait ToResponse {
    fn to_response(&self) -> &'static str;

    fn to_response_natural(&self) -> &'static str;
}

impl ToResponse for ReminderError {
    fn to_response(&self) -> &'static str {
        match self {
            Self::LongTime => "remind/long_time",
            Self::LongInterval => "interval/long_interval",
            Self::PastTime => "remind/past_time",
            Self::ShortInterval => "interval/short_interval",
            Self::InvalidTag => "remind/invalid_tag",
            Self::InvalidTime => "remind/invalid_time",
            Self::InvalidExpiration => "interval/invalid_expiration",
            Self::NeedSubscription => "interval/donor",
            Self::DiscordError(_) => "remind/generic_error",
        }
    }

    fn to_response_natural(&self) -> &'static str {
        match self {
            Self::LongTime => "natural/long_time",
            Self::InvalidTime => "natural/invalid_time",
            _ => self.to_response(),
        }
    }
}

impl<T> ToResponse for Result<T, ReminderError> {
    fn to_response(&self) -> &'static str {
        match self {
            Ok(_) => "remind/success",

            Err(reminder_error) => reminder_error.to_response(),
        }
    }

    fn to_response_natural(&self) -> &'static str {
        match self {
            Ok(_) => "remind/success",

            Err(reminder_error) => reminder_error.to_response_natural(),
        }
    }
}

fn generate_uid() -> String {
    let mut generator: OsRng = Default::default();

    (0..64)
        .map(|_| {
            CHARACTERS
                .chars()
                .choose(&mut generator)
                .unwrap()
                .to_owned()
                .to_string()
        })
        .collect::<Vec<String>>()
        .join("")
}

#[derive(Debug)]
enum ContentError {
    TooManyAttachments,
    AttachmentTooLarge,
    AttachmentDownloadFailed,
}

impl ContentError {
    fn to_response(&self) -> &'static str {
        match self {
            ContentError::TooManyAttachments => "remind/too_many_attachments",
            ContentError::AttachmentTooLarge => "remind/attachment_too_large",
            ContentError::AttachmentDownloadFailed => "remind/attachment_download_failed",
        }
    }
}

impl std::fmt::Display for ContentError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{:?}", self)
    }
}

impl std::error::Error for ContentError {}

struct Content {
    content: String,
    tts: bool,
    attachment: Option<Vec<u8>>,
    attachment_name: Option<String>,
}

impl Content {
    async fn build<S: ToString>(content: S, message: &Message) -> Result<Self, ContentError> {
        if message.attachments.len() > 1 {
            Err(ContentError::TooManyAttachments)
        } else if let Some(attachment) = message.attachments.get(0) {
            if attachment.size > 8_000_000 {
                Err(ContentError::AttachmentTooLarge)
            } else if let Ok(attachment_bytes) = attachment.download().await {
                Ok(Self {
                    content: content.to_string(),
                    tts: false,
                    attachment: Some(attachment_bytes.clone()),
                    attachment_name: Some(attachment.filename.clone()),
                })
            } else {
                Err(ContentError::AttachmentDownloadFailed)
            }
        } else {
            Ok(Self {
                content: content.to_string(),
                tts: false,
                attachment: None,
                attachment_name: None,
            })
        }
    }

    fn substitute(&mut self, guild: Guild) {
        if self.content.starts_with("/tts ") {
            self.tts = true;
            self.content = self.content.split_off(5);
        }

        self.content = REGEX_CONTENT_SUBSTITUTION
            .replace(&self.content, |caps: &Captures| {
                if let Some(user) = caps.name("user") {
                    format!("<@{}>", user.as_str())
                } else if let Some(role_name) = caps.name("role") {
                    if let Some(role) = guild.role_by_name(role_name.as_str()) {
                        role.mention().to_string()
                    } else {
                        format!("<<{}>>", role_name.as_str().to_string())
                    }
                } else {
                    String::new()
                }
            })
            .to_string()
            .replace("<<everyone>>", "@everyone")
            .replace("<<here>>", "@here");
    }
}

#[command("countdown")]
#[permission_level(Managed)]
async fn countdown(ctx: &Context, msg: &Message, args: String) {
    let (pool, lm) = get_ctx_data(&ctx).await;
    let language = UserData::language_of(&msg.author, &pool).await;

    if check_subscription_on_message(&ctx, &msg).await {
        let timezone = UserData::timezone_of(&msg.author, &pool).await;

        let split_args = args.splitn(3, ' ').collect::<Vec<&str>>();

        if split_args.len() == 3 {
            let time = split_args.get(0).unwrap();
            let interval = split_args.get(1).unwrap();
            let event_name = split_args.get(2).unwrap();

            let now = SystemTime::now()
                .duration_since(UNIX_EPOCH)
                .unwrap()
                .as_secs();

            let time_parser = TimeParser::new(*time, timezone);
            let interval_parser = TimeParser::new(*interval, timezone);

            if let Ok(target_ts) = time_parser.timestamp() {
                if let Ok(interval) = interval_parser.displacement() {
                    let mut first_time = target_ts;

                    while first_time - interval > now as i64 {
                        first_time -= interval;
                    }

                    let description = format!(
                        "**{}** occurs in **<<timefrom:{}:%d days, %h:%m>>**",
                        event_name, target_ts
                    );

                    sqlx::query!(
                        "
INSERT INTO embeds (title, description, color) VALUES (?, ?, ?)
                    ",
                        event_name,
                        description,
                        *THEME_COLOR
                    )
                    .execute(&pool)
                    .await
                    .unwrap();

                    let embed_id = sqlx::query!(
                        "
SELECT id FROM embeds WHERE title = ? AND description = ?
                    ",
                        event_name,
                        description
                    )
                    .fetch_one(&pool)
                    .await
                    .unwrap();

                    sqlx::query!(
                        "
INSERT INTO messages (embed_id) VALUES (?)
                    ",
                        embed_id.id
                    )
                    .execute(&pool)
                    .await
                    .unwrap();

                    sqlx::query!(
                        "
INSERT INTO reminders (
    `uid`,
    `name`,
    `message_id`,
    `channel_id`,
    `time`,
    `interval`,
    `method`,
    `set_by`,
    `expires`
) VALUES (
    ?,
    'Countdown',
    (SELECT id FROM messages WHERE embed_id = ?),
    (SELECT id FROM channels WHERE channel = ?),
    ?,
    ?,
    'countdown',
    (SELECT id FROM users WHERE user = ?),
    FROM_UNIXTIME(?)
)
                    ",
                        generate_uid(),
                        embed_id.id,
                        msg.channel_id.as_u64(),
                        first_time,
                        interval,
                        msg.author.id.as_u64(),
                        target_ts
                    )
                    .execute(&pool)
                    .await
                    .unwrap();

                    let _ = msg.channel_id.send_message(&ctx, |m| {
                        m.embed(|e| {
                            e.title(lm.get(&language, "remind/success")).description(
                                "A new countdown reminder has been created on this channel",
                            )
                        })
                    });
                } else {
                    let _ = msg.channel_id.send_message(&ctx, |m| {
                        m.embed(|e| {
                            e.title(lm.get(&language, "remind/issue"))
                                .description(lm.get(&language, "interval/invalid_interval"))
                        })
                    });
                }
            } else {
                let _ = msg.channel_id.send_message(&ctx, |m| {
                    m.embed(|e| {
                        e.title(lm.get(&language, "remind/issue"))
                            .description(lm.get(&language, "remind/invalid_time"))
                    })
                });
            }
        } else {
            command_help(
                ctx,
                msg,
                lm,
                &GuildData::prefix_from_id(msg.guild_id, &pool).await,
                &language,
                "countdown",
            )
            .await;
        }
    } else {
        let _ = msg
            .channel_id
            .say(
                &ctx,
                lm.get(&language, "interval/donor").replace(
                    "{prefix}",
                    &GuildData::prefix_from_id(msg.guild_id, &pool).await,
                ),
            )
            .await;
    }
}

#[command("remind")]
#[permission_level(Managed)]
async fn remind(ctx: &Context, msg: &Message, args: String) {
    remind_command(ctx, msg, args, RemindCommand::Remind).await;
}

#[command("interval")]
#[permission_level(Managed)]
async fn interval(ctx: &Context, msg: &Message, args: String) {
    remind_command(ctx, msg, args, RemindCommand::Interval).await;
}

fn parse_mention_list(mentions: &str) -> Vec<ReminderScope> {
    REGEX_CHANNEL_USER
        .captures_iter(mentions)
        .map(|i| {
            let pref = i.get(1).unwrap().as_str();
            let id = i.get(2).unwrap().as_str().parse::<u64>().unwrap();

            if pref == "#" {
                ReminderScope::Channel(id)
            } else {
                ReminderScope::User(id)
            }
        })
        .collect::<Vec<ReminderScope>>()
}

async fn remind_command(ctx: &Context, msg: &Message, args: String, command: RemindCommand) {
    let (pool, lm) = get_ctx_data(&ctx).await;

    let timezone = UserData::timezone_of(&msg.author, &pool).await;
    let language = UserData::language_of(&msg.author, &pool).await;

    match REGEX_REMIND_COMMAND.captures(&args) {
        Some(captures) => {
            let parsed = parse_mention_list(captures.name("mentions").unwrap().as_str());

            let scopes = if parsed.len() == 0 {
                vec![ReminderScope::Channel(msg.channel_id.into())]
            } else {
                parsed
            };

            let time_parser = TimeParser::new(captures.name("time").unwrap().as_str(), timezone);

            let expires_parser = captures
                .name("expires")
                .map(|mat| TimeParser::new(mat.as_str(), timezone));

            let interval_parser = captures
                .name("interval")
                .map(|mat| TimeParser::new(mat.as_str(), timezone))
                .map(|parser| parser.displacement())
                .transpose();

            if let Ok(interval) = interval_parser {
                if interval.is_some() && !check_subscription_on_message(&ctx, msg).await {
                    // no patreon
                    let _ = msg
                        .channel_id
                        .say(
                            &ctx,
                            lm.get(&language, "interval/donor").replace(
                                "{prefix}",
                                &GuildData::prefix_from_id(msg.guild_id, &pool).await,
                            ),
                        )
                        .await;
                } else {
                    let content_res = Content::build(
                        captures.name("content").map(|mat| mat.as_str()).unwrap(),
                        msg,
                    )
                    .await;

                    match content_res {
                        Ok(mut content) => {
                            let mut ok_locations = vec![];
                            let mut err_locations = vec![];
                            let mut err_types = HashSet::new();

                            for scope in scopes {
                                let res = create_reminder(
                                    &ctx,
                                    &pool,
                                    msg.author.id,
                                    msg.guild_id,
                                    &scope,
                                    &time_parser,
                                    expires_parser.as_ref().clone(),
                                    interval,
                                    &mut content,
                                )
                                .await;

                                if let Err(e) = res {
                                    err_locations.push(scope);
                                    err_types.insert(e);
                                } else {
                                    ok_locations.push(scope);
                                }
                            }

                            let success_part = match ok_locations.len() {
                                0 => "".to_string(),
                                1 => lm
                                    .get(&language, "remind/success")
                                    .replace("{location}", &ok_locations[0].mention())
                                    .replace(
                                        "{offset}",
                                        &shorthand_displacement(
                                            time_parser.displacement().unwrap() as u64,
                                        ),
                                    ),
                                n => lm
                                    .get(&language, "remind/success_bulk")
                                    .replace("{number}", &n.to_string())
                                    .replace(
                                        "{location}",
                                        &ok_locations
                                            .iter()
                                            .map(|l| l.mention())
                                            .collect::<Vec<String>>()
                                            .join(", "),
                                    )
                                    .replace(
                                        "{offset}",
                                        &shorthand_displacement(
                                            time_parser.displacement().unwrap() as u64,
                                        ),
                                    ),
                            };

                            let error_part = format!(
                                "{}\n{}",
                                match err_locations.len() {
                                    0 => "".to_string(),
                                    1 => lm
                                        .get(&language, "remind/issue")
                                        .replace("{location}", &err_locations[0].mention()),
                                    n => lm
                                        .get(&language, "remind/issue_bulk")
                                        .replace("{number}", &n.to_string())
                                        .replace(
                                            "{location}",
                                            &err_locations
                                                .iter()
                                                .map(|l| l.mention())
                                                .collect::<Vec<String>>()
                                                .join(", "),
                                        ),
                                },
                                err_types
                                    .iter()
                                    .map(|err| match err {
                                        ReminderError::DiscordError(s) => lm
                                            .get(&language, err.to_response())
                                            .replace("{error}", &s),

                                        _ => lm
                                            .get(&language, err.to_response())
                                            .replace("{min_interval}", &*MIN_INTERVAL.to_string()),
                                    })
                                    .collect::<Vec<String>>()
                                    .join("\n")
                            );

                            let _ = msg
                                .channel_id
                                .send_message(&ctx, |m| {
                                    m.embed(|e| {
                                        e.title(
                                            lm.get(&language, "remind/title").replace(
                                                "{number}",
                                                &ok_locations.len().to_string(),
                                            ),
                                        )
                                        .description(format!("{}\n\n{}", success_part, error_part))
                                        .color(*THEME_COLOR)
                                    })
                                })
                                .await;
                        }

                        Err(content_error) => {
                            let _ = msg
                                .channel_id
                                .send_message(ctx, |m| {
                                    m.embed(move |e| {
                                        e.title(
                                            lm.get(&language, "remind/title")
                                                .replace("{number}", "0"),
                                        )
                                        .description(lm.get(&language, content_error.to_response()))
                                        .color(*THEME_COLOR)
                                    })
                                })
                                .await;
                        }
                    }
                }
            } else {
                let _ = msg
                    .channel_id
                    .send_message(ctx, |m| {
                        m.embed(move |e| {
                            e.title(lm.get(&language, "remind/title").replace("{number}", "0"))
                                .description(lm.get(&language, "interval/invalid_interval"))
                                .color(*THEME_COLOR)
                        })
                    })
                    .await;
            }
        }

        None => {
            let prefix = GuildData::prefix_from_id(msg.guild_id, &pool).await;

            match command {
                RemindCommand::Remind => {
                    command_help(ctx, msg, lm, &prefix, &language, "remind").await
                }

                RemindCommand::Interval => {
                    command_help(ctx, msg, lm, &prefix, &language, "interval").await
                }
            }
        }
    }
}

#[command("natural")]
#[permission_level(Managed)]
async fn natural(ctx: &Context, msg: &Message, args: String) {
    let (pool, lm) = get_ctx_data(&ctx).await;

    let now = SystemTime::now();
    let since_epoch = now
        .duration_since(UNIX_EPOCH)
        .expect("Time calculated as going backwards. Very bad");

    let user_data = UserData::from_user(&msg.author, &ctx, &pool).await.unwrap();

    match REGEX_NATURAL_COMMAND_1.captures(&args) {
        Some(captures) => {
            let (expires, interval, string_content) =
                if check_subscription_on_message(&ctx, msg).await {
                    let rest_content = captures.name("msg").unwrap().as_str();

                    match REGEX_NATURAL_COMMAND_2.captures(rest_content) {
                        Some(secondary_captures) => {
                            let expires =
                                if let Some(expires_crop) = secondary_captures.name("expires") {
                                    natural_parser(expires_crop.as_str(), &user_data.timezone).await
                                } else {
                                    None
                                };

                            let interval =
                                if let Some(interval_crop) = secondary_captures.name("interval") {
                                    humantime::parse_duration(interval_crop.as_str())
                                        .or_else(|_| {
                                            humantime::parse_duration(&format!(
                                                "1 {}",
                                                interval_crop.as_str()
                                            ))
                                        })
                                        .map(|duration| duration.as_secs() as i64)
                                        .ok()
                                } else {
                                    None
                                };

                            (
                                expires,
                                interval,
                                if interval.is_some() {
                                    secondary_captures.name("msg").unwrap().as_str()
                                } else {
                                    rest_content
                                },
                            )
                        }

                        None => (None, None, rest_content),
                    }
                } else {
                    (None, None, captures.name("msg").unwrap().as_str())
                };

            let location_ids = if let Some(mentions) = captures.name("mentions").map(|m| m.as_str())
            {
                parse_mention_list(mentions)
            } else {
                vec![ReminderScope::Channel(msg.channel_id.into())]
            };

            if let Some(timestamp) =
                natural_parser(captures.name("time").unwrap().as_str(), &user_data.timezone).await
            {
                let content_res = Content::build(string_content, msg).await;

                match content_res {
                    Ok(mut content) => {
                        let offset = timestamp as u64 - since_epoch.as_secs();

                        let mut ok_locations = vec![];
                        let mut err_locations = vec![];
                        let mut err_types = HashSet::new();

                        for scope in location_ids {
                            let res = create_reminder(
                                &ctx,
                                &pool,
                                msg.author.id,
                                msg.guild_id,
                                &scope,
                                timestamp,
                                expires,
                                interval.clone(),
                                &mut content,
                            )
                            .await;

                            if let Err(e) = res {
                                err_locations.push(scope);
                                err_types.insert(e);
                            } else {
                                ok_locations.push(scope);
                            }
                        }

                        let success_part = match ok_locations.len() {
                            0 => "".to_string(),
                            1 => lm
                                .get(&user_data.language, "remind/success")
                                .replace("{location}", &ok_locations[0].mention())
                                .replace("{offset}", &shorthand_displacement(offset)),
                            n => lm
                                .get(&user_data.language, "remind/success_bulk")
                                .replace("{number}", &n.to_string())
                                .replace(
                                    "{location}",
                                    &ok_locations
                                        .iter()
                                        .map(|l| l.mention())
                                        .collect::<Vec<String>>()
                                        .join(", "),
                                )
                                .replace("{offset}", &shorthand_displacement(offset)),
                        };

                        let error_part = format!(
                            "{}\n{}",
                            match err_locations.len() {
                                0 => "".to_string(),
                                1 => lm
                                    .get(&user_data.language, "remind/issue")
                                    .replace("{location}", &err_locations[0].mention()),
                                n => lm
                                    .get(&user_data.language, "remind/issue_bulk")
                                    .replace("{number}", &n.to_string())
                                    .replace(
                                        "{location}",
                                        &err_locations
                                            .iter()
                                            .map(|l| l.mention())
                                            .collect::<Vec<String>>()
                                            .join(", "),
                                    ),
                            },
                            err_types
                                .iter()
                                .map(|err| match err {
                                    ReminderError::DiscordError(s) => lm
                                        .get(&user_data.language, err.to_response_natural())
                                        .replace("{error}", &s),

                                    _ => lm
                                        .get(&user_data.language, err.to_response_natural())
                                        .to_string(),
                                })
                                .collect::<Vec<String>>()
                                .join("\n")
                        );

                        let _ = msg
                            .channel_id
                            .send_message(&ctx, |m| {
                                m.embed(|e| {
                                    e.title(
                                        lm.get(&user_data.language, "remind/title")
                                            .replace("{number}", &ok_locations.len().to_string()),
                                    )
                                    .description(format!("{}\n\n{}", success_part, error_part))
                                    .color(*THEME_COLOR)
                                })
                            })
                            .await;
                    }

                    Err(content_error) => {
                        let _ = msg
                            .channel_id
                            .send_message(ctx, |m| {
                                m.embed(move |e| {
                                    e.title(
                                        lm.get(&user_data.language, "remind/title")
                                            .replace("{number}", "0"),
                                    )
                                    .description(
                                        lm.get(&user_data.language, content_error.to_response()),
                                    )
                                    .color(*THEME_COLOR)
                                })
                            })
                            .await;
                    }
                }
            } else {
                let _ = msg
                    .channel_id
                    .send_message(ctx, |m| {
                        m.embed(move |e| {
                            e.title(
                                lm.get(&user_data.language, "remind/title")
                                    .replace("{number}", "0"),
                            )
                            .description(lm.get(&user_data.language, "natural/invalid_time"))
                            .color(*THEME_COLOR)
                        })
                    })
                    .await;
            }
        }

        None => {
            command_help(
                ctx,
                msg,
                lm,
                &GuildData::prefix_from_id(msg.guild_id, &pool).await,
                &user_data.language,
                "natural",
            )
            .await;
        }
    }
}

async fn create_reminder<'a, U: Into<u64>, T: TryInto<i64>>(
    ctx: impl CacheHttp + AsRef<Cache>,
    pool: &MySqlPool,
    user_id: U,
    guild_id: Option<GuildId>,
    scope_id: &ReminderScope,
    time_parser: T,
    expires_parser: Option<T>,
    interval: Option<i64>,
    content: &mut Content,
) -> Result<(), ReminderError> {
    let user_id = user_id.into();

    if let Some(g_id) = guild_id {
        if let Some(guild) = g_id.to_guild_cached(&ctx).await {
            content.substitute(guild);
        }
    }

    let mut nudge = 0;

    let db_channel_id = match scope_id {
        ReminderScope::User(user_id) => {
            let user = UserId(*user_id).to_user(&ctx).await.unwrap();

            let user_data = UserData::from_user(&user, &ctx, &pool).await.unwrap();

            user_data.dm_channel
        }

        ReminderScope::Channel(channel_id) => {
            let channel = ChannelId(*channel_id).to_channel(&ctx).await.unwrap();

            if channel.clone().guild().map(|gc| gc.guild_id) != guild_id {
                return Err(ReminderError::InvalidTag);
            }

            let mut channel_data = ChannelData::from_channel(channel.clone(), &pool)
                .await
                .unwrap();

            nudge = channel_data.nudge;

            if let Some(guild_channel) = channel.guild() {
                if channel_data.webhook_token.is_none() || channel_data.webhook_id.is_none() {
                    match create_webhook(&ctx, guild_channel, "Reminder").await {
                        Ok(webhook) => {
                            channel_data.webhook_id = Some(webhook.id.as_u64().to_owned());
                            channel_data.webhook_token = Some(webhook.token);

                            channel_data.commit_changes(&pool).await;
                        }

                        Err(e) => {
                            return Err(ReminderError::DiscordError(e.to_string()));
                        }
                    }
                }
            }

            channel_data.id
        }
    };

    // validate time, channel
    if interval.map_or(false, |inner| inner < *MIN_INTERVAL) {
        Err(ReminderError::ShortInterval)
    } else if interval.map_or(false, |inner| inner > *MAX_TIME) {
        Err(ReminderError::LongInterval)
    } else {
        match time_parser.try_into() {
            Ok(time_pre) => {
                match expires_parser.map(|t| t.try_into()).transpose() {
                    Ok(expires) => {
                        let time = time_pre + nudge as i64;

                        let unix_time = SystemTime::now()
                            .duration_since(UNIX_EPOCH)
                            .unwrap()
                            .as_secs() as i64;

                        if time >= unix_time - 10 {
                            if time > unix_time + *MAX_TIME {
                                Err(ReminderError::LongTime)
                            } else {
                                sqlx::query!(
                                    "
INSERT INTO messages (content, tts, attachment, attachment_name) VALUES (?, ?, ?, ?)
                            ",
                                    content.content,
                                    content.tts,
                                    content.attachment,
                                    content.attachment_name,
                                )
                                .execute(&pool.clone())
                                .await
                                .unwrap();

                                sqlx::query!(
                            "
INSERT INTO reminders (uid, message_id, channel_id, time, expires, `interval`, method, set_by) VALUES
    (?,
    (SELECT id FROM messages WHERE content = ? ORDER BY id DESC LIMIT 1),
    ?, ?, FROM_UNIXTIME(?), ?, 'remind',
    (SELECT id FROM users WHERE user = ? LIMIT 1))
                            ",
                            generate_uid(),
                            content.content,
                            db_channel_id,
                            time as u32,
                            expires,
                            interval,
                            user_id
                        )
                        .execute(pool)
                        .await
                        .unwrap();

                                Ok(())
                            }
                        } else if time < 0 {
                            // case required for if python returns -1
                            Err(ReminderError::InvalidTime)
                        } else {
                            Err(ReminderError::PastTime)
                        }
                    }

                    Err(_) => Err(ReminderError::InvalidExpiration),
                }
            }

            Err(_) => Err(ReminderError::InvalidTime),
        }
    }
}