meta: initial commit

src/main.rs

@@ -0,0 +1,212 @@
+use std::{
+    collections::BTreeMap,
+    fmt::{Debug, Display},
+    str::FromStr,
+};
+
+use clap::Parser;
+use opendal::{IntoOperatorUri, Operator, OperatorUri};
+use secrecy::{ExposeSecret, SecretString};
+use tracing_subscriber::fmt::format::FmtSpan;
+use twilight_gateway::{
+    Event, EventTypeFlags, Intents, Shard, ShardId, StreamExt, error::ReceiveMessageErrorType,
+};
+use twilight_model::{
+    channel::ChannelType,
+    id::{
+        Id,
+        marker::{ChannelMarker, GuildMarker, UserMarker},
+    },
+};
+use typed_builder::TypedBuilder;
+use vc_notifier::{OneToManyUniqueBTreeMapWithData, UserInVCData, VoiceStatus};
+
+type VCsInServer = OneToManyUniqueBTreeMapWithData<Id<ChannelMarker>, Id<UserMarker>, UserInVCData>;
+
+type VCs = BTreeMap<Id<GuildMarker>, VCsInServer>;
+
+#[derive(Clone)]
+struct OpendalOperator {
+    uri: OperatorUri,
+    operator: Operator,
+}
+
+impl FromStr for OpendalOperator {
+    type Err = opendal::Error;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let uri = s.into_operator_uri()?;
+        let operator = Operator::from_uri(&uri)?;
+
+        Ok(Self { uri, operator })
+    }
+}
+
+impl OpendalOperator {
+    fn into_inner(self) -> Operator {
+        self.operator
+    }
+}
+
+impl From<OpendalOperator> for Operator {
+    fn from(wrapper: OpendalOperator) -> Self {
+        wrapper.into_inner()
+    }
+}
+
+impl Debug for OpendalOperator {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        Debug::fmt(&self.uri, f)
+    }
+}
+
+#[derive(Debug, Parser)]
+struct Args {
+    #[arg(long, env)]
+    discord_token: SecretString,
+
+    #[arg(long, env)]
+    storage: OpendalOperator,
+}
+
+#[tokio::main]
+async fn main() {
+    tracing_subscriber::fmt()
+        .pretty()
+        .with_span_events(FmtSpan::NEW | FmtSpan::CLOSE)
+        .init();
+
+    let args = Parser::parse();
+
+    tracing::debug!(?args, "using");
+
+    let Args {
+        discord_token,
+        storage,
+    } = args;
+
+    rustls::crypto::aws_lc_rs::default_provider()
+        .install_default()
+        .unwrap();
+
+    let shard_id = ShardId::new(0, 1);
+    let intents = Intents::GUILD_VOICE_STATES;
+    let mut shard = Shard::new(shard_id, discord_token.expose_secret().to_owned(), intents);
+
+    let vc_event_types = EventTypeFlags::GUILD_VOICE_STATES;
+    let mut next_event = shard.next_event(vc_event_types);
+
+    let discord_client = twilight_http::Client::new(discord_token.expose_secret().to_owned());
+    let mut voice_status = initialize_vcs(&discord_client).await;
+    while let Some(event_res) = next_event.await {
+        match event_res {
+            Ok(event) => {
+                tracing::debug!(?voice_status, "before handling");
+                handle_event(event, &mut voice_status).await;
+                tracing::debug!(?voice_status, "after handling");
+            }
+            Err(error) => {
+                tracing::error!(?error);
+            }
+        }
+
+        next_event = shard.next_event(vc_event_types);
+    }
+}
+
+#[tracing::instrument(skip(discord_client), ret)]
+async fn initialize_vcs(discord_client: &twilight_http::Client) -> VCs {
+    let mut vcs = VCs::default();
+
+    if let Ok(guilds_res) = discord_client.current_user_guilds().limit(200).await
+        && let Ok(guilds) = guilds_res.model().await
+    {
+        for guild in guilds {
+            if let Ok(guild_members_res) = discord_client.guild_members(guild.id).limit(999).await
+                && let Ok(guild_members) = guild_members_res.model().await
+            {
+                for member in guild_members {
+                    if let Ok(voice_state_res) = discord_client
+                        .user_voice_state(guild.id, member.user.id)
+                        .await
+                        && let Ok(voice_state) = voice_state_res.model().await
+                    {
+                        tracing::info!(?member.user.id, ?voice_state);
+
+                        let voice_status = VoiceStatus::builder()
+                            .self_deafened(voice_state.self_deaf)
+                            .self_muted(voice_state.self_mute)
+                            .server_deafened(voice_state.deaf)
+                            .server_muted(voice_state.mute)
+                            .camming(voice_state.self_video)
+                            .streaming(voice_state.self_stream)
+                            .build();
+                        let user_in_vc_data = voice_status.into();
+
+                        if let Some(channel_id) = voice_state.channel_id {
+                            vcs.entry(guild.id).or_default().insert(
+                                channel_id,
+                                member.user.id,
+                                user_in_vc_data,
+                            );
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    vcs
+}
+
+#[tracing::instrument(skip(vcs))]
+async fn handle_event(event: Event, vcs: &mut VCs) {
+    match event {
+        Event::VoiceStateUpdate(voice_state_update) => {
+            let user_id = voice_state_update.user_id;
+            match voice_state_update.guild_id {
+                Some(guild_id) => match voice_state_update.channel_id {
+                    Some(channel_id) => {
+                        let voice_status = VoiceStatus::builder()
+                            .self_deafened(voice_state_update.self_deaf)
+                            .self_muted(voice_state_update.self_mute)
+                            .server_deafened(voice_state_update.deaf)
+                            .server_muted(voice_state_update.mute)
+                            .camming(voice_state_update.self_video)
+                            .streaming(voice_state_update.self_stream)
+                            .build();
+                        let user_in_vc_data = voice_status.into();
+
+                        vcs.entry(guild_id).or_default().insert(
+                            channel_id,
+                            user_id,
+                            user_in_vc_data,
+                        );
+
+                        tracing::info!(
+                            ?guild_id,
+                            ?channel_id,
+                            ?user_id,
+                            "connected or otherwise changed state while connected"
+                        );
+                    }
+
+                    None => {
+                        if let Some(channel_vcers) = vcs.get_mut(&guild_id) {
+                            channel_vcers.remove_right(&user_id);
+                        }
+
+                        tracing::info!(?guild_id, ?user_id, "disconnected");
+                    }
+                },
+
+                None => {
+                    tracing::error!("why doesn't this have a guild id attached?!");
+                }
+            }
+        }
+        other => {
+            tracing::warn!(?other, "wasn't expected");
+        }
+    }
+}