use std::{
    collections::HashSet,
    string::ToString,
    time::{SystemTime, UNIX_EPOCH},
};

use chrono::NaiveDateTime;
use chrono_tz::Tz;
use num_integer::Integer;
use regex_command_attr::command;
use serenity::{builder::CreateEmbed, client::Context, model::channel::Channel};

use crate::{
    check_guild_subscription, check_subscription,
    component_models::{
        pager::{DelPager, LookPager, Pager},
        ComponentDataModel, DelSelector,
    },
    consts::{EMBED_DESCRIPTION_MAX_LENGTH, REGEX_CHANNEL_USER, SELECT_MAX_ENTRIES, THEME_COLOR},
    framework::{CommandInvoke, CommandOptions, CreateGenericResponse, OptionValue},
    hooks::CHECK_GUILD_PERMISSIONS_HOOK,
    models::{
        reminder::{
            builder::{MultiReminderBuilder, ReminderScope},
            content::Content,
            errors::ReminderError,
            look_flags::{LookFlags, TimeDisplayType},
            Reminder,
        },
        timer::Timer,
        user_data::UserData,
        CtxData,
    },
    time_parser::natural_parser,
    SQLPool,
};

#[command("pause")]
#[description("Pause all reminders on the current channel until a certain time or indefinitely")]
#[arg(
    name = "until",
    description = "When to pause until (hint: try 'next Wednesday', or '10 minutes')",
    kind = "String",
    required = false
)]
#[supports_dm(false)]
#[hook(CHECK_GUILD_PERMISSIONS_HOOK)]
async fn pause(ctx: &Context, invoke: &mut CommandInvoke, args: CommandOptions) {
    let pool = ctx.data.read().await.get::<SQLPool>().cloned().unwrap();

    let timezone = UserData::timezone_of(&invoke.author_id(), &pool).await;

    let mut channel = ctx.channel_data(invoke.channel_id()).await.unwrap();

    match args.get("until") {
        Some(OptionValue::String(until)) => {
            let parsed = natural_parser(until, &timezone.to_string()).await;

            if let Some(timestamp) = parsed {
                let dt = NaiveDateTime::from_timestamp(timestamp, 0);

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

                channel.commit_changes(&pool).await;

                let _ = invoke
                    .respond(
                        ctx.http.clone(),
                        CreateGenericResponse::new().content(format!(
                            "Reminders in this channel have been silenced until **<t:{}:D>**",
                            timestamp
                        )),
                    )
                    .await;
            } else {
                let _ = invoke
                    .respond(
                        ctx.http.clone(),
                        CreateGenericResponse::new()
                            .content("Time could not be processed. Please write the time as clearly as possible"),
                    )
                    .await;
            }
        }
        _ => {
            channel.paused = !channel.paused;
            channel.paused_until = None;

            channel.commit_changes(&pool).await;

            if channel.paused {
                let _ = invoke
                    .respond(
                        ctx.http.clone(),
                        CreateGenericResponse::new()
                            .content("Reminders in this channel have been silenced indefinitely"),
                    )
                    .await;
            } else {
                let _ = invoke
                    .respond(
                        ctx.http.clone(),
                        CreateGenericResponse::new()
                            .content("Reminders in this channel have been unsilenced"),
                    )
                    .await;
            }
        }
    }
}

