0.5.0 embed, help, refractor

.env.example

@@ -0,0 +1,2 @@
+DISCORD_TOKEN=<YOUR_DISCORD_TOKEN>
+PREFIX=<YOUR_PREFIX>

.gitignore

@@ -1,2 +1,3 @@
 /target
 .env
+

Cargo.lock

@@ -124,6 +124,21 @@ version = "0.21.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9d297deb1925b89f2ccc13d7635fa0714f12c87adce1c75356b39ca9b7178567"
 
+[[package]]
+name = "bit-set"
+version = "0.5.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0700ddab506f33b20a03b13996eccd309a48e5ff77d0d95926aa0210fb4e95f1"
+dependencies = [
+ "bit-vec",
+]
+
+[[package]]
+name = "bit-vec"
+version = "0.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "349f9b6a179ed607305526ca489b34ad0a41aed5f7980fa90eb03160b69598fb"
+
 [[package]]
 name = "bitflags"
 version = "1.3.2"
@@ -340,6 +355,41 @@ dependencies = [
  "zeroize",
 ]
 
+[[package]]
+name = "darling"
+version = "0.20.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fc5d6b04b3fd0ba9926f945895de7d806260a2d7431ba82e7edaecb043c4c6b8"
+dependencies = [
+ "darling_core",
+ "darling_macro",
+]
+
+[[package]]
+name = "darling_core"
+version = "0.20.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "04e48a959bcd5c761246f5d090ebc2fbf7b9cd527a492b07a67510c108f1e7e3"
+dependencies = [
+ "fnv",
+ "ident_case",
+ "proc-macro2",
+ "quote",
+ "strsim",
+ "syn 2.0.48",
+]
+
+[[package]]
+name = "darling_macro"
+version = "0.20.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1d1545d67a2149e1d93b7e5c7752dce5a7426eb5d1357ddcfd89336b94444f77"
+dependencies = [
+ "darling_core",
+ "quote",
+ "syn 2.0.48",
+]
+
 [[package]]
 name = "dashmap"
 version = "5.5.3"
@@ -441,6 +491,17 @@ dependencies = [
  "version_check",
 ]
 
+[[package]]
+name = "fancy-regex"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "531e46835a22af56d1e3b66f04844bed63158bc094a628bec1d321d9b4c44bf2"
+dependencies = [
+ "bit-set",
+ "regex-automata 0.4.5",
+ "regex-syntax 0.8.2",
+]
+
 [[package]]
 name = "fastrand"
 version = "2.0.1"
@@ -785,6 +846,12 @@ dependencies = [
  "cc",
 ]
 
+[[package]]
+name = "ident_case"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b9e0384b61958566e926dc50660321d12159025e767c18e043daf26b70104c39"
+
 [[package]]
 name = "idna"
 version = "0.5.0"
