mod logic;

mod map;

pub mod ownership;

mod schematic;

pub mod search;

mod sorter;

use crate::emoji;

use anyhow::Result;

use dashmap::DashMap;

use mindus::Serializable;

use poise::{serenity_prelude::*, CreateReply};

use serenity::futures::StreamExt;

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

use std::fmt::Write;

use std::time::{Duration, Instant};

use tokio::sync::Mutex;

assert_eq!(

std::process::Command::new("git")

.current_dir("repos")

.arg("clone")

.args(["--depth", "5"])

.arg(auth)

.stdout(Stdio::inherit())

.stderr(Stdio::inherit())

.status()

const PFX: char = '}';

if let [x, rest @ ..] = t {

let mut s = format!("[\"{x}\"");

for elem in rest {

}

}

pub struct Ch {

d: &'static str,

}

fn sep(x: Option<&Ch>) -> (Option<&'static str>, Option<String>, Option<&Repo>) {

(

x.map(|x| x.d),

)

}

c: Context<'_>,

#[description = "the channel in question"] ch: ChannelId,

) -> Result<()> {

let repo = repos::chief!(c);

let mut n = 0;

let d = SPECIAL[&ch.get()].d;

let h = c.say(format!("scouring {d}...")).await?;

unreachable!()

}

}

repo.push();

Ok(())

}

static HOOK: OnceLock<Webhook> = OnceLock::new();

pub async fn hookup(c: &impl AsRef<Http>) {

.author_nick(c)

.await

.unwrap_or(new_message.author.name.clone());

let m = Msg {

author: who.clone(),

avatar: new_message.author.avatar_url().unwrap_or(CAT.to_string()),

(new_message.author.name.clone(), new_message.author.id.get()),

);

use emoji::named::*;

send(c,|x| x

.avatar_url(new_message.author.avatar_url().unwrap_or(CAT.to_string()))

.username(&who)

.description(format!("https://discord.com/channels/925674713429184564/{}/{} {ADD} add {} (`{:x}.msch`)", m.channel_id,m.id, emoji::mindustry::to_discord(&strip_colors(s.tags.get("name").unwrap())), new_message.id.get())))

).await;

}

repo.write(dir, new_message.id, s);

repo.add();

repo.commit(&who, &format!("add {:x}.msch", new_message.id.get()));

}

static SEEN: LazyLock<Mutex<HashSet<(GuildId, u64, String, UserId)>>> =

LazyLock::new(|| Mutex::new(HashSet::new()));

pub struct Bot;

impl Bot {

pub async fn spawn() {

use emoji::named::*;

println!("bot startup");

let tok =

std::env::var("TOKEN").unwrap_or_else(|_| read_to_string("token").expect("wher token"));

// let User{id,name:owner_name,..} = c.http().get_user(*owner_id).await.unwrap();

}

// :deny:, @vd

&& *id == git.deny_emoji

&& git.auth(m)

=> {

let m = c.http().get_message(*channel_id,* message_id).await?;

let who = nick.as_deref().unwrap_or(&user.name);

git.remove(dir, *message_id);

git.commit(who, &format!("remove {:x}.msch", message_id.get()));

git.push();

m.delete_reaction(c,Some(1174262682573082644.into()), ReactionType::Custom { animated: false, id: 1192316518395039864.into(), name: Some("merge".into()) }).await.unwrap();

m.react(c,emojis::get!(DENY)).await?;

// only design-it has a webhook (possibly subject to future change)

send(c,|x| x

.avatar_url(user.avatar_url().unwrap_or(CAT.to_string()))

.username(who)

return Ok(());

}

handle_message(c, new_message, d).await?;

}

FullEvent::MessageUpdate {event: MessageUpdateEvent {

author: Some(author),

}

}

}

FullEvent::MessageDelete {

deleted_message_id, channel_id, ..

} => {

}

if let Some((_, r)) = d.tracker.remove(deleted_message_id) {

r.delete(c).await.unwrap();

// Ok(())

// }

// dbg!(m

// .iter()

pub async fn leaderboard(c: Context<'_>, channel: Option<ChannelId>, vds: bool) -> Result<()> {

use emoji::named::*;

c.defer().await?;

let process = |map: HashMap<u64, u16>| {

let mut v = map.into_iter().collect::<Vec<_>>();

v.sort_by_key(|(_, x)| *x);

out

};

Ok(())

}