#[command("offset")]
#[description("Move all reminders in the current server by a certain amount of time. Times get added together")]
#[arg(
    name = "hours",
    description = "Number of hours to offset by",
    kind = "Integer",
    required = false
)]
#[arg(
    name = "minutes",
    description = "Number of minutes to offset by",
    kind = "Integer",
    required = false
)]
#[arg(
    name = "seconds",
    description = "Number of seconds to offset by",
    kind = "Integer",
    required = false
)]
#[hook(CHECK_GUILD_PERMISSIONS_HOOK)]
async fn offset(ctx: &Context, invoke: &mut CommandInvoke, args: CommandOptions) {
    let pool = ctx.data.read().await.get::<SQLPool>().cloned().unwrap();

    let combined_time = args.get("hours").map_or(0, |h| h.as_i64().unwrap() * 3600)
        + args.get("minutes").map_or(0, |m| m.as_i64().unwrap() * 60)
        + args.get("seconds").map_or(0, |s| s.as_i64().unwrap());

    if combined_time == 0 {
        let _ = invoke
            .respond(
                ctx.http.clone(),
                CreateGenericResponse::new()
                    .content("Please specify one of `hours`, `minutes` or `seconds`"),
            )
            .await;
    } else {
        if let Some(guild) = invoke.guild(ctx.cache.clone()) {
            let channels = guild
                .channels
                .iter()
                .filter(|(_, channel)| match channel {
                    Channel::Guild(guild_channel) => guild_channel.is_text_based(),
                    _ => false,
                })
                .map(|(id, _)| id.0.to_string())
                .collect::<Vec<String>>()
                .join(",");

            sqlx::query!(
                "
UPDATE reminders
INNER JOIN
    `channels` ON `channels`.id = reminders.channel_id
SET reminders.`utc_time` = DATE_ADD(reminders.`utc_time`, INTERVAL ? SECOND)
WHERE FIND_IN_SET(channels.`channel`, ?)",
                combined_time,
                channels
            )
            .execute(&pool)
            .await
            .unwrap();
        } else {
            sqlx::query!(
                "UPDATE reminders INNER JOIN `channels` ON `channels`.id = reminders.channel_id SET reminders.`utc_time` = reminders.`utc_time` + ? WHERE channels.`channel` = ?",
                combined_time,
                invoke.channel_id().0
            )
            .execute(&pool)
            .await
            .unwrap();
        }

        let _ = invoke
            .respond(
                ctx.http.clone(),
                CreateGenericResponse::new()
                    .content(format!("All reminders offset by {} seconds", combined_time)),
            )
            .await;
    }
}

#[command("nudge")]
#[description("Nudge all future reminders on this channel by a certain amount (don't use for DST! See `/offset`)")]
#[arg(
    name = "minutes",
    description = "Number of minutes to nudge new reminders by",
    kind = "Integer",
    required = false
)]
#[arg(
    name = "seconds",
    description = "Number of seconds to nudge new reminders by",
    kind = "Integer",
    required = false
)]
#[hook(CHECK_GUILD_PERMISSIONS_HOOK)]
async fn nudge(ctx: &Context, invoke: &mut CommandInvoke, args: CommandOptions) {
    let pool = ctx.data.read().await.get::<SQLPool>().cloned().unwrap();

    let combined_time = args.get("minutes").map_or(0, |m| m.as_i64().unwrap() * 60)
        + args.get("seconds").map_or(0, |s| s.as_i64().unwrap());

    if combined_time < i16::MIN as i64 || combined_time > i16::MAX as i64 {
        let _ = invoke
            .respond(
                ctx.http.clone(),
                CreateGenericResponse::new().content("Nudge times must be less than 500 minutes"),
            )
            .await;
    } else {
        let mut channel_data = ctx.channel_data(invoke.channel_id()).await.unwrap();

        channel_data.nudge = combined_time as i16;
        channel_data.commit_changes(&pool).await;

        let _ = invoke
            .respond(
                ctx.http.clone(),
                CreateGenericResponse::new().content(format!(
                    "Future reminders will be nudged by {} seconds",
                    combined_time
                )),
            )
            .await;
    }
}