@@ -892,10 +959,12 @@ dependencies = [
 
 [[package]]
 name = "lyra"
-version = "0.2.0"
+version = "0.5.0"
 dependencies = [
  "dotenv",
+ "fancy-regex",
  "openssl",
+ "poise",
  "regex",
  "reqwest",
  "serenity",
@@ -1247,6 +1316,35 @@ dependencies = [
  "pnet_base",
 ]
 
+[[package]]
+name = "poise"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1819d5a45e3590ef33754abce46432570c54a120798bdbf893112b4211fa09a6"
+dependencies = [
+ "async-trait",
+ "derivative",
+ "futures-util",
+ "parking_lot",
+ "poise_macros",
+ "regex",
+ "serenity",
+ "tokio",
+ "tracing",
+]
+
+[[package]]
+name = "poise_macros"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8fa2c123c961e78315cd3deac7663177f12be4460f5440dbf62a7ed37b1effea"
+dependencies = [
+ "darling",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.48",
+]
+
 [[package]]
 name = "poly1305"
 version = "0.8.0"
@@ -1976,6 +2074,12 @@ version = "0.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fe895eb47f22e2ddd4dabc02bce419d2e643c8e3b585c78158b349195bc24d82"
 
+[[package]]
+name = "strsim"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "73473c0e59e6d5812c5dfe2a064a6444949f089e20eec9a2e5506596494e4623"
+
 [[package]]
 name = "subtle"
 version = "2.5.0"
@@ -1990,10 +2094,14 @@ checksum = "62e48dba70095f265fdb269b99619b95d04c89e619538138383e63310b14d941"
 dependencies = [
  "lazy_static",
  "symphonia-bundle-flac",
+ "symphonia-bundle-mp3",
+ "symphonia-codec-aac",
  "symphonia-codec-adpcm",
+ "symphonia-codec-alac",
  "symphonia-codec-pcm",
  "symphonia-codec-vorbis",
  "symphonia-core",
+ "symphonia-format-isomp4",
  "symphonia-format-mkv",
  "symphonia-format-ogg",
  "symphonia-format-wav",
@@ -2012,6 +2120,30 @@ dependencies = [
  "symphonia-utils-xiph",
 ]
 
+[[package]]
+name = "symphonia-bundle-mp3"
+version = "0.5.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0f31d7fece546f1e6973011a9eceae948133bbd18fd3d52f6073b1e38ae6368a"
+dependencies = [
+ "bitflags 1.3.2",
+ "lazy_static",
+ "log",
+ "symphonia-core",
+ "symphonia-metadata",
+]
+
+[[package]]
+name = "symphonia-codec-aac"
+version = "0.5.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "68bdd75b25ce4b84b12a4bd20bfea2460c2dbd7fc1d227ef5533504d3168109d"
+dependencies = [
+ "lazy_static",
+ "log",
+ "symphonia-core",
+]
+
 [[package]]
 name = "symphonia-codec-adpcm"
 version = "0.5.3"
@@ -2022,6 +2154,16 @@ dependencies = [
  "symphonia-core",
 ]
 
+[[package]]
+name = "symphonia-codec-alac"
+version = "0.5.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3a27e8763d1c9eff666faf903e73a99d4de2f7a93fca4e3c214c1d68432903b9"
+dependencies = [
+ "log",
+ "symphonia-core",
+]
+
 [[package]]
 name = "symphonia-codec-pcm"
 version = "0.5.3"
@@ -2056,6 +2198,19 @@ dependencies = [
  "log",
 ]
 
+[[package]]
+name = "symphonia-format-isomp4"
+version = "0.5.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ffdf14bae5cf352032416bc64151e5d6242d29d33cbf3238513b44d4427a1efb"
+dependencies = [
+ "encoding_rs",
+ "log",
+ "symphonia-core",
+ "symphonia-metadata",
+ "symphonia-utils-xiph",
+]
+
 [[package]]
 name = "symphonia-format-mkv"
 version = "0.5.3"
@@ -2261,6 +2416,7 @@ dependencies = [
  "libc",
  "mio",
  "num_cpus",
+ "parking_lot",
  "pin-project-lite",
  "signal-hook-registry",
  "socket2",

Cargo.toml

@@ -1,17 +1,27 @@
 [package]
 name = "lyra"
-version = "0.2.0"
+version = "0.5.0"
+authors = ["Michał Czyż <mike@c2yz.com>"]
 edition = "2021"
+description = "A featureful Discord bot written in Rust."
+documentation = "https://lyra.c2yz.com/docs"
+readme = "README.md"
+homepage = "https://lyra.c2yz.com"
+license-file = "LICENSE.md"
+keywords = ["discord", "bot", "rust", "music", "featureful"]
+
 
 [dependencies]
 dotenv = "0.15.0"
+fancy-regex = "0.13.0"
 openssl = { version = "0.10.63", features = ["vendored"] }
+poise = "0.6.1"
 regex = "1.10.3"
 reqwest = "0.11.23"
 serenity = { version = "0.12.0", features = ["cache", "framework", "standard_framework", "voice"] }
 songbird = { version = "0.4.0", features = ["builtin-queue", "serenity"] }
-symphonia = "0.5.3"
-tokio = { version = "1.35.1", features = ["macros", "rt-multi-thread", "signal"] }
+symphonia = { version = "0.5.3", features = ["aac", "adpcm", "alac", "flac", "mpa", "isomp4"] }
+tokio = { version = "1.35.1", features = ["macros", "full", "signal"] }
 tracing = "0.1.40"
 tracing-futures = "0.2.5"
 tracing-subscriber = "0.3.18"

LICENSE.md

@@ -1,5 +1,7 @@
 # License
 
-Copyright(c) Michał Czyż 2024
+Copyright (C) 2024 Michał Czyż
 
-[Currently] All Rights Reserved.
+All Rights Reserved.
+
+This build is private and shall not be distributed nor modified without permission.

scripts/cross-build.sh

@@ -0,0 +1,3 @@
+#!/bin/bash
+
+cross build -r --target aarch64-unknown-linux-gnu

scripts/launch.sh

@@ -0,0 +1,3 @@
+#!/bin/bash
+
+nohup ../lyra > lyra.log 2> lyra.err < /dev/null &

src/commands.rs

@@ -1,4 +1,4 @@
 pub mod kashi;
-pub mod misc;
 pub mod music;
 pub mod tools;
+pub mod embeds;

src/commands/embeds.rs

@@ -0,0 +1,37 @@
+use crate::{Context, Error};
+
+use serenity::{builder::{CreateEmbedAuthor, CreateEmbedFooter}, model::{Colour, Timestamp}};
+use poise::serenity_prelude::CreateEmbed;
+use poise::CreateReply;
+
+pub async fn fail(ctx: Context<'_>, err: String) -> Result<(), Error> {
+    ctx.send(
+        CreateReply::default().embed(error_embed(ctx, &format!("Failed: {:?}", err)).await.unwrap())
+    ).await?;
+
+    Ok(())
+}
+
+pub async fn error_embed(ctx: Context<'_>, msg: &str) -> Result<CreateEmbed, Error> {
+    let embed = CreateEmbed::default()
+    .author(CreateEmbedAuthor::new("Something went wrong!").icon_url(ctx.author().clone().face()))
+    .colour(Colour::from_rgb(255, 58, 97))
+    .title("Oopsie, Doopsie!")
+    .description(msg)
+    .timestamp(Timestamp::now())
+    .footer(CreateEmbedFooter::new(ctx.cache().current_user().name.to_string()).icon_url(ctx.cache().current_user().face()));
+
+    Ok(embed)
+}
+
+pub async fn embed(ctx: Context<'_>, author: &str, description: &str, title: &str) -> Result<CreateEmbed, Error> {
+    let embed = CreateEmbed::default()
+    .author(CreateEmbedAuthor::new(author).icon_url(ctx.author().clone().face()))
+    .colour(Colour::from_rgb(255, 58, 97))
+    .title(title)
+    .description(description)
+    .timestamp(Timestamp::now())
+    .footer(CreateEmbedFooter::new(ctx.cache().current_user().name.to_string()).icon_url(ctx.cache().current_user().face()));
+
+    Ok(embed)
+}

src/commands/kashi.rs

@@ -0,0 +1,3 @@
+pub mod kashi;
+
+pub use kashi::kashi;

src/commands/kashi/kashi.rs

@@ -1,10 +1,17 @@
-use serenity::{all::Message, client::Context, framework::standard::{macros::command, CommandResult}};
+use crate::{Context, Error};
 
-use crate::commands::misc::check_msg;
+/// Kashi integration platform (WIP)
+#[poise::command(
+    prefix_command, 
+    slash_command,
+    category = "Kashi"
+)]
+pub async fn kashi(
+    ctx: Context<'_>
+) -> Result<(), Error> {
     
-#[command]
-async fn kashi(ctx: &Context, msg: &Message) -> CommandResult {
-    check_msg(msg.reply(ctx, "Kashi lyrics platform integration").await);
+    let response = format!("Kashi platform is currently under construction!");
+    ctx.say(response).await?;
 
     Ok(())
 }

src/commands/kashi/mod.rs

@@ -1 +0,0 @@
-pub mod kashi;

src/commands/misc.rs

@@ -1,8 +0,0 @@
-use serenity::model::channel::Message;
-use serenity::Result as SerenityResult;
-
-pub fn check_msg(result: SerenityResult<Message>) {
-    if let Err(why) = result {
-        println!("Error sending message: {:?}", why);
-    }
-}

src/commands/music.rs

@@ -0,0 +1,24 @@
+pub mod deafen;
+pub mod join;
+pub mod leave;
+pub mod notifier;
+pub mod mute;
+pub mod pause;
+pub mod play;
+pub mod queue;
+pub mod repeat;
+pub mod resume;
+pub mod skip;
+pub mod stop;
+
+pub use deafen::deafen;
+pub use join::join;
+pub use leave::leave;
+pub use mute::mute;
+pub use pause::pause;
+pub use play::play;
+pub use queue::queue;
+pub use repeat::repeat;
+pub use resume::resume;
+pub use skip::skip;
+pub use stop::stop;

src/commands/music/deafen.rs

@@ -1,24 +1,31 @@
-use serenity::framework::standard::macros::command;
-use serenity::framework::standard::CommandResult;
-use serenity::model::prelude::*;
-use serenity::prelude::*;
+use crate::{commands::embeds::{error_embed, embed, fail}, Context, Error};
+use poise::CreateReply;
 
-use crate::commands::misc::check_msg;
+/// Deafens itself while in a voice channel; \
+/// aliases: deafen, undeaden, shuush
+#[poise::command(
+    prefix_command,
+    slash_command,
+    aliases("shuush", "undeafen"),
+    category = "Music"
+)]
+pub async fn deafen(
+    ctx: Context<'_>
+) -> Result<(), Error> {
+    let guild_id = ctx.guild_id().unwrap();
 
-#[command]
-#[only_in(guilds)]
-async fn deafen(ctx: &Context, msg: &Message) -> CommandResult {
-    let guild_id = msg.guild_id.unwrap();
-
-    let manager = songbird::get(ctx)
+    let manager = songbird::get(&ctx.serenity_context())
         .await
-        .expect("Client placed at init")
+        .expect("Songbird client placed at init")
         .clone();
 
     let handler_lock = match manager.get(guild_id) {
         Some(handler) => handler,
         None => {
-            check_msg(msg.reply(ctx, "Not in a voice channel").await);
+            let msg = "I am not in a voice channel!";
+            ctx.send(
+                CreateReply::default().embed(error_embed(ctx, msg).await.unwrap())
+            ).await?;
             
             return Ok(());
         }
@@ -28,24 +35,20 @@ async fn deafen(ctx: &Context, msg: &Message) -> CommandResult {
 
     if handler.is_deaf() {
         if let Err(err) = handler.deafen(false).await {
-            check_msg(
-                msg.channel_id
-                    .say(&ctx.http, format!("Failed: {:?}", err))
-                    .await,
-            );
+            fail(ctx, err.to_string()).await.unwrap();
         }
 
-        check_msg(msg.channel_id.say(&ctx.http, "Undeafened").await);
+        ctx.send(
+            CreateReply::default().embed(embed(ctx, "Undeafened!", "", "").await.unwrap())
+        ).await?;
     } else {
         if let Err(err) = handler.deafen(true).await {  
-            check_msg(
-                msg.channel_id
-                    .say(&ctx.http, format!("Failed: {:?}", err))
-                    .await,
-            );
+            fail(ctx, err.to_string()).await.unwrap();
         }
        
-        check_msg(msg.channel_id.say(&ctx.http, "Deafened").await);
+        ctx.send(
+            CreateReply::default().embed(embed(ctx, "Deafened!", "", "").await.unwrap())
+        ).await?;
     }
 
     Ok(())

src/commands/music/join.rs

@@ -1,29 +1,36 @@
-use serenity::framework::standard::macros::command;
-use serenity::framework::standard::CommandResult;
-use serenity::model::prelude::*;
-use serenity::prelude::*;
-use songbird::events::TrackEvent;
+use crate::{commands::embeds::{error_embed, embed}, Context, Error};
+use poise::CreateReply;
+use songbird::TrackEvent;
+use crate::commands::music::notifier::TrackErrorNotifier;
 
-use crate::commands::{misc::check_msg, music::misc::TrackErrorNotifier};
-
-#[command]
-#[only_in(guilds)]
-async fn join(ctx: &Context, msg: &Message) -> CommandResult {
-    let guild_id = msg.guild_id.unwrap();
-    let channel_id = msg.guild(&ctx.cache).unwrap().voice_states.get(&msg.author.id).and_then(|voice_state| voice_state.channel_id);
+/// Joins your voice channel
+#[poise::command(
+    prefix_command,
+    slash_command,
+    category = "Music"
+)]
+pub async fn join(
+    ctx: Context<'_>
+) -> Result<(), Error> {
+    let guild_id = ctx.guild_id().unwrap();
+    let channel_id = ctx.guild().unwrap()
+        .voice_states.get(&ctx.author().id)
+        .and_then(|voice_state| voice_state.channel_id);
 
     let connect_to = match channel_id {
         Some(channel) => channel,
         None => {
-            check_msg(msg.reply(ctx, "Not in a voice channel").await);
-
+            let msg = "I am not in a voice channel!";
+            ctx.send(
+                CreateReply::default().embed(error_embed(ctx, msg).await.unwrap())
+            ).await?;
             return Ok(());
         }
     };
 
-    let manager = songbird::get(ctx)
+    let manager = songbird::get(&ctx.serenity_context())
         .await
-        .expect("Songbird Voice placed at init")
+        .expect("Songbird client placed at init")
         .clone();
 
     if let Ok(handler_lock) = manager.join(guild_id, connect_to).await {
@@ -31,5 +38,9 @@ async fn join(ctx: &Context, msg: &Message) -> CommandResult {
         handler.add_global_event(TrackEvent::Error.into(), TrackErrorNotifier);
     }
 
+    ctx.send(
+        CreateReply::default().embed(embed(ctx, "Joined!", "Hi there!", "").await.unwrap())
+    ).await?;
+
     Ok(())
 }

src/commands/music/leave.rs

@@ -1,36 +1,40 @@
-use serenity::framework::standard::macros::command;
-use serenity::framework::standard::CommandResult;
-use serenity::model::prelude::*;
-use serenity::prelude::*;
+use poise::CreateReply;
+use crate::{commands::embeds::{error_embed, fail, embed}, Context, Error};
 
-use crate::commands::misc::check_msg;
+/// Leaves the voice channel; \
+/// aliases: leave, qa!
+#[poise::command(
+    prefix_command,
+    slash_command,
+    aliases("leave", "qa!"),
+    category = "Music"
+)]
+pub async fn leave(
+    ctx: Context<'_>
+) -> Result<(), Error> {
+    let guild_id = ctx.guild_id().unwrap();
 
-#[command]
-#[aliases(q)]
-#[only_in(guilds)]
-async fn leave(ctx: &Context, msg: &Message) -> CommandResult {
-    let guild_id = msg.guild_id.unwrap();
-
-    let manager = songbird::get(ctx)
+    let manager = songbird::get(&ctx.serenity_context())
         .await
-        .expect("Client placed in at init")
+        .expect("Songbird client placed at init")
         .clone();
 
-    let has_handler = manager.get(guild_id).is_some();
+    if !manager.get(guild_id).is_some() {
+        let msg = "I am not in a voice channel!";
+        ctx.send(
+            CreateReply::default().embed(error_embed(ctx, msg).await.unwrap())
+        ).await?;
 
-    if has_handler {
-        if let Err(err) = manager.remove(guild_id).await {
-            check_msg(
-                msg.channel_id
-                    .say(&ctx.http, format!("Failed: {:?}", err))
-                    .await,
-            );
-        }
-
-        check_msg(msg.channel_id.say(&ctx.http, "Left voice channel").await);
-    } else {
-        check_msg(msg.reply(ctx, "Not in a voice channel").await);
+        return Ok(())
     }
 
+    if let Err(err) = manager.remove(guild_id).await { 
+        fail(ctx, err.to_string()).await.unwrap();
+    }
+
+    ctx.send(
+        CreateReply::default().embed(embed(ctx, "Left!", "I left the voice channel", "").await.unwrap())
+    ).await?;
+
     Ok(())
 }

src/commands/music/mod.rs

@@ -1,9 +0,0 @@
-pub mod deafen;
-pub mod join;
-pub mod leave;
-pub mod misc;
-pub mod mute;
-pub mod play;
-pub mod queue;
-pub mod skip;
-pub mod stop;

src/commands/music/mute.rs

@@ -1,25 +1,31 @@
-use serenity::framework::standard::macros::command;
-use serenity::framework::standard::CommandResult;
-use serenity::model::prelude::*;
-use serenity::prelude::*;
+use crate::{commands::embeds::{error_embed, embed, fail}, Context, Error};
+use poise::CreateReply;
 
-use crate::commands::misc::check_msg;
+/// Mutes itself while in a voice channel; \
+/// aliases: mute, unmute, shhh
+#[poise::command(
+    prefix_command, 
+    slash_command,
+    aliases("shhh", "unmute"),
+    category = "Music"
+)]
+pub async fn mute(
+    ctx: Context<'_>
+) -> Result<(), Error> {
+    let guild_id = ctx.guild_id().unwrap();
 
-#[command]
-#[only_in(guilds)]
-async fn mute(ctx: &Context, msg: &Message) -> CommandResult {
-    let guild_id = msg.guild_id.unwrap();
-
-    let manager = songbird::get(ctx)
+    let manager = songbird::get(&ctx.serenity_context())
         .await
-        .expect("Client placed at init")
+        .expect("Songbird client placed at init")
         .clone();
 
     let handler_lock = match manager.get(guild_id) {
         Some(handler) => handler,
         None => { 
-            check_msg(msg.reply(ctx, "Not in a voice channel").await);
-
+            let msg = "I am not in a voice channel!";
+            ctx.send(
+                CreateReply::default().embed(error_embed(ctx, msg).await.unwrap())
+            ).await?;
             return Ok(());
         }
     };
@@ -27,25 +33,21 @@ async fn mute(ctx: &Context, msg: &Message) -> CommandResult {
     let mut handler = handler_lock.lock().await;
 
     if handler.is_mute() { 
-        if let Err(e) = handler.mute(false).await {
-            check_msg(
-                msg.channel_id
-                    .say(&ctx.http, format!("failed: {:?}", e))
-                    .await,
-            );
+        if let Err(err) = handler.mute(false).await {
+            fail(ctx, err.to_string()).await.unwrap();
         }
  
-        check_msg(msg.channel_id.say(&ctx.http, "Unmuted").await);
+        ctx.send(
+            CreateReply::default().embed(embed(ctx, "Unmuted!", "", "").await.unwrap())
+        ).await?;
     } else {
         if let Err(err) = handler.mute(true).await {
-            check_msg(
-                msg.channel_id
-                    .say(&ctx.http, format!("Failed: {:?}", err))
-                    .await,
-            );
+            fail(ctx, err.to_string()).await.unwrap();
         }
  
-        check_msg(msg.channel_id.say(&ctx.http, "Muted").await);
+        ctx.send(
+            CreateReply::default().embed(embed(ctx, "Muted!", "", "").await.unwrap())
+        ).await?;
     }
 
     Ok(())

src/commands/music/pause.rs

@@ -0,0 +1,36 @@
+use crate::{commands::embeds::{error_embed, embed}, Context, Error};
+use poise::CreateReply;
+
+/// Pauses the currently playing song
+#[poise::command(
+    prefix_command,
+    slash_command,
+    category = "Music"
+)]
+pub async fn pause(
+    ctx: Context<'_>
+) -> Result<(), Error> {
+    let guild_id = ctx.guild_id().unwrap();
+
+    let manager = songbird::get(&ctx.serenity_context())
+        .await
+        .expect("Songbird client placed at init")
+        .clone();
+
+    if let Some(handler_lock) = manager.get(guild_id) {
+        let handler = handler_lock.lock().await;
+        let queue = handler.queue();
+        let _ = queue.pause();
+        
+        ctx.send(
+            CreateReply::default().embed(embed(ctx, "Paused!", "Currently playing song is now paused!", "").await.unwrap())
+        ).await?;
+    } else { 
+        let msg = "I am not in a voice channel!";
+        ctx.send(
+            CreateReply::default().embed(error_embed(ctx, msg).await.unwrap())
+        ).await?;
+    }
+
+    Ok(())
+}

src/commands/music/play.rs

@@ -1,58 +1,66 @@
-use serenity::framework::standard::macros::command;
-use serenity::framework::standard::{Args, CommandResult};
-use serenity::model::prelude::*;
-use serenity::prelude::*;
-use reqwest::Client as HttpClient;
+use crate::{commands::embeds::error_embed, Context, Error};
+
+use fancy_regex::Regex;
+use regex::Regex as Regex_Classic;
+use std::process::Command;
+use std::time::Duration;
+use poise::CreateReply;
+use poise::serenity_prelude::CreateEmbed;
+use poise::serenity_prelude::Colour;
+use poise::serenity_prelude::model::Timestamp;
+use serenity::builder::CreateEmbedAuthor;
+use serenity::builder::CreateEmbedFooter;
+use songbird::input::AuxMetadata;
 use songbird::input::{Compose, YoutubeDl};
 use songbird::events::TrackEvent;
 
-use crate::commands::{misc::check_msg, music::misc::TrackErrorNotifier};
+use crate::commands::music::notifier::TrackErrorNotifier;
+use crate::http::HttpKey;
 
-pub struct HttpKey;
+/// Plays a song; \
+/// you can search by query or paste an url; \
+/// aliases: play, p, enqueue
+#[poise::command(
+    prefix_command, 
+    slash_command, 
+    aliases("p", "enqueue"),
+    category = "Music"
+)]
+pub async fn play(
+    ctx: Context<'_>, 
+    #[description = "Provide a query or an url"] #[rest] mut song: String,
+) -> Result<(), Error> {
+    let regex_spotify = Regex::new(r"https?:\/\/(?:embed\.|open\.)(?:spotify\.com\/)(?:track\/|\?uri=spotify:track:)((\w|-)+)(?:(?=\?)(?:[?&]foo=(\d*)(?=[&#]|$)|(?![?&]foo=)[^#])+)?(?=#|$)").unwrap();
+    let regex_youtube = Regex_Classic::new(r#""url": "(https://www.youtube.com/watch\?v=[A-Za-z0-9]{11})""#).unwrap();
+    let regex_youtube_playlist = Regex::new(r"^((?:https?:)\/\/)?((?:www|m)\.)?((?:youtube\.com)).*(youtu.be\/|list=)([^#&?]*).*").unwrap();   
 
-impl TypeMapKey for HttpKey {
-    type Value = HttpClient;
-}
+    let is_playlist = regex_youtube_playlist.is_match(&song).unwrap();
+    let is_spotify = regex_spotify.is_match(&song).unwrap();
+    let is_query = !song.starts_with("http");
 
-#[command]
-#[aliases(p)]
-#[only_in(guilds)]
-async fn play(ctx: &Context, msg: &Message, mut args: Args) -> CommandResult {
-    let url = match args.single::<String>() {
-        Ok(url) => url,
-        Err(_) => {
-            check_msg(
-                msg.channel_id
-                    .say(&ctx.http, "Must provide a URL to a video or audio")
-                    .await,
-            );
-
-            return Ok(());
-        }
-    };
-
-    let is_search = !url.starts_with("http");
-
-    let guild_id = msg.guild_id.unwrap();
-    let channel_id = msg.guild(&ctx.cache).unwrap().voice_states.get(&msg.author.id).and_then(|voice_state| voice_state.channel_id);
+    let guild_id = ctx.guild_id().unwrap();
+    let channel_id = ctx.guild().unwrap().voice_states.get(&ctx.author().id).and_then(|voice_state| voice_state.channel_id);
 
     let connect_to = match channel_id {
         Some(channel) => channel,
         None => { 
-            check_msg(msg.reply(ctx, "Not in a voice channel").await);
+            let msg = "I am not in a voice channel!";
+            ctx.send(
+                CreateReply::default().embed(error_embed(ctx, msg).await.unwrap())
+            ).await?;
 
             return Ok(());
         }
     };
 
     let http_client = {
-        let data = ctx.data.read().await;
+        let data = ctx.serenity_context().data.read().await;
         data.get::<HttpKey>()
             .cloned()
             .expect("Guaranteed to exist in the typemap.")
     };
 
-    let manager = songbird::get(ctx)
+    let manager = songbird::get(&ctx.serenity_context())
         .await
         .expect("Songbird Voice placed at init")
         .clone();
@@ -60,29 +68,100 @@ async fn play(ctx: &Context, msg: &Message, mut args: Args) -> CommandResult {
     if let Ok(handler_lock) = manager.join(guild_id, connect_to).await {
         let mut handler = handler_lock.lock().await;
 
-        if let Err(err) = handler.deafen(true).await {println!("Failed to deafen: {:?}", err)};
         handler.add_global_event(TrackEvent::Error.into(), TrackErrorNotifier);
 
-        let mut src = if is_search {
-            println!("ytsearch:{}", url);
-            YoutubeDl::new_ytdl_like("yt-dlp", http_client, format!("ytsearch:{}", args.clone().message()))
+        if is_playlist {
+            let raw_list = Command::new("yt-dlp")
+                .args(["-j", "--flat-playlist", &song])
+                .output()
+                .expect("failed to execute process")
+            .stdout;
+
+            let list = String::from_utf8(raw_list.clone()).expect("Invalid UTF-8");
+
+            let urls: Vec<String> = regex_youtube.captures_iter(&list).map(|capture| capture[1].to_string()).collect();
+            
+            let mut sources: Vec<YoutubeDl> = vec![];
+
+            for url in urls {
+                let src = YoutubeDl::new_ytdl_like("yt-dlp", http_client.clone(), url);
+                let _ = handler.enqueue_input(src.clone().into()).await;
+                sources.push(src);
+            }
+
+            let embed = generate_playlist_embed(ctx, sources).await;
+            let response = CreateReply::default().embed(embed.unwrap());
+            ctx.send(response).await?;
         } else {
-            YoutubeDl::new_ytdl_like("yt-dlp", http_client, url)
-        };
+            if is_spotify {
+                let exec = format!("node ./src/spotify --url {}", song);
+                let query = Command::new("sh").arg("-c").arg(exec).output().expect("failed to execute process").stdout;
+                let query_str = String::from_utf8(query.clone()).expect("Invalid UTF-8");
+                song = format!("ytsearch:{}", query_str.to_string());
 
-        let _ = handler.enqueue_input(src.clone().into()).await;
+            }
 
-        let metadata = src.aux_metadata().await.unwrap();
-        // let _ = handler.play_input(src.clone().into());
+            if is_query {
+                song = format!("ytsearch:{}", song);
+            }
 
-        check_msg(msg.channel_id.say(&ctx.http, format!("Playing song: {}", metadata.title.unwrap())).await);
-    } else {
-        check_msg(
-            msg.channel_id
-                .say(&ctx.http, "Not in a voice channel to play in")
-                .await,
-        );
+            let src = YoutubeDl::new_ytdl_like("yt-dlp", http_client, song); 
+            let _ = handler.enqueue_input(src.clone().into()).await;
+        
+            let embed = generate_embed(ctx, src).await;
+            let response = CreateReply::default().embed(embed.unwrap());
+            ctx.send(response).await?;
+        }
     }
 
     Ok(())
 }
+
+async fn generate_embed(ctx: Context<'_>, src: YoutubeDl) -> Result<CreateEmbed, Error> {
+    let metadata = src.clone().aux_metadata().await.unwrap();
+    let AuxMetadata {title, thumbnail, source_url, artist, duration, ..} = metadata;
+    let timestamp = Timestamp::now();
+    let duration_minutes = duration.unwrap_or(Duration::new(0, 0)).clone().as_secs() / 60;
+    let duration_seconds = duration.unwrap_or(Duration::new(0, 0)).clone().as_secs() % 60;
+
+    let embed = CreateEmbed::default()
+        .author(CreateEmbedAuthor::new("Track enqueued").icon_url(ctx.author().clone().face()))
+        .colour(Colour::from_rgb(255, 58, 97))
+        .title(title.unwrap())
+        .url(source_url.unwrap())
+        .thumbnail(thumbnail.unwrap_or(ctx.cache().current_user().face()))
+        .field("Artist", artist.unwrap_or("Unknown Artist".to_string()), true)
+        .field("Duration", format!("{:02}:{:02}", duration_minutes, duration_seconds), true)
+        .field("DJ", ctx.author().name.clone(), true)
+        .timestamp(timestamp)
+        .footer(CreateEmbedFooter::new(ctx.cache().current_user().name.to_string()).icon_url(ctx.cache().current_user().face()));
+
+    Ok(embed)
+}
+
+async fn generate_playlist_embed(ctx: Context<'_>, sources: Vec<YoutubeDl>) -> Result<CreateEmbed, Error> {
+    let src = sources.get(0).unwrap();
+    
+    let metadata = src.clone().aux_metadata().await.unwrap();
+    let AuxMetadata {title, thumbnail, source_url, artist, duration, ..} = metadata;
+    let timestamp = Timestamp::now();
+    let duration_minutes = duration.unwrap_or(Duration::new(0, 0)).clone().as_secs() / 60;
+    let duration_seconds = duration.unwrap_or(Duration::new(0, 0)).clone().as_secs() % 60;
+    
+    let description = format!("Enqueued tracks: {}", sources.len() - 1);
+
+    let embed = CreateEmbed::default()
+        .author(CreateEmbedAuthor::new("Playlist enqueued").icon_url(ctx.author().clone().face()))
+        .colour(Colour::from_rgb(255, 58, 97))
+        .title(title.unwrap())
+        .url(source_url.unwrap())
+        .thumbnail(thumbnail.unwrap_or(ctx.cache().current_user().face()))
+        .field("Artist", artist.unwrap_or("Unknown Artist".to_string()), true)
+        .field("Duration", format!("{:02}:{:02}", duration_minutes, duration_seconds), true)
+        .field("DJ", ctx.author().name.clone(), true)
+        .description(description)
+        .timestamp(timestamp)
+        .footer(CreateEmbedFooter::new(ctx.cache().current_user().name.to_string()).icon_url(ctx.cache().current_user().face()));
+
+    Ok(embed)
+}

src/commands/music/queue.rs

@@ -1,18 +1,22 @@
-use serenity::framework::standard::macros::command;
-use serenity::framework::standard::CommandResult;
-use serenity::model::prelude::*;
-use serenity::prelude::*;
+use crate::{commands::embeds::error_embed, Context, Error};
+use poise::CreateReply;
 
-use crate::commands::misc::check_msg;
+/// Shows next tracks in queue; \
+/// aliases: queue, q
+#[poise::command(
+    prefix_command, 
+    slash_command,
+    aliases("q"),
+    category = "Music" 
+)]
+pub async fn queue(
+    ctx: Context<'_>
+) -> Result<(), Error> {
+    let guild_id = ctx.guild_id().unwrap();
 
-#[command]
-#[only_in(guilds)]
-async fn queue(ctx: &Context, msg: &Message) -> CommandResult {
-    let guild_id = msg.guild_id.unwrap();
-    
-    let manager = songbird::get(ctx)
+    let manager = songbird::get(&ctx.serenity_context())
         .await
-        .expect("Client placed at init")
+        .expect("Songbird client placed at init")
         .clone();
 
     if let Some(handler_lock) = manager.get(guild_id) {
@@ -27,21 +31,16 @@ async fn queue(ctx: &Context, msg: &Message) -> CommandResult {
                 song.uuid(),
                 "Artist"
                 // song.metadata().artist.clone().unwrap_or_else(|| String::from("Unknown"))
-        ));
+            ));
         }
 
-        check_msg(
-            msg.channel_id
-                .say(&ctx.http, queue_res)
-                .await,
-        );
+        ctx.say(queue_res).await?;
 
     } else {
-        check_msg(
-            msg.channel_id
-                .say(&ctx.http, "Not in a voice channel!")
-                .await,
-        );
+        let msg = "I am not in a voice channel!";
+        ctx.send(
+            CreateReply::default().embed(error_embed(ctx, msg).await.unwrap())
+        ).await?;
     }
 
     Ok(())

src/commands/music/repeat.rs

@@ -0,0 +1,70 @@
+use crate::{commands::embeds::{error_embed, embed}, Context, Error};
+use poise::CreateReply;
+use songbird::tracks::LoopState;
+
+/// Loops currently playing song provided amount of times; \
+/// aliases: repeat, loop, while, for
+#[poise::command(
+    prefix_command, 
+    slash_command,
+    aliases("loop", "while", "for"),
+    category = "Music"
+)]
+pub async fn repeat(
+    ctx: Context<'_>, 
+    #[description = "How many times"] #[rest] times: usize
+) -> Result<(), Error> {
+    let guild_id = ctx.guild_id().unwrap();
+
+    let manager = songbird::get(&ctx.serenity_context())
+        .await
+        .expect("Songbird client placed at init")
+        .clone();
+
+
+    if let Some(handler_lock) = manager.get(guild_id) {
+        let handler = handler_lock.lock().await;
+        let queue = handler.queue();
+
+        let track = queue.current().unwrap().get_info().await;
+        let is_looped = track.unwrap().loops;
+
+        match is_looped {
+            LoopState::Infinite => {
+                let _ = queue.current().unwrap().disable_loop();
+
+                ctx.send(
+                    CreateReply::default().embed(embed(ctx, "Song Unlooped!", "", "").await.unwrap())
+                ).await?;
+            }
+            LoopState::Finite(_) => { 
+                if times == 0 {
+                    let _ = queue.current().unwrap().disable_loop();
+
+                    ctx.send(
+                        CreateReply::default().embed(embed(ctx, "Song Unlooped!", "", "").await.unwrap())
+                    ).await?;
+                }
+                else if times < 100 {
+                    let _ = queue.current().unwrap().loop_for(times);
+                    ctx.send(
+                        CreateReply::default().embed(embed(ctx, &format!("Song looped {} times!", times), "You definitelly love this song!", "").await.unwrap())
+                    ).await?;
+                }
+                else {
+                    let _ = queue.current().unwrap().enable_loop();
+                    ctx.send(
+                        CreateReply::default().embed(embed(ctx, "Song looped forever!", "A very long time!", "").await.unwrap())
+                    ).await?;
+                }
+            }
+        }
+    } else { 
+        let msg = "I am not in a voice channel!";
+        ctx.send(
+            CreateReply::default().embed(error_embed(ctx, msg).await.unwrap())
+        ).await?;
+    }
+
+    Ok(())
+}

