use crate::webhook::Webhook;
use anyhow::Result;
use futures_util::StreamExt;
use minify_js::TopLevelMode;
use regex::Regex;
use serenity::http::Http;
use serenity::prelude::*;
use std::fs::read_to_string;
use std::sync::{Arc, Mutex, OnceLock};
use strum::{AsRefStr, EnumString, EnumVariantNames, VariantNames};
use tokio::sync::broadcast;
use tokio::sync::OnceCell as TokLock;
pub struct Data {
    stdin: broadcast::Sender<String>,
}

static SKIPPING: OnceLock<(Arc<Mutex<u8>>, broadcast::Sender<String>)> = OnceLock::new();

pub struct Bot;
impl Bot {
    pub async fn new(stdout: broadcast::Receiver<String>, stdin: broadcast::Sender<String>) {
        let tok = std::env::var("TOKEN").unwrap_or(read_to_string("token").expect("wher token"));
        let f: poise::FrameworkBuilder<Data, anyhow::Error> = poise::Framework::builder()
            .options(poise::FrameworkOptions {
                commands: vec![raw(), say(), ban(), js(), maps(), start(), end(), help()],
                prefix_options: poise::PrefixFrameworkOptions {
                    prefix: Some(">".to_string()),
                    ..Default::default()
                },
                ..Default::default()
            })
            .token(&tok)
            .intents(GatewayIntents::GUILD_MESSAGES | GatewayIntents::MESSAGE_CONTENT)
            .setup(|ctx, _ready, framework| {
                Box::pin(async move {
                    poise::builtins::register_globally(ctx, &framework.options().commands).await?;
                    println!("registered");
                    Ok(Data { stdin })
                })
            });

        tokio::spawn(async move {
            let http = Http::new("");
            let mut wh = Webhook::new(&http, &std::env::var("WEBHOOK").expect("no webhook!")).await;
            SKIPPING.get_or_init(|| (wh.skip.clone(), wh.skipped.clone()));
            wh.link(stdout).await;
        });
        tokio::spawn(async move {
            f.run().await.unwrap();
        });
    }
}

type Context<'a> = poise::Context<'a, Data, anyhow::Error>;

#[poise::command(
    prefix_command,
    required_permissions = "USE_SLASH_COMMANDS",
    category = "ADMINISTRATION"
)]
/// send a raw command to the server
async fn raw(
    ctx: Context<'_>,
    #[description = "Command"]
    #[rest]
    cmd: String,
) -> Result<()> {
    ctx.data().stdin.send(cmd)?;
    println!("sent");
    Ok(())
}

macro_rules! return_next {
    ($ctx:expr) => {{
        let line = get_nextblock().await;
        $ctx.send(|m| m.content(line)).await?;
        Ok(())
    }};
}

async fn get_nextblock() -> String {
    let (skip_count, skip_send) = SKIPPING.get().unwrap();
    {
        *skip_count.lock().unwrap() += 1;
    }
    skip_send
        .subscribe()
        .recv()
        .await
        .unwrap_or("._?".to_string())
}

#[poise::command(slash_command, category = "ADMINISTRATION")]
/// say something as the server
async fn say(ctx: Context<'_>, #[description = "Message"] message: String) -> Result<()> {
    let _ = ctx.defer();
    ctx.data().stdin.send(format!("say {message}"))?;
    return_next!(ctx)
}

#[derive(EnumString, EnumVariantNames, AsRefStr)]
#[strum(serialize_all = "snake_case")]
enum BanType {
    Id,
    Ip,
    Name,
}

async fn autocomplete_ban<'a>(
    _ctx: Context<'_>,
    partial: &'a str,
) -> impl futures::Stream<Item = String> + 'a {
    futures::stream::iter(BanType::VARIANTS)
        .filter(move |name| futures::future::ready(name.starts_with(partial)))
        .map(|name| name.to_string())
}

#[poise::command(slash_command, category = "ADMINISTRATION")]
/// ban a player
async fn ban(
    ctx: Context<'_>,
    #[autocomplete = "autocomplete_ban"] ban_type: BanType,
    #[description = "Player (id/ip/name)"] player: String,
) -> Result<()> {
    let _ = ctx.defer();
    ctx.data()
        .stdin
        .send(format!("ban {} {player}", ban_type.as_ref()))?;
    return_next!(ctx)
}