#[command("look")]
#[description("View reminders on a specific channel")]
#[arg(
    name = "channel",
    description = "The channel to view reminders on",
    kind = "Channel",
    required = false
)]
#[arg(
    name = "disabled",
    description = "Whether to show disabled reminders or not",
    kind = "Boolean",
    required = false
)]
#[arg(
    name = "relative",
    description = "Whether to display times as relative or exact times",
    kind = "Boolean",
    required = false
)]
#[hook(CHECK_GUILD_PERMISSIONS_HOOK)]
async fn look(ctx: &Context, invoke: &mut CommandInvoke, args: CommandOptions) {
    let pool = ctx.data.read().await.get::<SQLPool>().cloned().unwrap();

    let timezone = UserData::timezone_of(&invoke.author_id(), &pool).await;

    let flags = LookFlags {
        show_disabled: args.get("disabled").map(|i| i.as_bool()).flatten().unwrap_or(true),
        channel_id: args.get("channel").map(|i| i.as_channel_id()).flatten(),
        time_display: args.get("relative").map_or(TimeDisplayType::Relative, |b| {
            if b.as_bool() == Some(true) {
                TimeDisplayType::Relative
            } else {
                TimeDisplayType::Absolute
            }
        }),
    };

    let channel_opt = invoke.channel_id().to_channel_cached(&ctx);

    let channel_id = if let Some(Channel::Guild(channel)) = channel_opt {
        if Some(channel.guild_id) == invoke.guild_id() {
            flags.channel_id.unwrap_or_else(|| invoke.channel_id())
        } else {
            invoke.channel_id()
        }
    } else {
        invoke.channel_id()
    };

    let channel_name = if let Some(Channel::Guild(channel)) = channel_id.to_channel_cached(&ctx) {
        Some(channel.name)
    } else {
        None
    };

    let reminders = Reminder::from_channel(ctx, channel_id, &flags).await;

    if reminders.is_empty() {
        let _ = invoke
            .respond(
                ctx.http.clone(),
                CreateGenericResponse::new().content("No reminders on specified channel"),
            )
            .await;
    } else {
        let mut char_count = 0;

        let display = reminders
            .iter()
            .map(|reminder| reminder.display(&flags, &timezone))
            .take_while(|p| {
                char_count += p.len();

                char_count < EMBED_DESCRIPTION_MAX_LENGTH
            })
            .collect::<Vec<String>>()
            .join("\n");

        let pages = reminders
            .iter()
            .map(|reminder| reminder.display(&flags, &timezone))
            .fold(0, |t, r| t + r.len())
            .div_ceil(EMBED_DESCRIPTION_MAX_LENGTH);

        let pager = LookPager::new(flags, timezone);

        invoke
            .respond(
                ctx.http.clone(),
                CreateGenericResponse::new()
                    .embed(|e| {
                        e.title(format!(
                            "Reminders{}",
                            channel_name.map_or(String::new(), |n| format!(" on #{}", n))
                        ))
                        .description(display)
                        .footer(|f| f.text(format!("Page {} of {}", 1, pages)))
                        .color(*THEME_COLOR)
                    })
                    .components(|comp| {
                        pager.create_button_row(pages, comp);

                        comp
                    }),
            )
            .await
            .unwrap();
    }
}

#[command("del")]
#[description("Delete reminders")]
#[hook(CHECK_GUILD_PERMISSIONS_HOOK)]
async fn delete(ctx: &Context, invoke: &mut CommandInvoke, _args: CommandOptions) {
    let timezone = ctx.timezone(invoke.author_id()).await;

    let reminders = Reminder::from_guild(ctx, invoke.guild_id(), invoke.author_id()).await;

    let resp = show_delete_page(&reminders, 0, timezone);

    let _ = invoke.respond(&ctx, resp).await;
}

pub fn max_delete_page(reminders: &[Reminder], timezone: &Tz) -> usize {
    let mut rows = 0;
    let mut char_count = 0;

    reminders
        .iter()
        .enumerate()
        .map(|(count, reminder)| reminder.display_del(count, timezone))
        .fold(1, |mut pages, reminder| {
            rows += 1;
            char_count += reminder.len();

            if char_count > EMBED_DESCRIPTION_MAX_LENGTH || rows > SELECT_MAX_ENTRIES {
                rows = 1;
                char_count = reminder.len();
                pages += 1;
            }

            pages
        })
}