src/commands/music/resume.rs

@@ -0,0 +1,37 @@
+use crate::{commands::embeds::{error_embed, embed}, Context, Error};
+use poise::CreateReply;
+
+/// Resumes currently paused song
+#[poise::command(
+    prefix_command,
+    slash_command,
+    category = "Music"
+)]
+pub async fn resume(
+    ctx: Context<'_>
+) -> Result<(), Error> {
+    let guild_id = ctx.guild_id().unwrap();
+
+    let manager = songbird::get(&ctx.serenity_context())
+        .await
+        .expect("Songbird client placed at init")
+        .clone();
+
+    if let Some(handler_lock) = manager.get(guild_id) {
+        let handler = handler_lock.lock().await;
+        let queue = handler.queue();
+        let _ = queue.resume();
+
+        ctx.say(format!("Song resumed.")).await?;
+        ctx.send(
+            CreateReply::default().embed(embed(ctx, "Resumed!", "Currently paused song is now resumed!", "").await.unwrap())
+        ).await?;
+    } else {
+        let msg = "I am not in a voice channel!";
+        ctx.send(
+            CreateReply::default().embed(error_embed(ctx, msg).await.unwrap())
+        ).await?;
+    }
+
+    Ok(())
+}

src/commands/music/skip.rs

@@ -1,18 +1,20 @@
-use serenity::framework::standard::macros::command;
-use serenity::framework::standard::CommandResult;
-use serenity::model::prelude::*;
-use serenity::prelude::*;
+use crate::{commands::embeds::{error_embed, embed}, Context, Error};
+use poise::CreateReply;
 