#[poise::command(
    prefix_command,
    required_permissions = "USE_SLASH_COMMANDS",
    category = "ADMINISTRATION",
    track_edits
)]
/// run arbitrary javascript
async fn js(
    ctx: Context<'_>,
    #[description = "Script"]
    #[rest]
    script: String,
) -> Result<()> {
    static RE: OnceLock<Regex> = OnceLock::new();
    let _ = ctx.channel_id().start_typing(&ctx.serenity_context().http);
    let re = RE.get_or_init(|| Regex::new(r#"```(js|javascript)?([^`]+)```"#).unwrap());
    let mat = re
        .captures(&script)
        .ok_or(anyhow::anyhow!(r#"no code found (use \`\`\`js...\`\`\`."#))?;
    let script = mat.get(2).unwrap().as_str();
    let mut out = vec![];
    let script = if let Err(_) = minify_js::minify(TopLevelMode::Global, script.into(), &mut out) {
        std::borrow::Cow::from(script.replace('\n', ";")) // xd
    } else {
        String::from_utf8_lossy(&out)
    };
    ctx.data().stdin.send(format!("js {script}"))?;
    let line = get_nextblock().await;
    ctx.send(|m| m.content(line)).await?;
    Ok(())
}

fn strip_colors(from: &str) -> String {
    let mut result = String::new();
    result.reserve(from.len());
    let mut level: u8 = 0;
    for c in from.chars() {
        if c == '[' {
            level += 1;
        } else if c == ']' {
            level -= 1;
        } else if level == 0 {
            result.push(c);
        }
    }
    result
}

static MAPS: TokLock<Vec<String>> = TokLock::const_new();
async fn get_maps(stdin: &broadcast::Sender<String>) -> &Vec<String> {
    MAPS.get_or_init(|| async move {
        stdin.send(format!("listmaps")).unwrap();
        let res = get_nextblock().await;
        let mut vec = vec![];
        for line in res.lines() {
            if let Some((_, name)) = line.split_once(':') {
                vec.push(strip_colors(name));
            }
        }
        vec
    })
    .await
}

#[poise::command(slash_command, required_permissions = "USE_SLASH_COMMANDS")]
/// lists the maps.
pub async fn maps(ctx: Context<'_>) -> Result<()> {
    let _ = ctx.defer();
    let maps = get_maps(&ctx.data().stdin).await;
    poise::send_reply(ctx, |m| {
        m.embed(|e| {
            for (k, v) in maps.iter().enumerate() {
                e.field((k + 1).to_string(), v, true);
            }
            e.description("map list.")
        })
    })
    .await?;
    Ok(())
}

async fn autocomplete_map<'a>(
    ctx: Context<'a>,
    partial: &'a str,
) -> impl futures::Stream<Item = String> + 'a {
    futures::stream::iter(get_maps(&ctx.data().stdin).await)
        .filter(move |name| futures::future::ready(name.starts_with(partial)))
        .map(|name| name.to_string())
}

async fn mapi(map: &str, stdin: &broadcast::Sender<String>) -> usize {
    get_maps(stdin).await.iter().position(|r| r == map).unwrap()
}

#[poise::command(slash_command, required_permissions = "USE_SLASH_COMMANDS")]
/// start the game.
pub async fn start(
    ctx: Context<'_>,
    #[description = "the map"]
    #[autocomplete = "autocomplete_map"]
    map: String,
) -> Result<()> {
    let _ = ctx.defer();
    ctx.data()
        .stdin
        .send(format!("plague {}", mapi(&map, &ctx.data().stdin).await))
        .unwrap();
    return_next!(ctx)
}

#[poise::command(slash_command, required_permissions = "USE_SLASH_COMMANDS")]
/// end the game.
pub async fn end(
    ctx: Context<'_>,
    #[description = "the map to go to"]
    #[autocomplete = "autocomplete_map"]
    map: String,
) -> Result<()> {
    let _ = ctx.defer();
    ctx.data()
        .stdin
        .send(format!("endplague {}", mapi(&map, &ctx.data().stdin).await))
        .unwrap();
    return_next!(ctx)
}

#[poise::command(
    prefix_command,
    slash_command,
    required_permissions = "USE_SLASH_COMMANDS",
    track_edits
)]
/// show help and stuff
pub async fn help(
    ctx: Context<'_>,
    #[description = "Specific command to show help about"]
    #[autocomplete = "poise::builtins::autocomplete_command"]
    command: Option<String>,
) -> Result<()> {
    poise::builtins::help(
        ctx,
        command.as_deref(),
        poise::builtins::HelpConfiguration {
            extra_text_at_bottom: "Mindustry server management bot",
            ..Default::default()
        },
    )
    .await?;
    Ok(())
}