pub fn show_delete_page(
    reminders: &[Reminder],
    page: usize,
    timezone: Tz,
) -> CreateGenericResponse {
    let pager = DelPager::new(page, timezone);

    if reminders.is_empty() {
        return CreateGenericResponse::new()
            .embed(|e| e.title("Delete Reminders").description("No Reminders").color(*THEME_COLOR))
            .components(|comp| {
                pager.create_button_row(0, comp);
                comp
            });
    }

    let pages = max_delete_page(reminders, &timezone);

    let mut page = page;
    if page >= pages {
        page = pages - 1;
    }

    let mut char_count = 0;
    let mut rows = 0;
    let mut skipped_rows = 0;
    let mut skipped_char_count = 0;
    let mut first_num = 0;

    let mut skipped_pages = 0;

    let (shown_reminders, display_vec): (Vec<&Reminder>, Vec<String>) = reminders
        .iter()
        .enumerate()
        .map(|(count, reminder)| (reminder, reminder.display_del(count, &timezone)))
        .skip_while(|(_, p)| {
            first_num += 1;
            skipped_rows += 1;
            skipped_char_count += p.len();

            if skipped_char_count > EMBED_DESCRIPTION_MAX_LENGTH
                || skipped_rows > SELECT_MAX_ENTRIES
            {
                skipped_rows = 1;
                skipped_char_count = p.len();
                skipped_pages += 1;
            }

            skipped_pages < page
        })
        .take_while(|(_, p)| {
            rows += 1;
            char_count += p.len();

            char_count < EMBED_DESCRIPTION_MAX_LENGTH && rows <= SELECT_MAX_ENTRIES
        })
        .unzip();

    let display = display_vec.join("\n");

    let del_selector = ComponentDataModel::DelSelector(DelSelector { page, timezone });

    CreateGenericResponse::new()
        .embed(|e| {
            e.title("Delete Reminders")
                .description(display)
                .footer(|f| f.text(format!("Page {} of {}", page + 1, pages)))
                .color(*THEME_COLOR)
        })
        .components(|comp| {
            pager.create_button_row(pages, comp);

            comp.create_action_row(|row| {
                row.create_select_menu(|menu| {
                    menu.custom_id(del_selector.to_custom_id()).options(|opt| {
                        for (count, reminder) in shown_reminders.iter().enumerate() {
                            opt.create_option(|o| {
                                o.label(count + first_num).value(reminder.id).description({
                                    let c = reminder.display_content();

                                    if c.len() > 100 {
                                        format!(
                                            "{}...",
                                            reminder
                                                .display_content()
                                                .chars()
                                                .take(97)
                                                .collect::<String>()
                                        )
                                    } else {
                                        c.to_string()
                                    }
                                })
                            });
                        }

                        opt
                    })
                })
            })
        })
}