-use crate::commands::misc::check_msg;
+/// Skips the currently playing song
+#[poise::command(
+    prefix_command,
+    slash_command,
+    category = "Music"
+)]
+pub async fn skip(
+    ctx: Context<'_>
+) -> Result<(), Error> {
+    let guild_id = ctx.guild_id().unwrap();
 
-#[command]
-#[only_in(guilds)]
-async fn skip(ctx: &Context, msg: &Message) -> CommandResult {
-    let guild_id = msg.guild_id.unwrap();
-
-    let manager = songbird::get(ctx)
+    let manager = songbird::get(&ctx.serenity_context())
         .await
-        .expect("Client placed at init")
+        .expect("Songbird client placed at init")
         .clone();
 
     if let Some(handler_lock) = manager.get(guild_id) {
@@ -20,20 +22,14 @@ async fn skip(ctx: &Context, msg: &Message) -> CommandResult {
         let queue = handler.queue();
         let _ = queue.skip();
 
-        check_msg(
-            msg.channel_id
-                .say(
-                    &ctx.http,
-                    format!("Song skipped: {} in queue.", queue.len()),
-                )
-                .await,
-        );
+        ctx.send(
+            CreateReply::default().embed(embed(ctx, "Skipped!", "Next song: {song}", &format!("Songs left in queue: {}", queue.len())).await.unwrap())
+        ).await?;
     } else {
-        check_msg(
-            msg.channel_id
-                .say(&ctx.http, "Not in a voice channel to play in")
-                .await,
-        );
+        let msg = "I am not in a voice channel!";
+        ctx.send(
+            CreateReply::default().embed(error_embed(ctx, msg).await.unwrap())
+        ).await?;
     }
 
     Ok(())

src/commands/music/stop.rs

@@ -1,40 +1,37 @@
-use serenity::framework::standard::macros::command;
-use serenity::framework::standard::CommandResult;
-use serenity::model::prelude::*;
-use serenity::prelude::*;
+use crate::{commands::embeds::{error_embed, embed}, Context, Error};
+use poise::CreateReply;
 
-use crate::commands::misc::check_msg;
+/// Stops playback and destroys the queue; \
+/// aliases: stop, end
+#[poise::command(
+    prefix_command, 
+    slash_command,
+    aliases("end"),
+    category = "Music"
+)]
+pub async fn stop(
+    ctx: Context<'_>
+) -> Result<(), Error> {
+    let guild_id = ctx.guild_id().unwrap();
     
-#[command]
-#[only_in(guilds)]
-async fn stop(ctx: &Context, msg: &Message) -> CommandResult {
-    let guild_id = msg.guild_id.unwrap();
-    
-    let manager = songbird::get(ctx)
+    let manager = songbird::get(&ctx.serenity_context())
         .await
-        .expect("Client placed at init")
+        .expect("Songbird client placed at init")
         .clone();
 
     if let Some(handler_lock) = manager.get(guild_id) {
-        let mut handler = handler_lock.lock().await;
+        let handler = handler_lock.lock().await;
         let queue = handler.queue();
         queue.stop();
 
-        if let Err(e) = handler.deafen(false).await {
-            check_msg(
-                msg.channel_id
-                    .say(&ctx.http, format!("Failed: {:?}", e))
-                    .await,
-            );
-        }
-
-        check_msg(msg.channel_id.say(&ctx.http, "Playback stopped!").await);
+        ctx.send(
+            CreateReply::default().embed(embed(ctx, "Stopped!", "Playback stopped!", "Queue destroyed! Bot will stay and chill with you in a vc").await.unwrap())
+        ).await?;
     } else {     
-        check_msg(
-            msg.channel_id
-                .say(&ctx.http, "Not in a voice channel!")
-                .await,
-        );
+        let msg = "I am not in a voice channel!";
+        ctx.send(
+            CreateReply::default().embed(error_embed(ctx, msg).await.unwrap())
+        ).await?;
     }
     
     Ok(())

src/commands/tools.rs

@@ -0,0 +1,7 @@
+pub mod ping;
+pub mod register;
+pub mod help;
+
+pub use ping::ping;
+pub use register::register;
+pub use help::help;

src/commands/tools/help.rs

@@ -0,0 +1,23 @@
+use crate::{Context, Error};
+
+/// Prints this help message; aliases: help, huh, welp
+#[poise::command(
+    prefix_command,
+    slash_command,
+    track_edits,
+    aliases("huh", "welp"),
+    category = "Help"
+)]
+pub async fn help(
+    ctx: Context<'_>,
+    #[description = "Specific command to show help about"] command: Option<String>,
+) -> Result<(), Error> {
+    let config = poise::builtins::HelpConfiguration {
+        extra_text_at_bottom: "\
+Use /help command for more info on a command.
+You can edit you message to the bot and the bot will edit its response.",
+        ..Default::default()
+    };
+    poise::builtins::help(ctx, command.as_deref(), config).await?;
+    Ok(())
+}

src/commands/tools/mod.rs

@@ -1 +0,0 @@
-pub mod ping;

src/commands/tools/ping.rs

@@ -1,17 +1,23 @@
+use crate::{Context, Error};
 use std::time::SystemTime;
 
-use serenity::{all::Message, client::Context, framework::standard::{macros::command, CommandResult}};
+/// Pings you backs with a response time
+#[poise::command(
+    prefix_command,
+    slash_command,
+    category = "Tools"
+)]
+pub async fn ping(
+    ctx: Context<'_>
+) -> Result<(), Error> {
+    let system_now = SystemTime::now()
+        .duration_since(SystemTime::UNIX_EPOCH)
+        .unwrap().as_millis() as i64;
 
-use crate::commands::misc::check_msg;
+    let message_now = ctx.created_at().timestamp_millis();
 
-#[command]
-async fn ping(ctx: &Context, msg: &Message) -> CommandResult {
-    let system_now = SystemTime::now().duration_since(SystemTime::UNIX_EPOCH).unwrap().as_millis() as i64;
-    let message_now = msg.timestamp.timestamp_millis();
-
-    // println!("System Time: {} ||| Message Time: {}", system_now, message_now);
-
-    check_msg(msg.reply(ctx, format!("Pong! (latency: {} ms)", system_now - message_now)).await);
+    let response = format!("Pong! (latency: {} ms)", system_now - message_now);
+    ctx.say(response).await?;
 
     Ok(())
 }

src/commands/tools/register.rs

@@ -0,0 +1,13 @@
+use crate::{Context, Error};
+
+#[poise::command(
+    prefix_command,
+    hide_in_help,
+    owners_only
+)]
+pub async fn register(
+    ctx: Context<'_>
+) -> Result<(), Error> {
+    poise::builtins::register_application_commands_buttons(ctx).await?;
+    Ok(())
+}