#[command("timer")]
#[description("Manage timers")]
#[subcommand("list")]
#[description("List the timers in this server or DM channel")]
#[subcommand("start")]
#[description("Start a new timer from now")]
#[arg(name = "name", description = "Name for the new timer", kind = "String", required = true)]
#[subcommand("delete")]
#[description("Delete a timer")]
#[arg(name = "name", description = "Name of the timer to delete", kind = "String", required = true)]
#[hook(CHECK_GUILD_PERMISSIONS_HOOK)]
async fn timer(ctx: &Context, invoke: &mut CommandInvoke, args: CommandOptions) {
    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 = ctx.data.read().await.get::<SQLPool>().cloned().unwrap();

    let owner = invoke.guild_id().map(|g| g.0).unwrap_or_else(|| invoke.author_id().0);

    match args.subcommand.clone().unwrap().as_str() {
        "start" => {
            let count = Timer::count_from_owner(owner, &pool).await;

            if count >= 25 {
                let _ = invoke
                    .respond(
                        ctx.http.clone(),
                        CreateGenericResponse::new()
                            .content("You already have 25 timers. Please delete some timers before creating a new one"),
                    )
                    .await;
            } else {
                let name = args.get("name").unwrap().to_string();

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

                    let _ = invoke
                        .respond(
                            ctx.http.clone(),
                            CreateGenericResponse::new().content("Created a new timer"),
                        )
                        .await;
                } else {
                    let _ = invoke
                        .respond(
                            ctx.http.clone(),
                            CreateGenericResponse::new()
                                .content(format!("Please name your timer something shorted (max. 32 characters, you used {})", name.len())),
                        )
                        .await;
                }
            }
        }
        "delete" => {
            let name = args.get("name").unwrap().to_string();

            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 _ = invoke
                    .respond(
                        ctx.http.clone(),
                        CreateGenericResponse::new().content("Deleted a timer"),
                    )
                    .await;
            } else {
                let _ = invoke
                    .respond(
                        ctx.http.clone(),
                        CreateGenericResponse::new().content("Could not find a timer by that name"),
                    )
                    .await;
            }
        }
        "list" => {
            let timers = Timer::from_owner(owner, &pool).await;

            if !timers.is_empty() {
                let _ = invoke
                    .respond(
                        ctx.http.clone(),
                        CreateGenericResponse::new().embed(|e| {
                            e.fields(timers.iter().map(|timer| {
                                (
                                    &timer.name,
                                    format!("⌚ `{}`", time_difference(timer.start_time)),
                                    false,
                                )
                            }))
                            .color(*THEME_COLOR)
                        }),
                    )
                    .await;
            } else {
                let _ = invoke
                    .respond(
                        ctx.http.clone(),
                        CreateGenericResponse::new().content(
                            "No timers currently. Use `/timer start` to create a new timer",
                        ),
                    )
                    .await;
            }
        }
        _ => {}
    }
}