src/http.rs

@@ -0,0 +1,8 @@
+use reqwest::Client as HttpClient;
+use poise::serenity_prelude::prelude::TypeMapKey;
+
+pub struct HttpKey;
+
+impl TypeMapKey for HttpKey {
+    type Value = HttpClient;
+}

src/main.rs

@@ -1,86 +1,125 @@
-use serenity::gateway::ActivityData;
-use serenity::model::prelude::Message;
+use std::sync::Arc;
+use std::time::Duration;
+use tracing::{info, warn, error};
+use poise::serenity_prelude::{self as serenity, ActivityData};
 use songbird::SerenityInit;
-
 use reqwest::Client as HttpClient;
 
-use serenity::client::Context;
-
-use serenity::{
-    async_trait,
-    client::{Client, EventHandler},
-    framework::{
-        standard::{macros::group, macros::hook, Configuration},
-        StandardFramework,
-    },
-    model::gateway::Ready,
-    prelude::GatewayIntents,
-};
-
-use tracing::info;
-
 mod commands;
+mod http;
 
-// music management commands
-use crate::commands::music::deafen::*;
-use crate::commands::music::join::*;
-use crate::commands::music::leave::*;
-use crate::commands::music::mute::*;
-use crate::commands::music::play::*;
-use crate::commands::music::queue::*;
-use crate::commands::music::skip::*;
-use crate::commands::music::stop::*;
+use crate::commands::kashi;
+use crate::commands::music;
+use crate::commands::tools;
+use crate::http::HttpKey;
 
-// tools
-use crate::commands::tools::ping::*;
+type Error = Box<dyn std::error::Error + Send + Sync>;
+type Context<'a> = poise::Context<'a, Data, Error>;
 
-// kashi
-use crate::commands::kashi::kashi::*;
+pub struct Data;
 
-struct Handler;
-
-#[async_trait]
-impl EventHandler for Handler {
-    async fn ready(&self, ctx: Context, ready: Ready) {
-        info!("{} [{}] connected successfully!", ready.user.name, ready.user.id);
-        let prefix = std::env::var("PREFIX").expect("Environment variable `PREFIX` not found!");
-        ctx.set_activity(Some(ActivityData::listening(prefix + "help")));
+async fn on_error(error: poise::FrameworkError<'_, Data, Error>) {
+    match error {
+        poise::FrameworkError::Setup { error, .. } => panic!("Failed to start bot {:?}", error),
+        poise::FrameworkError::Command { error, ctx, .. } => {
+            warn!("Error in command `{}`: {:?}", ctx.command().name, error);
+        }
+        error => {
+            if let Err(e) = poise::builtins::on_error(error).await {
+                error!("Error while handling error: {}", e)
+            }
+        }
     }
 }
 
-#[hook]
-async fn before(_: &Context, msg: &Message, command_name: &str) -> bool {
-    info!(
-        "Received command [{}] from user [{}]",
-        command_name, msg.author.name
-    );
-    true
-}
-
-#[group]
-#[commands(
-    join, deafen, leave, mute, play, ping, kashi, queue, stop, skip
-)]
-struct General;
-
 #[tokio::main]
 async fn main() {
-    dotenv::dotenv().expect("Failed to load .env file.");
     tracing_subscriber::fmt::init();
+    dotenv::dotenv().expect("Failed to load .env file.");
 
-    let token =
-        std::env::var("DISCORD_TOKEN").expect("Environment variable `DISCORD_TOKEN` not found!");
+    let token = std::env::var("DISCORD_TOKEN").expect("Environment variable `DISCORD_TOKEN` not found!");
     let prefix = std::env::var("PREFIX").expect("Environment variable `PREFIX` not found!");
 
-    let framework = StandardFramework::new().before(before).group(&GENERAL_GROUP);
-    framework.configure(Configuration::new().prefix(prefix));
+    let commands = vec![
+        kashi::kashi(),
+        music::deafen(),
+        music::join(),
+        music::leave(),
+        music::repeat(),
+        music::mute(),
+        music::pause(),
+        music::play(),
+        music::queue(),
+        music::resume(),
+        music::skip(),
+        music::stop(),
+        tools::ping(),
+        tools::register(),
+        tools::help(),
+    ];
 
-    let intents = GatewayIntents::non_privileged() | GatewayIntents::MESSAGE_CONTENT;
+    let options = poise::FrameworkOptions {
+        commands,
+        prefix_options: poise::PrefixFrameworkOptions {
+            prefix: Some(prefix.to_string().into()),
+            edit_tracker: Some(Arc::new(poise::EditTracker::for_timespan(
+                Duration::from_secs(3600),
+            ))),
+            additional_prefixes: vec![],
+            ..Default::default()
+        },
 
-    let mut client = Client::builder(&token, intents)
+        on_error: |error| Box::pin(on_error(error)),
+
+        pre_command: |ctx| {
+            Box::pin(async move {
+                info!("Executing command {}...", ctx.command().qualified_name);
+            })
+        },
+
+        post_command: |ctx| {
+            Box::pin(async move {
+                info!("Executed command {}!", ctx.command().qualified_name);
+            })
+        },
+
+        command_check: Some(|ctx| {
+            Box::pin(async move {
+                if ctx.author().id == 123456789 {
+                    return Ok(false);
+                }
+                Ok(true)
+            })
+        }),
+
+        skip_checks_for_owners: false,
+        event_handler: |_ctx, event, _framework, _data| {
+            Box::pin(async move {
+                info!("Got an event in event handler: {:?}", event.snake_case_name());
+                Ok(())
+            })
+        },
+        ..Default::default()
+    };
+
+    let framework = poise::Framework::builder()
+        .setup(move |ctx, ready, _framework| {
+            Box::pin(async move {
+                info!("{} [{}] connected successfully!", ready.user.name, ready.user.id);
+                ctx.set_activity(Some(ActivityData::listening(prefix + "help")));
+                // poise::builtins::register_globally(ctx, &framework.options().commands).await?;
+
+                Ok(Data {})
+            })
+        })
+        .options(options)
+        .build();
+
+    let intents = serenity::GatewayIntents::non_privileged() | serenity::GatewayIntents::MESSAGE_CONTENT;
+
+    let mut client = serenity::ClientBuilder::new(token, intents)
         .framework(framework)
         .register_songbird()
-        .event_handler(Handler)
         .type_map_insert::<HttpKey>(HttpClient::new())
         .await
         .expect("Error creating client");
@@ -89,9 +128,9 @@ async fn main() {
         let _ = client
             .start()
             .await
-            .map_err(|why| println!("Client ended: {:?}", why));
+            .map_err(|why| error!("Client ended: {:?}", why));
     });
 
     let _signal_err = tokio::signal::ctrl_c().await;
-    println!("Recieved Ctrl-C, shutting down.");
+    warn!("Recieved Ctrl-C, shutting down.");
 }