#[command("remind")]
#[description("Create a new reminder")]
#[arg(
    name = "time",
    description = "A description of the time to set the reminder for",
    kind = "String",
    required = true
)]
#[arg(
    name = "content",
    description = "The message content to send",
    kind = "String",
    required = true
)]
#[arg(
    name = "channels",
    description = "Channel or user mentions to set the reminder for",
    kind = "String",
    required = false
)]
#[arg(
    name = "interval",
    description = "(Patreon only) Time to wait before repeating the reminder. Leave blank for one-shot reminder",
    kind = "String",
    required = false
)]
#[arg(
    name = "expires",
    description = "(Patreon only) For repeating reminders, the time at which the reminder will stop sending",
    kind = "String",
    required = false
)]
#[arg(
    name = "tts",
    description = "Set the TTS flag on the reminder message (like the /tts command)",
    kind = "Boolean",
    required = false
)]
#[hook(CHECK_GUILD_PERMISSIONS_HOOK)]
async fn remind(ctx: &Context, invoke: &mut CommandInvoke, args: CommandOptions) {
    if args.get("interval").is_none() && args.get("expires").is_some() {
        let _ = invoke
            .respond(
                &ctx,
                CreateGenericResponse::new().content("`expires` can only be used with `interval`"),
            )
            .await;

        return;
    }

    invoke.defer(&ctx).await;

    let user_data = ctx.user_data(invoke.author_id()).await.unwrap();
    let timezone = user_data.timezone();

    let time = {
        let time_str = args.get("time").unwrap().to_string();

        natural_parser(&time_str, &timezone.to_string()).await
    };

    match time {
        Some(time) => {
            let content = {
                let content = args.get("content").unwrap().to_string();
                let tts = args.get("tts").map_or(false, |arg| arg.as_bool().unwrap_or(false));

                Content { content, tts, attachment: None, attachment_name: None }
            };

            let scopes = {
                let list = args
                    .get("channels")
                    .map(|arg| parse_mention_list(&arg.to_string()))
                    .unwrap_or_default();

                if list.is_empty() {
                    if invoke.guild_id().is_some() {
                        vec![ReminderScope::Channel(invoke.channel_id().0)]
                    } else {
                        vec![ReminderScope::User(invoke.author_id().0)]
                    }
                } else {
                    list
                }
            };

            let (interval, expires) = if let Some(repeat) = args.get("interval") {
                if check_subscription(&ctx, invoke.author_id()).await
                    || (invoke.guild_id().is_some()
                        && check_guild_subscription(&ctx, invoke.guild_id().unwrap()).await)
                {
                    (
                        humantime::parse_duration(&repeat.to_string())
                            .or_else(|_| {
                                humantime::parse_duration(&format!("1 {}", repeat.to_string()))
                            })
                            .map(|duration| duration.as_secs() as i64)
                            .ok(),
                        {
                            if let Some(arg) = args.get("expires") {
                                natural_parser(&arg.to_string(), &timezone.to_string()).await
                            } else {
                                None
                            }
                        },
                    )
                } else {
                    let _ = invoke
                        .respond(&ctx, CreateGenericResponse::new()
                            .content("`repeat` is only available to Patreon subscribers or self-hosted users")
                        ).await;

                    return;
                }
            } else {
                (None, None)
            };

            if interval.is_none() && args.get("interval").is_some() {
                let _ = invoke
                    .respond(
                        &ctx,
                        CreateGenericResponse::new().content(
                            "Repeat interval could not be processed. Try and format the repetition similar to `1 hour` or `4 days`",
                        ),
                    )
                    .await;
            } else if expires.is_none() && args.get("expires").is_some() {
                let _ = invoke
                    .respond(
                        &ctx,
                        CreateGenericResponse::new().content(
                            "Expiry time failed to process. Please make it as clear as possible",
                        ),
                    )
                    .await;
            } else {
                let mut builder = MultiReminderBuilder::new(ctx, invoke.guild_id())
                    .author(user_data)
                    .content(content)
                    .time(time)
                    .expires(expires)
                    .interval(interval);

                builder.set_scopes(scopes);

                let (errors, successes) = builder.build().await;

                let embed = create_response(successes, errors, time);

                let _ = invoke
                    .respond(
                        &ctx,
                        CreateGenericResponse::new().embed(|c| {
                            *c = embed;
                            c
                        }),
                    )
                    .await;
            }
        }
        None => {
            let _ = invoke
                .respond(&ctx, CreateGenericResponse::new().content("Time could not be processed"))
                .await;
        }
    }
}

fn create_response(
    successes: HashSet<ReminderScope>,
    errors: HashSet<ReminderError>,
    time: i64,
) -> CreateEmbed {
    let success_part = match successes.len() {
        0 => "".to_string(),
        n => format!(
            "Reminder{s} for {locations} set for <t:{offset}:R>",
            s = if n > 1 { "s" } else { "" },
            locations = successes.iter().map(|l| l.mention()).collect::<Vec<String>>().join(", "),
            offset = time
        ),
    };

    let error_part = match errors.len() {
        0 => "".to_string(),
        n => format!(
            "{n} reminder{s} failed to set:\n{errors}",
            s = if n > 1 { "s" } else { "" },
            n = n,
            errors = errors.iter().map(|e| e.to_string()).collect::<Vec<String>>().join("\n")
        ),
    };

    let mut embed = CreateEmbed::default();
    embed
        .title(format!(
            "{n} Reminder{s} Set",
            n = successes.len(),
            s = if successes.len() > 1 { "s" } else { "" }
        ))
        .description(format!("{}\n\n{}", success_part, error_part))
        .color(*THEME_COLOR);

    embed
}

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>>()
}