일단 저장

TODO 추가가
TODO리스트는 늘어만 간다..
2025-10-26 09:55:14 +00:00 · 2025-08-28 20:46:37 +09:00 · 2025-03-09 17:29:09 +09:00 · 2025-03-09 17:27:42 +09:00 · 2025-03-07 17:25:58 +09:00 · 2025-03-07 17:19:58 +09:00
64 changed files with 1777 additions and 1183 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -1,7 +1,7 @@
 build/*
-out/
-.vs/
-.idea/
-tmp/
-config.json
-Music
+Temp/
+Music
+*.json
+yt-dlp
+ffmpeg
+password
--- a/.idea/.gitignore
+++ b/.idea/.gitignore
@@ -0,0 +1,10 @@
+# Default ignored files
+/shelf/
+/workspace.xml
+# Editor-based HTTP Client requests
+/httpRequests/
+# Environment-dependent path to Maven home directory
+/mavenHomeManager.xml
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml
--- a/.idea/BumbleCee.iml
+++ b/.idea/BumbleCee.iml
@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="JAVA_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$" />
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>
--- a/.idea/misc.xml
+++ b/.idea/misc.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectRootManager" version="2" languageLevel="JDK_23" default="true" project-jdk-name="openjdk-23" project-jdk-type="JavaSDK">
+    <output url="file://$PROJECT_DIR$/out" />
+  </component>
+</project>
--- a/.idea/modules.xml
+++ b/.idea/modules.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/BumbleCee.iml" filepath="$PROJECT_DIR$/.idea/BumbleCee.iml" />
+    </modules>
+  </component>
+</project>
--- a/.idea/vcs.xml
+++ b/.idea/vcs.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="" vcs="Git" />
+  </component>
+</project>
--- a/.vscode/c_cpp_properties.json
+++ b/.vscode/c_cpp_properties.json
@@ -3,7 +3,8 @@
        {
            "name": "Linux",
            "includePath": [
-                "${workspaceFolder}/**"
+                "${workspaceFolder}/**",
+                "${workspaceFolder}/include"
            ],
            "defines": [
                "DDPP_CORO=on"
--- a/.vscode/launch.json
+++ b/.vscode/launch.json
@@ -5,7 +5,7 @@
            "name": "Debug",
            "type": "cppdbg",
            "request": "launch",
-            "program": "/home/happytanuki/BumbleCee/build/BumbleCee",
+            "program": "${workspaceFolder}/build/BumbleCee",
            "stopAtEntry": false,
            "cwd": "${workspaceFolder}",
            "environment": [],
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -1,80 +1,109 @@
 {
    "files.associations": {
-        "iostream": "cpp",
-        "any": "cpp",
-        "chrono": "cpp",
-        "codecvt": "cpp",
-        "compare": "cpp",
-        "condition_variable": "cpp",
-        "deque": "cpp",
-        "forward_list": "cpp",
-        "list": "cpp",
-        "string": "cpp",
-        "unordered_map": "cpp",
-        "vector": "cpp",
-        "exception": "cpp",
-        "functional": "cpp",
-        "iterator": "cpp",
-        "memory": "cpp",
-        "memory_resource": "cpp",
-        "optional": "cpp",
-        "string_view": "cpp",
-        "random": "cpp",
-        "*.tcc": "cpp",
-        "fstream": "cpp",
-        "future": "cpp",
-        "initializer_list": "cpp",
-        "istream": "cpp",
-        "mutex": "cpp",
-        "new": "cpp",
-        "ostream": "cpp",
-        "ranges": "cpp",
-        "semaphore": "cpp",
-        "shared_mutex": "cpp",
+        "iosfwd": "cpp",
        "sstream": "cpp",
-        "stdexcept": "cpp",
-        "stop_token": "cpp",
-        "streambuf": "cpp",
-        "system_error": "cpp",
-        "thread": "cpp",
-        "tuple": "cpp",
-        "type_traits": "cpp",
-        "typeinfo": "cpp",
-        "valarray": "cpp",
-        "variant": "cpp",
-        "array": "cpp",
-        "atomic": "cpp",
-        "bit": "cpp",
        "cctype": "cpp",
-        "charconv": "cpp",
        "clocale": "cpp",
        "cmath": "cpp",
-        "concepts": "cpp",
-        "coroutine": "cpp",
        "csignal": "cpp",
        "cstdarg": "cpp",
        "cstddef": "cpp",
-        "cstdint": "cpp",
        "cstdio": "cpp",
        "cstdlib": "cpp",
        "cstring": "cpp",
        "ctime": "cpp",
        "cwchar": "cpp",
        "cwctype": "cpp",
-        "map": "cpp",
-        "algorithm": "cpp",
-        "numeric": "cpp",
-        "ratio": "cpp",
-        "utility": "cpp",
-        "iomanip": "cpp",
-        "iosfwd": "cpp",
-        "limits": "cpp",
-        "numbers": "cpp",
-        "cinttypes": "cpp",
+        "any": "cpp",
+        "array": "cpp",
+        "atomic": "cpp",
+        "strstream": "cpp",
+        "bit": "cpp",
+        "*.tcc": "cpp",
        "bitset": "cpp",
+        "charconv": "cpp",
+        "chrono": "cpp",
+        "codecvt": "cpp",
+        "compare": "cpp",
+        "complex": "cpp",
+        "concepts": "cpp",
+        "condition_variable": "cpp",
+        "coroutine": "cpp",
+        "cstdint": "cpp",
+        "deque": "cpp",
+        "forward_list": "cpp",
+        "list": "cpp",
+        "map": "cpp",
        "set": "cpp",
-        "regex": "cpp",
+        "string": "cpp",
+        "unordered_map": "cpp",
+        "vector": "cpp",
+        "exception": "cpp",
+        "algorithm": "cpp",
+        "functional": "cpp",
+        "iterator": "cpp",
+        "memory": "cpp",
+        "memory_resource": "cpp",
+        "numeric": "cpp",
+        "optional": "cpp",
+        "random": "cpp",
+        "ratio": "cpp",
+        "source_location": "cpp",
+        "string_view": "cpp",
+        "system_error": "cpp",
+        "tuple": "cpp",
+        "type_traits": "cpp",
+        "utility": "cpp",
+        "fstream": "cpp",
+        "future": "cpp",
+        "initializer_list": "cpp",
+        "iomanip": "cpp",
+        "iostream": "cpp",
+        "istream": "cpp",
+        "limits": "cpp",
+        "mutex": "cpp",
+        "new": "cpp",
+        "numbers": "cpp",
+        "ostream": "cpp",
+        "ranges": "cpp",
+        "semaphore": "cpp",
+        "shared_mutex": "cpp",
+        "stdexcept": "cpp",
+        "stop_token": "cpp",
+        "streambuf": "cpp",
+        "thread": "cpp",
+        "cinttypes": "cpp",
+        "typeindex": "cpp",
+        "typeinfo": "cpp",
+        "valarray": "cpp",
+        "variant": "cpp",
+        "*.ipp": "cpp",
        "format": "cpp",
-        "span": "cpp"
+        "span": "cpp",
+        "__bit_reference": "cpp",
+        "__bits": "cpp",
+        "__config": "cpp",
+        "__debug": "cpp",
+        "__errc": "cpp",
+        "__hash_table": "cpp",
+        "__locale": "cpp",
+        "__mutex_base": "cpp",
+        "__node_handle": "cpp",
+        "__nullptr": "cpp",
+        "__split_buffer": "cpp",
+        "__string": "cpp",
+        "__threading_support": "cpp",
+        "__tree": "cpp",
+        "__tuple": "cpp",
+        "ios": "cpp",
+        "locale": "cpp",
+        "queue": "cpp",
+        "hash_map": "cpp",
+        "hash_set": "cpp",
+        "regex": "cpp",
+        "stack": "cpp",
+        "__memory": "cpp",
+        "__verbose_abort": "cpp",
+        "print": "cpp"
    }
 }
--- a/.vscode/tasks.json
+++ b/.vscode/tasks.json
@@ -8,7 +8,7 @@
            "command": "make",
            "args": [],
            "options": {
-                "cwd": "/home/happytanuki/BumbleCee/build/"
+                "cwd": "${workspaceFolder}/build/"
            },
            "group": {
                "kind": "build",
@@ -24,7 +24,7 @@
                ".."
            ],
            "options": {
-                "cwd": "/home/happytanuki/BumbleCee/build/"
+                "cwd": "${workspaceFolder}/build/"
            },
            "group": {
                "kind": "build",
--- a/BuildDockerAndUpload.sh
+++ b/BuildDockerAndUpload.sh
@@ -0,0 +1,8 @@
+#!/bin/bash
+(
+    cd build
+    cmake .. && make
+)
+docker login -u happytanuki12 --password-stdin < password
+docker build --tag happytanuki12/bumblebee:latest .
+docker push happytanuki12/bumblebee:latest
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,38 +1,30 @@
 cmake_minimum_required (VERSION 3.6)

+INCLUDE_DIRECTORIES(include . ${Boost_INCLUDE_DIR})
+
 list(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake)
 set(BOT_NAME "BumbleCee")

 project(${BOT_NAME})
 aux_source_directory("src" coresrc)
+aux_source_directory("src/Audio" commands)
 aux_source_directory("src/Commands" commands)
-add_executable(${BOT_NAME} ${coresrc} ${commands})
-
-string(ASCII 27 Esc)
+aux_source_directory("src/Queue" settings)
+aux_source_directory("src/Settings" settings)
+aux_source_directory("src/Utils" settings)
+add_executable(${BOT_NAME} ${coresrc} ${commands} ${settings})

 set(CMAKE_POSITION_INDEPENDENT_CODE ON)
-
-set_target_properties(${BOT_NAME} PROPERTIES
-    CXX_STANDARD 20
-    CXX_STANDARD_REQUIRED ON
-)
-
-target_compile_definitions(${BOT_NAME} PUBLIC DPP_CORO)
-target_compile_features(${BOT_NAME} PUBLIC cxx_std_20)
+set(CMAKE_BUILD_TYPE Debug)
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)

 set(THREADS_PREFER_PTHREAD_FLAG TRUE)
+add_definitions( -DBOOST_ALL_NO_LIB )
+set( Boost_USE_STATIC_LIBS ON )
 find_package(Threads REQUIRED)
-find_package(DPP)
-if(APPLE)
-	if(CMAKE_APPLE_SILICON_PROCESSOR)
-		set(OPENSSL_ROOT_DIR "/opt/homebrew/opt/openssl")
-	else()
-		set(OPENSSL_ROOT_DIR "/usr/local/opt/openssl")
-	endif()
-	find_package(OpenSSL REQUIRED)
-else()
-	find_package(OpenSSL REQUIRED)
-endif()
+find_package(OpenSSL REQUIRED)
+find_package(Boost REQUIRED)

 target_include_directories(${BOT_NAME} PUBLIC
    ${CMAKE_CURRENT_SOURCE_DIR}/include
@@ -41,40 +33,14 @@ target_include_directories(${BOT_NAME} PUBLIC
 )

 target_link_libraries(${BOT_NAME}
-    dl
    dpp
    opus
+    ogg
    oggz
-    mariadbcpp
    ${CMAKE_THREAD_LIBS_INIT}
    ${OPENSSL_CRYPTO_LIBRARY} 
    ${OPENSSL_SSL_LIBRARY}
+    ${Boost_LIBRARIES}
 )

-if (DPP_FOUND)
-    target_link_libraries(${BOT_NAME} ${DPP_LIBRARIES})
-    target_include_directories(${BOT_NAME} PUBLIC ${DPP_INCLUDE_DIR})
-else()
-    message(WARNING "Could not find DPP install. Building from source instead.")
-    option(DPP_BUILD_TEST "" OFF)
-    include(FetchContent)
-
-    FetchContent_Declare(
-            libdpp
-            GIT_REPOSITORY https://github.com/brainboxdotcc/DPP.git
-            GIT_TAG master)
-
-    FetchContent_GetProperties(libdpp)
-    if(NOT libdpp_POPULATED)
-        FetchContent_Populate(libdpp)
-        target_include_directories(${BOT_NAME} PUBLIC
-            ${libdpp_SOURCE_DIR}/include
-        )
-        add_subdirectory(
-            ${libdpp_SOURCE_DIR}
-            ${libdpp_BINARY_DIR}
-            EXCLUDE_FROM_ALL)
-    endif()
-
-    target_link_libraries(${BOT_NAME} dpp)
-endif()
+link_directories(/usr/lib)
--- a/21
+++ b/21
@@ -0,0 +1,21 @@
+FROM debian:sid
+WORKDIR /
+RUN apt-get update && \
+    apt-get install -y curl libopus0 tini liboggz2 xz-utils ffmpeg python3 \
+        python3-pip python3-certifi python3-brotli python3-websockets python3-requests python3-mutagen && \
+    apt-get clean && \
+    rm -rf /var/lib/apt/lists/*
+RUN pip3 install --break-system-packages --no-cache-dir curl_cffi
+RUN pip3 install --break-system-packages --no-cache-dir pycryptodome
+RUN curl -Lo dpp.deb https://dl.dpp.dev/latest
+RUN curl -Lo dpp-legacy.deb https://github.com/brainboxdotcc/DPP/releases/download/v10.0.35/libdpp-10.0.35-linux-x64.deb
+RUN dpkg -i dpp.deb
+RUN dpkg -i dpp-legacy.deb
+RUN rm dpp.deb
+RUN curl -LO https://github.com/yt-dlp/yt-dlp/releases/latest/download/yt-dlp
+RUN chmod +x ./yt-dlp
+COPY ./build/BumbleCee /BumbleCee
+COPY ./streamOpus.sh /streamOpus.sh
+RUN chmod +x BumbleCee
+RUN chmod +x streamOpus.sh
+ENTRYPOINT ["/usr/bin/tini", "--", "./BumbleCee"]
--- a/README.md
+++ b/README.md
@@ -1,18 +1,25 @@

 # 이게 뭔가요?
+[![CodeFactor](https://www.codefactor.io/repository/github/happytanuki/bumblecee/badge)](https://www.codefactor.io/repository/github/happytanuki/bumblecee)
+
 C++ Dpp 라이브러리를 이용해서 개발된 간단한 디스코드 음악봇입니다!
 <div align="center">
  <a href="https://github.com/brainboxdotcc/DPP" alt="DPP"> <img src="DPP-markdown-logo.png" /> </a>
 </div>

+
 # 어떻게 써요?
 1. 실행파일 경로에 config.json 파일을 만들고 다음과 같이 입력하세요:
 ```
-{"token": "디스코드에서 발급받은 개인 봇 토큰"}
+{
+    "CLEAR_PREVIOUS_COMMAND": true,
+    "FFMPEG_CMD": "ffmpeg",
+    "LOGLEVEL": "debug",
+    "TOKEN": "발급받은 토큰",
+    "YTDLP_CMD": "./yt-dlp"
+}
 ```
-2. Music 디렉터리를 만드세요
-3. Music/Archive 파일을 만드세요
-4. 봇을 실행시키고 초대하셔서 사용하시면 됩니다.
+2. 봇을 초대하시고 사용하시면 됩니다.

 # 명령어
 ## /p
@@ -36,3 +43,6 @@ C++ Dpp 라이브러리를 이용해서 개발된 간단한 디스코드 음악
 음성 채팅을 떠납니다.
 사용법:
 /l
+
+# docker
+happytanuki12/bumblebee:latest
--- a/Temp/CurMusic
+++ b/Temp/CurMusic
@@ -1,49 +0,0 @@
-W8UNLOOogU4
-749DIRUHhNY
-o75PUTiHEXU
-pS5d77DQHOI
-65xX7zyr-fA
-2eNEQ0cQtkI
-UgS7vgquBvo
-IFCDLIKSArs
-yPdqcADl5U4
-6aEglYFwjrA
-n8F-E5f-cos
-1zwaZkOXXqw
-vjSrFwbwu6w
-vwZAqxL8rgs
-zOkIe3RcTCs
-mzVbYUBo8_Y
-rgNdeflYdYw
-CjaM8qWzssk
-kNDbaYEp0tU
-smObR_8q5UQ
-27NtZwyog7g
-vHfAjfKVMew
-b_bjtIeqIR4
-YTaX7BWlk9g
-BBj3SCImk_A
-Yb_IhN4TGp8
-m-crWZHLi0
-4ciZKNHSoUs
-4tlUwgtgdZA
-oPGtAA2HaS8
-dLlD-dZNACM
-9LW9DpmhrPE
-pMTRBNMX2mw
-Kt451YtL-Vs
-tc0FL9JROGQ
-NinLIDs9qmU
-KMdTrqzEI0I
-HbXaUmWaU5Q
-xtFAmapbTbY
-B7luArOaIl0
-HMqhXxH5-RQ
-mQFokUq9LYs
-HyL8Z94W6es
-prAnOH-q_Bo
-LRPGqNeav_M
-M4-XU0a2hf0
-BryspbM6s3E
-JVTS3fyoAEQ
-KAaUyVJoNAE
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -0,0 +1,7 @@
+services:
+  bumblebee:
+    image: happytanuki12/bumblebee:latest
+    container_name: BumbleBee
+    volumes:
+      - ./config.json:/config.json
+    restart: unless-stopped
--- a/include/Audio/MusicPlayManager.hpp
+++ b/include/Audio/MusicPlayManager.hpp
@@ -0,0 +1,67 @@
+#pragma once
+#include <dpp/dpp.h>
+#include <Queue/MusicQueue.hpp>
+#include <condition_variable>
+
+namespace bumbleBee {
+class MusicPlayManager {
+public:
+    MusicPlayManager(std::shared_ptr<dpp::cluster> cluster, std::vector<dpp::snowflake> GIDs) :
+        cluster(cluster), GIDs(GIDs) {
+        queueMap = std::unordered_map<dpp::snowflake, std::shared_ptr<MusicQueue>>();
+        queueEmptyMutex = std::unordered_map<dpp::snowflake, std::shared_ptr<std::mutex>>();
+
+        cluster->on_voice_ready([this](const dpp::voice_ready_t &event){on_voice_ready(event);});
+        cluster->on_voice_track_marker([this](const dpp::voice_track_marker_t &event){on_voice_track_marker(event);});
+        cluster->on_voice_client_disconnect([this](const dpp::voice_client_disconnect_t& event){on_voice_client_disconnect(event);});
+
+        for (auto GID : GIDs) {
+            queueMap[GID] = std::make_shared<MusicQueue>();
+            queueEmptyMutex[GID] = std::make_shared<std::mutex>();
+        }
+    }
+
+    /**
+     * @brief voice_ready 이벤트 인지시 콜백되는 함수
+     * @param event const dpp::voice_ready_t&
+    **/
+    void on_voice_ready(const dpp::voice_ready_t& event);
+    /**
+     * @brief voice_track_marker 이벤트 인지시 콜백되는 함수
+     * @param event const dpp::voice_track_marker_t&
+    **/
+    void on_voice_track_marker(const dpp::voice_track_marker_t& event);
+    /**
+     * @brief voice_client_disconnect 이벤트 인지시 콜백되는 함수
+     * @param event const dpp::voice_client_disconnect_t&
+    **/
+    void on_voice_client_disconnect(const dpp::voice_client_disconnect_t& event);
+
+    void play(dpp::discord_voice_client* client);
+
+    void queue_music(const dpp::snowflake guildId, const std::shared_ptr<MusicQueueElement> music);
+
+    void clear(const dpp::snowflake guildId);
+    std::shared_ptr<MusicQueueElement> remove(const dpp::snowflake guildId, dpp::discord_voice_client* client, int index);
+    int size(const dpp::snowflake guildId);
+
+    void setRepeat(const dpp::snowflake guildId, const bool value);
+    bool getRepeat(const dpp::snowflake guildId);
+
+    std::pair<std::shared_ptr<std::list<std::shared_ptr<MusicQueueElement>>>, std::list<std::shared_ptr<MusicQueueElement>>::iterator> getQueue(const dpp::snowflake guildId);
+    MusicQueueElement getNowPlaying(const dpp::snowflake guildId);
+
+    std::condition_variable queuedCondition;
+    
+private:
+    std::shared_ptr<dpp::cluster> cluster;
+
+    std::vector<dpp::snowflake> GIDs;
+    /// @brief 음악 큐
+    std::unordered_map<dpp::snowflake, std::shared_ptr<MusicQueue>> queueMap;
+
+    std::unordered_map<dpp::snowflake, std::shared_ptr<std::mutex>> queueEmptyMutex;
+
+    void send_audio_to_voice(std::shared_ptr<bumbleBee::MusicQueueElement> music, dpp::discord_voice_client* client);
+};
+}
--- a/include/Audio/MusicPlayerThreadManager.hpp
+++ b/include/Audio/MusicPlayerThreadManager.hpp
@@ -0,0 +1,18 @@
+#pragma once
+#include <memory>
+#include <dpp/dpp.h>
+#include <Queue/MusicQueueElement.hpp>
+#include "Utils/ThreadPool.hpp"
+
+namespace bumbleBee {
+class ThreadManager : public ThreadPool<dpp::snowflake, int, int> {
+public:
+    bool addMusic(std::shared_ptr<bumbleBee::MusicQueueElement> music, dpp::discord_voice_client* client);
+    void stopSending(dpp::snowflake gid);
+private:
+    // GID, 쓰레드
+    std::unordered_map<dpp::snowflake, std::thread> threadPool;
+    // GID, 쓰레드 종료
+    std::unordered_map<dpp::snowflake, bool> terminating;
+};
+}
--- a/include/Bot.hpp
+++ b/include/Bot.hpp
@@ -1,27 +0,0 @@
-#pragma once
-#include <Commands/CommandType.hpp>
-#include <dpp/dpp.h>
-#include <memory>
-#include <mariadb/conncpp.hpp>
-
-class IBot {
-public:
-    IBot(std::string token, int clusterCount = 0);
-    virtual void start();
-    virtual void onCommand(const dpp::slashcommand_t &event);
-    virtual void onReady(const dpp::ready_t &event);
-
-    std::shared_ptr<dpp::cluster> botCluster;
-    std::vector<std::shared_ptr<commands::ICommand>> commandsArray;
-
-    std::function<void(const dpp::log_t&)> logger() {
-        return [&](const dpp::log_t& event){
-            if (event.severity >= dpp::ll_error)
-                std::cerr << "[" << dpp::utility::current_date_time() << "] " << dpp::utility::loglevel(event.severity) << ": " << event.message << std::endl;
-            else if (event.severity - logLevel >= 0)
-                std::clog << "[" << dpp::utility::current_date_time() << "] " << dpp::utility::loglevel(event.severity) << ": " << event.message << std::endl;
-        };
-    };
-
-    dpp::loglevel logLevel = dpp::ll_debug;
-};
--- a/include/BumbleBee.hpp
+++ b/include/BumbleBee.hpp
@@ -0,0 +1,54 @@
+#pragma once
+#ifndef _BUMBLEBEE_HPP_
+#define _BUMBLEBEE_HPP_
+#include <dpp/dpp.h>
+#include <dpp/nlohmann/json.hpp>
+#include <memory>
+#include <Commands/BumbleBeeCommand.hpp>
+
+namespace bumbleBee {
+/**
+ * @file BumbleBee.hpp
+ * @brief 메인 봇 클래스
+**/
+class BumbleBee {
+public:
+    /**
+     * @brief 생성자
+    **/
+    BumbleBee();
+    /**
+     * @brief 파괴자
+     * @details BumbleBee의 모든 Property를 책임지고 파괴합니다
+    **/
+    ~BumbleBee() {}
+
+    /**
+     * @brief 봇 시작
+    **/
+    void start();
+
+    /**
+     * @brief slashcommand 이벤트 인지시 콜백되는 함수
+     * @param event const dpp::slashcommand_t&
+    **/
+    void on_slashcommand(const dpp::slashcommand_t& event);
+    /**
+     * @brief ready 이벤트 인지시 콜백되는 함수
+     * @param event const dpp::ready_t&
+    **/
+    void on_ready(const dpp::ready_t& event);
+
+    /// @brief DPP 기본 클러스터 객체
+    std::shared_ptr<dpp::cluster> cluster;
+    /// @brief guild id 배열
+    std::vector<dpp::snowflake> GIDs;
+    
+private:
+    /// @brief Command 목록
+    std::unordered_map<std::string, std::shared_ptr<commands::ICommand>> commands;
+    /// @brief voiceclient 관련 event 처리기 <guild id, 각 길드별 MusicPlayManager 인스턴스>
+    std::shared_ptr<MusicPlayManager> musicManager;
+};
+}
+#endif
--- a/include/BumbleCeepp.hpp
+++ b/include/BumbleCeepp.hpp
@@ -1,38 +0,0 @@
-#pragma once
-#include <string>
-#include <Bot.hpp>
-#include <dpp/dpp.h>
-#include <memory>
-#include <unordered_map>
-#include <FQueueElement.hpp>
-
-class BumbleCeepp : public IBot {
-public:
-    BumbleCeepp(std::string token, std::string DBURL, std::string DBID, std::string DBPassword, int clusterCount = 0);
-    ~BumbleCeepp();
-
-    void enqueueMusic(FQueueElement item, dpp::discord_voice_client* vc);
-    std::shared_ptr<dpp::embed> findEmbed(std::string musicID);
-    bool insertDB(
-        std::string webpage_url,
-        std::string title,
-        std::string uploader,
-        std::string id,
-        std::string thumbnail,
-        time_t duration);
-    std::shared_ptr<dpp::embed> makeEmbed(
-        std::string webpage_url,
-        std::string title,
-        std::string uploader,
-        std::string id,
-        std::string thumbnail,
-        time_t duration);
-
-    bool repeat;
-    std::string nowPlayingMusic;
-
-private:
-    //<guild_id, queueMutex> 쌍임.
-    std::unordered_map<dpp::snowflake, std::mutex> enqueuingMutexMap;
-    sql::Connection* conn;
-};
--- a/include/Commands/BumbleBeeCommand.hpp
+++ b/include/Commands/BumbleBeeCommand.hpp
@@ -0,0 +1,69 @@
+#pragma once
+#include <dpp/dpp.h>
+#include <Audio/MusicPlayManager.hpp>
+#include <functional>
+
+namespace bumbleBee::commands {
+class ICommand : public dpp::slashcommand {
+public:
+    /**
+     * @brief 기본 생성자
+     * @param botID 봇 아이디
+     * @param manager 음악재생 매니저
+    **/
+    ICommand(dpp::snowflake botID, std::shared_ptr<MusicPlayManager> manager) {
+        this->botID = botID;
+        this->musicManager = manager;
+    }
+    /**
+     * @brief 명령어 호출 시에 콜백될 메소드
+     * @param event dpp::slashcommand_t
+    **/
+    virtual void execute(const dpp::slashcommand_t &event){};
+
+    /// @brief 명령어 별명
+    std::vector<std::string> aliases;
+
+private:
+    /// @brief 봇 ID
+    dpp::snowflake botID;
+    
+protected:
+    /// @brief 음악재생 매니저
+    std::shared_ptr<MusicPlayManager> musicManager;
+
+protected:
+    /// @brief concrete class에서 구현해야 하는 init 이벤트트
+    virtual void init() = 0;
+};
+}
+
+/**
+ * @brief 명령어 인자가 없는 명령어의 boilerplate 대체 매크로
+ * @param name 명령어 이름 및 클래스명
+ * @param description 명령어 설명
+**/
+#define _DECLARE_BUMBLEBEE_COMMAND(CLASS, NAME, DESCRIPTION) \
+namespace bumbleBee::commands { \
+class CLASS : public ICommand { \
+public: \
+    CLASS (dpp::snowflake botID, std::shared_ptr<MusicPlayManager> manager) \
+    : ICommand(botID, manager) { \
+        name = #NAME; \
+        description = DESCRIPTION; \
+        init(); \
+    } \
+    void execute(const dpp::slashcommand_t &event) override; \
+    \
+protected: \
+    void init() override; \
+}; \
+}
+
+_DECLARE_BUMBLEBEE_COMMAND(Delete,  d,          "큐의 해당하는 번호의 노래를 지웁니다")
+_DECLARE_BUMBLEBEE_COMMAND(Leave,   l,          "음성 채팅방을 떠납니다")
+_DECLARE_BUMBLEBEE_COMMAND(Play,    p,          "노래 재생")
+_DECLARE_BUMBLEBEE_COMMAND(Queue,   q,          "노래 예약 큐를 확인합니다")
+_DECLARE_BUMBLEBEE_COMMAND(Repeat,  r,          "반복을 켜거나 끕니다")
+_DECLARE_BUMBLEBEE_COMMAND(Skip,    s,          "현재 재생중인 곡을 스킵합니다")
+_DECLARE_BUMBLEBEE_COMMAND(Shuffle, shuffle,    "큐를 섞습니다")
--- a/include/Commands/CommandType.hpp
+++ b/include/Commands/CommandType.hpp
@@ -1,22 +0,0 @@
-#pragma once
-#include <dpp/dpp.h>
-#include <vector>
-#include <list>
-
-class BumbleCeepp;
-
-namespace commands {
-class ICommand {
-public:
-    ICommand(dpp::snowflake botID, BumbleCeepp* Bot)
-    {
-        this->botID = botID;
-        this->Bot = Bot;
-    }
-    virtual void operator()(const dpp::slashcommand_t &event) = 0;
-
-    std::vector<dpp::slashcommand> commandObjectVector;
-    dpp::snowflake botID;
-    BumbleCeepp* Bot;
-};
-}
--- a/include/Commands/Commands.hpp
+++ b/include/Commands/Commands.hpp
@@ -1,7 +0,0 @@
-#pragma once
-#include <Commands/Play.hpp>
-#include <Commands/Repeat.hpp>
-#include <Commands/Queue.hpp>
-#include <Commands/Skip.hpp>
-#include <Commands/Leave.hpp>
-#include <Commands/Delete.hpp>
--- a/include/Commands/Delete.hpp
+++ b/include/Commands/Delete.hpp
@@ -1,13 +0,0 @@
-#pragma once
-#include <Commands/CommandType.hpp>
-#include <BumbleCeepp.hpp>
-#include <memory>
-
-namespace commands {
-class Delete : public ICommand {
-public:
-    Delete(dpp::snowflake botID, BumbleCeepp* Bot);
-
-    void operator()(const dpp::slashcommand_t& event);
-};
-}
--- a/include/Commands/Leave.hpp
+++ b/include/Commands/Leave.hpp
@@ -1,13 +0,0 @@
-#pragma once
-#include <Commands/CommandType.hpp>
-#include <BumbleCeepp.hpp>
-#include <memory>
-
-namespace commands {
-class Leave : public ICommand {
-public:
-    Leave(dpp::snowflake botID, BumbleCeepp* Bot);
-
-    void operator()(const dpp::slashcommand_t& event);
-};
-}
--- a/include/Commands/Play.hpp
+++ b/include/Commands/Play.hpp
@@ -1,14 +0,0 @@
-#pragma once
-#include <Commands/CommandType.hpp>
-#include <BumbleCeepp.hpp>
-#include <memory>
-
-namespace commands {
-class Play : public ICommand {
-public:
-    Play(dpp::snowflake botID, BumbleCeepp* Bot);
-
-    void operator()(const dpp::slashcommand_t& event);
-    void on_DLCompleted(std::string musicID, dpp::embed embed, const dpp::slashcommand_t& event);
-};
-}
--- a/include/Commands/Queue.hpp
+++ b/include/Commands/Queue.hpp
@@ -1,13 +0,0 @@
-#pragma once
-#include <Commands/CommandType.hpp>
-#include <BumbleCeepp.hpp>
-#include <memory>
-
-namespace commands {
-class Queue : public ICommand {
-public:
-    Queue(dpp::snowflake botID, BumbleCeepp* Bot);
-
-    void operator()(const dpp::slashcommand_t& event);
-};
-}
--- a/include/Commands/Repeat.hpp
+++ b/include/Commands/Repeat.hpp
@@ -1,13 +0,0 @@
-#pragma once
-#include <Commands/CommandType.hpp>
-#include <BumbleCeepp.hpp>
-#include <memory>
-
-namespace commands {
-class Repeat : public ICommand {
-public:
-    Repeat(dpp::snowflake botID, BumbleCeepp* Bot);
-
-    void operator()(const dpp::slashcommand_t& event);
-};
-}
--- a/include/Commands/Skip.hpp
+++ b/include/Commands/Skip.hpp
@@ -1,13 +0,0 @@
-#pragma once
-#include <Commands/CommandType.hpp>
-#include <BumbleCeepp.hpp>
-#include <memory>
-
-namespace commands {
-class Skip : public ICommand {
-public:
-    Skip(dpp::snowflake botID, BumbleCeepp* Bot);
-
-    void operator()(const dpp::slashcommand_t& event);
-};
-}
--- a/include/FQueueElement.hpp
+++ b/include/FQueueElement.hpp
@@ -1,9 +0,0 @@
-#pragma once
-#include <string>
-#include <dpp/dpp.h>
-
-struct FQueueElement {
-    std::string ID;
-    dpp::embed embed;
-    bool skip = false;
-};
--- a/include/Queue/MusicQueue.hpp
+++ b/include/Queue/MusicQueue.hpp
@@ -0,0 +1,51 @@
+#pragma once
+#include <memory>
+#include <functional>
+#include <condition_variable>
+#include <list>
+#include <dpp/dpp.h>
+#include <Queue/MusicQueueElement.hpp>
+
+namespace bumbleBee {
+
+class MusicQueue {
+public:
+    MusicQueue() {
+        queue = std::list<std::shared_ptr<MusicQueueElement>>();
+        currentPlayingPosition = queue.begin();
+        repeat = true;
+    }
+    void
+        enqueue(std::shared_ptr<MusicQueueElement> Element);
+    std::shared_ptr<MusicQueueElement>
+        dequeue();
+    std::list<std::shared_ptr<MusicQueueElement>>::iterator
+        findById(std::string id);
+    std::list<std::shared_ptr<MusicQueueElement>>::iterator
+        findByIndex(int index);
+    std::shared_ptr<MusicQueueElement>
+        nowplaying();
+    std::list<std::shared_ptr<MusicQueueElement>>::iterator
+        next_music();
+    std::shared_ptr<MusicQueueElement>
+        jump_to_index(int idx);
+    void
+        clear();
+    std::shared_ptr<MusicQueueElement>
+        erase(std::list<std::shared_ptr<MusicQueueElement>>::iterator it);
+    std::pair<std::shared_ptr<std::list<std::shared_ptr<MusicQueueElement>>>, std::list<std::shared_ptr<MusicQueueElement>>::iterator>
+        getQueueCopy();
+    int
+        size();
+    std::list<std::shared_ptr<MusicQueueElement>>::iterator
+        end();
+
+    bool repeat;
+
+    std::list<std::shared_ptr<MusicQueueElement>>::iterator currentPlayingPosition;
+
+private:
+    std::list<std::shared_ptr<MusicQueueElement>> queue;
+    std::mutex queueMutex;
+};
+}
--- a/include/Queue/MusicQueueElement.hpp
+++ b/include/Queue/MusicQueueElement.hpp
@@ -0,0 +1,20 @@
+#pragma once
+#include <dpp/dpp.h>
+
+namespace bumbleBee {
+
+class MusicQueueElement {
+public:
+    MusicQueueElement(
+        std::string id,
+        std::string query,
+        dpp::user issuingUser,
+        dpp::embed embed) :
+        id(id), query(query), issuingUser(issuingUser), embed(embed) {}
+
+    const std::string id;
+    const std::string query;
+    const dpp::user issuingUser;
+    const dpp::embed embed;
+};
+}
--- a/include/Settings/SettingsManager.hpp
+++ b/include/Settings/SettingsManager.hpp
@@ -0,0 +1,34 @@
+#pragma once
+#include <dpp/dpp.h>
+
+#define _DECLARE_DEFAULT_ACCESSER_STATIC_VARIABLE(type, name, Name)\
+private:\
+    static type name;\
+public:\
+    static type get##Name() {return name;}\
+    static void set##Name(const type& value) {name = value; saveToFile();}
+
+namespace bumbleBee {
+/// @brief 모든 설정은 이 객체를 통해 스태틱하게 제공됨.
+class SettingsManager {
+    /// @brief 봇 토큰
+    _DECLARE_DEFAULT_ACCESSER_STATIC_VARIABLE(std::string, TOKEN, TOKEN)
+    /// @brief yt-dlp 실행 명령어
+    _DECLARE_DEFAULT_ACCESSER_STATIC_VARIABLE(std::string, YTDLP_CMD, YTDLP_CMD)
+    /// @brief ffmpeg 실행 명령어
+    _DECLARE_DEFAULT_ACCESSER_STATIC_VARIABLE(std::string, FFMPEG_CMD, FFMPEG_CMD)
+    /// @brief 로그레벨
+    _DECLARE_DEFAULT_ACCESSER_STATIC_VARIABLE(dpp::loglevel, LOGLEVEL, LOGLEVEL)
+    /// @brief 이전에 있던 명령을 지우고 등록할지 선택합니다.
+    _DECLARE_DEFAULT_ACCESSER_STATIC_VARIABLE(bool, REGISTER_COMMAND, REGISTER_COMMAND)
+public:
+    /// @brief 설정 로드하기, 설정은 이 load()를 부르기 전까지는 적절하지 못한 값을 가지고 있음.
+    /// @return 로드 성공 시 true, 실패 시 false 반환.
+    static bool load();
+    /// @brief 설정 변경사항 저장
+    static void saveToFile();
+    /// @brief 토큰이 유효한지 체크합니다.
+    /// @return 유효한 토큰이면 true, 아니면 false를 반환합니다.
+    static bool validateToken();
+};
+}
--- a/include/Utils/AsyncDownloadManager.hpp
+++ b/include/Utils/AsyncDownloadManager.hpp
@@ -0,0 +1,56 @@
+#pragma once
+#include <queue>
+#include <string>
+#include <thread>
+#include <condition_variable>
+#include <dpp/dpp.h>
+#include <Queue/MusicQueue.hpp>
+
+namespace bumbleBee {
+/// @brief 싱글톤 멀티스레딩 다운로드 매니저
+class [[deprecated]] AsyncDownloadManager {
+public:
+    static AsyncDownloadManager& getInstance(int worker_count, std::weak_ptr<dpp::cluster> weak_cluster) {
+        static AsyncDownloadManager dl(worker_count);
+        dl.weak_cluster = weak_cluster;
+        return dl;
+    }
+    void enqueue(std::pair<std::string, dpp::message> query) {
+        std::thread th(&bumbleBee::AsyncDownloadManager::enqueueAsyncDL, this, query);
+        th.detach();
+    }
+    void stop() {
+        auto cluster = weak_cluster.lock();
+        cluster->log(dpp::ll_info, "AsyncDownloadManager stop/destructor called.");
+        terminate = true;
+        dlQueueCondition.notify_all();
+
+        for (auto& t : worker_thread) {
+            t.join();
+        }
+    }
+
+    ~AsyncDownloadManager(){
+        stop();
+    }
+
+private:
+    AsyncDownloadManager(int worker_count){
+        worker_thread.reserve(worker_count);
+        terminate = false;
+        for (int i=0; i<worker_count; i++) {
+            worker_thread.emplace_back([this](){this->downloadWorker();});
+        }
+    }
+    
+    void enqueueAsyncDL(std::pair<std::string, dpp::message> query);
+    void downloadWorker();
+
+    std::queue<std::pair<std::string, dpp::message>> downloadQueue;
+    std::condition_variable dlQueueCondition;
+    std::mutex dlQueueMutex;
+    std::weak_ptr<dpp::cluster> weak_cluster;
+    std::vector<std::thread> worker_thread;
+    bool terminate;
+};
+}
--- a/include/Utils/ConsoleUtils.hpp
+++ b/include/Utils/ConsoleUtils.hpp
@@ -0,0 +1,46 @@
+#pragma once
+#include <iostream>
+#include <sstream>
+#include <queue>
+#include <regex>
+#include <boost/process.hpp>
+
+namespace bumbleBee {
+class ConsoleUtils {
+public:
+    /** 
+     * @brief 명령어를 쉘에서 실행하고 결과를 EOF 전까지 읽어 \n을 구분자로 토큰화하여 반환합니다
+     * @param cmd 실행할 명령
+     * @param args 아규먼트
+     * @return std::queue<std::string> tokens
+     */
+    static std::queue<std::string> safe_execute_command(const std::string& cmd, const std::vector<std::string>& args) {
+        std::queue<std::string> tokens;
+        try {
+            boost::process::ipstream output;  // 명령의 출력을 받을 스트림
+            boost::process::child c(cmd, boost::process::args(args), boost::process::std_out > output);
+
+            std::string line;
+            while (!output.eof() && std::getline(output, line))
+                tokens.push(line);
+
+            c.wait();  // 프로세스가 종료될 때까지 대기
+            return tokens;
+        } catch (const std::exception& e) {
+            return tokens;
+        }
+    }
+    /** 
+     * @brief 명령어를 쉘에서 실행하고 결과를 파이프로 연결하여 반환합니다
+     * @param cmd 실행할 명령
+     * @param args 아규먼트
+     * @return FILE* fd
+     */
+    static FILE* safe_open_pipe(const std::string& cmd, const std::vector<std::string>& args) {
+        boost::process::pipe pipe;
+        boost::process::child c(cmd, boost::process::args(args), boost::process::std_out > pipe);
+
+        return fdopen(pipe.native_source(), "r");
+    }
+};
+}
--- a/include/Utils/QueuedMusicListEmbedProvider.hpp
+++ b/include/Utils/QueuedMusicListEmbedProvider.hpp
@@ -0,0 +1,77 @@
+#pragma once
+#include <dpp/dpp.h>
+#include <Queue/MusicQueueElement.hpp>
+#include <cmath>
+
+namespace bumbleBee {
+class QueuedMusicListEmbedProvider {
+public:
+    static std::queue<dpp::embed> makeEmbed(std::shared_ptr<std::list<std::shared_ptr<MusicQueueElement>>> queue, std::list<std::shared_ptr<MusicQueueElement>>::iterator np, bool repeat) {
+        std::queue<dpp::embed> returnValue;
+        std::list<std::shared_ptr<MusicQueueElement>>::iterator it = queue->begin();
+        if (queue->size() == 0) {
+            dpp::embed embed = makeEmbedPart(queue, np, repeat, it);
+            returnValue.push(embed);
+            return returnValue;
+        }
+        for (int i = 0; i < std::ceil(queue->size() / 5.0) && it != queue->end(); i++) {
+            dpp::embed embed = makeEmbedPart(queue, np, repeat, it);
+            returnValue.push(embed);
+        }
+        return returnValue;
+    }
+    
+private:
+    static dpp::embed makeEmbedPart(
+        std::shared_ptr<std::list<std::shared_ptr<MusicQueueElement>>> queue,
+        std::list<std::shared_ptr<MusicQueueElement>>::iterator np,
+        bool repeat,
+        std::list<std::shared_ptr<MusicQueueElement>>::iterator &startIter) {
+        dpp::embed embed = dpp::embed()
+            .set_color(dpp::colors::sti_blue);
+
+        if (queue->begin() == queue->end()) {
+            embed
+                .set_title("큐가 비었습니다!")
+                .set_timestamp(time(0));
+
+            if (repeat)
+                embed.add_field(":repeat:","");
+
+            return embed;
+        }
+
+        int startIndex = std::distance(queue->begin(), startIter) + 1;
+        int index = startIndex;
+
+        for (; (index < startIndex + 5) && startIter != queue->end() && index < queue->size()+1; startIter++, index++) { //iter로 순회하면 왠지 모르게 이상한 값을 읽을 때가 있음 이유는 나도 몰?루
+            if (*startIter == *np)
+                embed.add_field (
+                    "np",
+                    "",
+                    true
+                );
+            else
+                embed.add_field (
+                    std::to_string(index),
+                    "",
+                    true
+                );
+            embed.add_field (
+                (*startIter)->embed.title,
+                (*startIter)->embed.description,
+                true
+            )
+            .add_field("","");
+        }
+
+        if (startIter == queue->end() || index >= queue->size()+1) {
+            embed.set_timestamp(time(0));
+            if (repeat)
+                embed.add_field(":repeat:","");
+        }
+
+        return embed;
+    }
+};
+}
--- a/include/Utils/ThreadPool.hpp
+++ b/include/Utils/ThreadPool.hpp
@@ -0,0 +1,25 @@
+#pragma once
+#include <memory>
+#include <functional>
+#include <thread>
+#include <condition_variable>
+#include <queue>
+
+namespace bumbleBee {
+template <typename FuncRet, typename FuncParam>
+class ThreadPool {
+public:
+    ThreadPool() = delete;
+    ThreadPool(std::int32_t threadCount);
+
+    std::thread::id execute(std::function<FuncRet(FuncParam)> function);
+    void gracefullStop(std::thread::id thread);
+    void gracefullAllStop();
+private:
+    std::mutex mutex_;
+    std::condition_variable condition_;
+    std::int32_t threadCount_;
+    std::vector<std::thread> threadPool_;
+    std::unordered_map<std::thread, std::bool> terminating_;
+};
+}
--- a/include/Utils/VersionsCheckUtils.hpp
+++ b/include/Utils/VersionsCheckUtils.hpp
@@ -0,0 +1,83 @@
+#pragma once
+#include <dpp/dpp.h>
+#include "ConsoleUtils.hpp"
+#include "../Settings/SettingsManager.hpp"
+
+namespace bumbleBee {
+class VersionsCheckUtils {
+public:
+    static bool isThereCMD(std::shared_ptr<dpp::cluster> cluster, std::string cmd) {
+        if (ConsoleUtils::safe_execute_command("/usr/bin/which", {cmd}).size() == 0) {
+            cluster->log(dpp::ll_error, cmd + " is unavaliable. unresolable error please install " + cmd);
+            return false;
+        }
+        else
+            return true;
+    }
+
+    static void validateFFMPEG(std::shared_ptr<dpp::cluster> cluster) {
+        std::queue<std::string> result = ConsoleUtils::safe_execute_command(SettingsManager::getFFMPEG_CMD(), {"-version"});
+        std::string front = result.front();
+        if (front[0] != 'f' ||
+            front[1] != 'f' ||
+            front[2] != 'm' ||
+            front[3] != 'p' ||
+            front[4] != 'e' ||
+            front[5] != 'g') {
+            cluster->log(dpp::ll_warning, "ffmpeg is unavailable. downloading ffmpeg...");
+
+            if (!isThereCMD(cluster, "curl")) {
+                exit(1);
+            }
+            if (!isThereCMD(cluster, "tar")) {
+                exit(1);
+            }
+
+            system("curl -LO https://github.com/BtbN/FFmpeg-Builds/releases/latest/download/ffmpeg-master-latest-linux64-gpl.tar.xz");
+            system("tar -xf ffmpeg-master-latest-linux64-gpl.tar.xz");
+            system("rm ffmpeg-master-latest-linux64-gpl.tar.xz");
+            system("mv ffmpeg-master-latest-linux64-gpl/bin/ffmpeg .");
+            system("rm -rf ffmpeg-master-latest-linux64-gpl");
+            SettingsManager::setFFMPEG_CMD("./ffmpeg");
+        }
+    }
+
+    static void validateYTDLP(std::shared_ptr<dpp::cluster> cluster) {
+        std::queue<std::string> result = ConsoleUtils::safe_execute_command(SettingsManager::getYTDLP_CMD(), {"--version"});
+        std::string front = result.front();
+        if ((front[0]-'0' < 0 || front[0]-'0' > 9) ||
+            (front[1]-'0' < 0 || front[1]-'0' > 9) ||
+            (front[2]-'0' < 0 || front[2]-'0' > 9) ||
+            (front[3]-'0' < 0 || front[3]-'0' > 9)) {
+            cluster->log(dpp::ll_warning, "ytdlp is unavailable. downloading ytdlp...");
+
+            if (!isThereCMD(cluster, "curl")) {
+                exit(1);
+            }
+            if (!isThereCMD(cluster, "tar")) {
+                exit(1);
+            }
+
+            system("curl -LO https://github.com/yt-dlp/yt-dlp/releases/latest/download/yt-dlp");
+            system("chmod +x ./yt-dlp");
+            SettingsManager::setYTDLP_CMD("./yt-dlp");
+        }
+    }
+
+    static void validateYTDLPFFMPEGBinary(std::shared_ptr<dpp::cluster> cluster) {
+        cluster->log(dpp::ll_info, "Checking if yt-dlp and ffmpeg is available...");
+        validateFFMPEG(cluster);
+        validateYTDLP(cluster);
+    }
+
+    static void updateytdlp(std::shared_ptr<dpp::cluster> cluster) {
+        cluster->log(dpp::ll_info, "Checking if yt-dlp update is available...");
+        std::queue<std::string> result = ConsoleUtils::safe_execute_command("./yt-dlp", {"-U"});
+        while(!result.empty()) {
+            std::string front = result.front();
+            result.pop();
+            cluster->log(dpp::ll_info, front);
+        }
+    }
+};
+}
--- a/1
+++ b/1
--- a/src/Audio/MusicPlayManager.cpp
+++ b/src/Audio/MusicPlayManager.cpp
@@ -0,0 +1,138 @@
+#include <Audio/MusicPlayManager.hpp>
+#include <ogg/ogg.h>
+#include <oggz/oggz.h>
+#include <algorithm>
+#include <Settings/SettingsManager.hpp>
+
+namespace bumbleBee {
+
+void MusicPlayManager::on_voice_ready(const dpp::voice_ready_t& event) {
+    play(event.voice_client);
+}
+
+void MusicPlayManager::on_voice_track_marker(const dpp::voice_track_marker_t& event) {
+    dpp::snowflake gid = dpp::find_channel(event.voice_client->channel_id)->guild_id;
+    queueMap[gid]->next_music(); // TODO("repeat가 꺼져 있을 때 노래 큐에서 지우기")
+    play(event.voice_client);
+}
+
+void MusicPlayManager::on_voice_client_disconnect(const dpp::voice_client_disconnect_t& event) { // 이거 봇이 나갈 때가 아니고 같이 있는 유저가 나갈 때였고
+    // dpp::snowflake gid = dpp::find_channel(event.voice_client->channel_id)->guild_id;
+    // event.voice_client->stop_audio();
+    // queueMap[gid]->clear();
+}
+
+void MusicPlayManager::play(dpp::discord_voice_client* client) {
+    std::thread t([&](dpp::discord_voice_client* client){
+        dpp::snowflake gid = dpp::find_channel(client->channel_id)->guild_id;
+        std::unique_lock<std::mutex> queueEmptyLock(*queueEmptyMutex[gid]);
+
+        queuedCondition.wait(queueEmptyLock, [&]{
+            return queueMap[gid]->size() != 0 && queueMap[gid]->currentPlayingPosition != queueMap[gid]->end();
+        });
+
+        auto next = queueMap[gid]->currentPlayingPosition;
+        send_audio_to_voice(*next, client);
+    }, client);
+    t.detach();
+}
+
+void MusicPlayManager::queue_music(const dpp::snowflake guildId, const std::shared_ptr<MusicQueueElement> music) {
+    queueMap[guildId]->enqueue(music);
+}
+
+void MusicPlayManager::clear(const dpp::snowflake guildId) {
+    queueMap[guildId]->clear();
+}
+std::shared_ptr<MusicQueueElement> MusicPlayManager::remove(const dpp::snowflake guildId, dpp::discord_voice_client* client, int index) {
+    auto queue = queueMap[guildId];
+    auto foundIterator = queue->findByIndex(index);
+
+    if (queue->currentPlayingPosition == foundIterator) {
+        auto removed = queue->erase(queue->findByIndex(0));
+        if (client == nullptr)
+            return removed;
+        client->pause_audio(true);
+        client->stop_audio();
+        client->pause_audio(false);
+        client->insert_marker("end");
+        return removed;
+    }
+
+    return queue->erase(queue->findByIndex(index));
+}
+int MusicPlayManager::size(const dpp::snowflake guildId) {
+    return queueMap[guildId]->size();
+}
+void MusicPlayManager::setRepeat(const dpp::snowflake guildId, const bool value) {
+    queueMap[guildId]->repeat = value;
+}
+
+bool MusicPlayManager::getRepeat(const dpp::snowflake guildId) {
+    return queueMap[guildId]->repeat;
+}
+
+std::pair<std::shared_ptr<std::list<std::shared_ptr<MusicQueueElement>>>, std::list<std::shared_ptr<MusicQueueElement>>::iterator>
+    MusicPlayManager::getQueue(const dpp::snowflake guildId){
+    auto returnValue = queueMap[guildId]->getQueueCopy();
+    return returnValue;
+}
+
+MusicQueueElement MusicPlayManager::getNowPlaying(const dpp::snowflake guildId) {
+    std::shared_ptr<MusicQueueElement> nowplaying = queueMap[guildId]->nowplaying();
+    if (nowplaying == nullptr)
+        return MusicQueueElement("", "", dpp::user(), dpp::embed());
+    MusicQueueElement returnValue(*nowplaying);
+    return returnValue;
+}
+
+void MusicPlayManager::send_audio_to_voice(std::shared_ptr<bumbleBee::MusicQueueElement> music, dpp::discord_voice_client* client) {
+    std::thread t([](std::shared_ptr<bumbleBee::MusicQueueElement> music, dpp::discord_voice_client* client) { // TODO: thread 벡터 만들고 delete, leave, skip시에 전송 중지하도록 만들고. 또 노래 캐싱하고 ytdlp를 버퍼링하여 혹시 있을지 모르는 음성의 끊김을 방지할 것것
+        std::string command = "./streamOpus.sh ";
+        command += SettingsManager::getYTDLP_CMD() + " ";
+        command += SettingsManager::getFFMPEG_CMD() + " ";
+        command += "https://youtu.be/";
+        command += music->id;
+
+        OGGZ* og = oggz_open_stdio(popen(command.c_str(), "r"), OGGZ_READ);
+
+        // client->stop_audio(); //이거 필요함??
+
+        oggz_set_read_callback(
+            og, -1,
+            [](OGGZ *oggz, oggz_packet *packet, long serialno, void *user_data) {
+                auto voiceConn = (dpp::discord_voice_client *)user_data;
+
+                voiceConn->send_audio_opus(packet->op.packet, packet->op.bytes);
+
+                return 0;
+            },
+            (void *)client
+        );
+
+        while (client && !client->terminating && music != nullptr) {
+            static const constexpr long CHUNK_READ = BUFSIZ * 2;
+
+            const long read_bytes = oggz_read(og, CHUNK_READ);
+
+            /* break on eof */
+            if (!read_bytes) {
+                break;
+            }
+        }
+
+        if (music != nullptr)
+            client->creator->log(dpp::ll_info, "Sending " + music->embed.title + " - " + music->id + " complete!");
+        else {
+            client->stop_audio();
+            client->pause_audio(true);
+        }
+
+        oggz_close(og);
+
+        client->insert_marker();
+    }, music, client);
+    t.detach();
+}
+}
+
--- a/src/Bot.cpp
+++ b/src/Bot.cpp
@@ -1,39 +0,0 @@
-#include <Bot.hpp>
-#include <Commands/CommandType.hpp>
-
-IBot::IBot(std::string token, int clusterCount)
-{
-    botCluster = std::make_shared<dpp::cluster>(token, dpp::i_default_intents, clusterCount);
-
-    botCluster->on_log(logger());
-    botCluster->on_slashcommand([&](const dpp::slashcommand_t& event){onCommand(event);});
-    botCluster->on_ready([&](const dpp::ready_t &event){onReady(event);});
-}
-
-void IBot::onCommand(const dpp::slashcommand_t &event)
-{
-    auto _event = event;
-    for (auto command : commandsArray)
-        for (auto alias : command->commandObjectVector)
-            if (event.command.get_command_name() == alias.name)
-                (*command)(_event);
-}
-
-void IBot::onReady(const dpp::ready_t &event)
-{
-    if (!dpp::run_once<struct register_bot_commands>())
-        return;
-
-    //BotCluster->global_bulk_command_delete();
-
-    for (auto command : commandsArray)
-        for (auto alias : command->commandObjectVector)
-            botCluster->global_command_create(alias);
-    
-    botCluster->log(dpp::loglevel::ll_info, "Command added to all clusters.");
-}
-
-void IBot::start()
-{
-    botCluster->start(dpp::st_wait);
-}
--- a/src/BumbleBee.cpp
+++ b/src/BumbleBee.cpp
@@ -0,0 +1,80 @@
+#include <BumbleBee.hpp>
+#include <memory>
+#include <Settings/SettingsManager.hpp>
+#include <Utils/VersionsCheckUtils.hpp>
+#include <Audio/MusicPlayManager.hpp>
+#include <Commands/BumbleBeeCommand.hpp>
+
+namespace bumbleBee{
+BumbleBee::BumbleBee() {
+    if (!SettingsManager::load()) {
+        std::cout << "Please configure confing.json" << std::endl;
+        exit(1);
+    }
+
+    cluster = std::make_shared<dpp::cluster>(SettingsManager::getTOKEN());
+
+    cluster->on_log([](const dpp::log_t& event) {
+		if (event.severity >= SettingsManager::getLOGLEVEL()) {
+			std::cout << "[" << dpp::utility::current_date_time() << "] " << dpp::utility::loglevel(event.severity) << ": " << event.message << std::endl;
+		}
+	});
+    cluster->on_slashcommand([this](const dpp::slashcommand_t& event){on_slashcommand(event);});
+    cluster->on_ready([this](const dpp::ready_t &event){on_ready(event);});
+
+    VersionsCheckUtils::validateYTDLPFFMPEGBinary(cluster);
+    VersionsCheckUtils::updateytdlp(cluster);
+}
+
+void BumbleBee::start() { this->cluster->start(dpp::st_wait); }
+
+void BumbleBee::on_slashcommand(const dpp::slashcommand_t &event) {
+    if (commands.find(event.command.get_command_name()) != commands.end()) {
+        event.thinking();
+        auto command = commands.at(event.command.get_command_name());
+        std::thread t([](const dpp::slashcommand_t &event, std::shared_ptr<commands::ICommand> command){
+            command->execute(event);
+        }, event, command);
+        t.detach();
+    }
+}
+
+void BumbleBee::on_ready(const dpp::ready_t &event) {
+    GIDs = event.guilds;
+    musicManager = std::make_shared<MusicPlayManager>(cluster, GIDs);
+
+    commands["d"]       = std::make_shared<commands::Delete>  (cluster->cluster_id, musicManager);
+    commands["l"]       = std::make_shared<commands::Leave>   (cluster->cluster_id, musicManager);
+    commands["p"]       = std::make_shared<commands::Play>    (cluster->cluster_id, musicManager);
+    commands["q"]       = std::make_shared<commands::Queue>   (cluster->cluster_id, musicManager);
+    commands["r"]       = std::make_shared<commands::Repeat>  (cluster->cluster_id, musicManager);
+    commands["s"]       = std::make_shared<commands::Skip>    (cluster->cluster_id, musicManager);
+    commands["shuffle"] = std::make_shared<commands::Shuffle> (cluster->cluster_id, musicManager);
+    
+    if (event.guilds.size() == 0) {
+        cluster->log(dpp::loglevel::ll_info, "Bot is not on any server! Please invite this bot to any server.");
+        exit(1);
+    }
+    
+    if (dpp::run_once<struct register_bot_commands>()) {
+        if (SettingsManager::getREGISTER_COMMAND()) {
+            cluster->log(dpp::loglevel::ll_info, "Clear Pre-installed commands");
+
+            cluster->global_bulk_command_create({
+                *commands["d"],
+                *commands["l"],
+                *commands["p"],
+                *commands["q"],
+                *commands["r"],
+                *commands["s"],
+                *commands["shuffle"]
+            }, [&](const dpp::confirmation_callback_t &t){
+                cluster->log(dpp::loglevel::ll_info, "Command created.");
+                SettingsManager::setREGISTER_COMMAND(false);
+            });
+        }
+    }
+
+    cluster->log(dpp::loglevel::ll_info, "Bot ready.");
+}
+}
--- a/src/BumbleCeepp.cpp
+++ b/src/BumbleCeepp.cpp
@@ -1,245 +0,0 @@
-#include "BumbleCeepp.hpp"
-#include <string>
-#include <FQueueElement.hpp>
-#include <Commands/Commands.hpp>
-#include <oggz/oggz.h>
-
-BumbleCeepp::BumbleCeepp(std::string token, std::string DBURL, std::string DBID, std::string DBPassword, int clusterCount)
-    : IBot(token, clusterCount)
-{
-    sql::Properties pro({
-        {"user", DBID},
-        {"password", DBPassword}
-    });
-
-    conn = sql::mariadb::get_driver_instance()->connect(DBURL, pro);
-    
-    commandsArray.push_back(std::make_shared<commands::Play>(botCluster->me.id, this));
-    commandsArray.push_back(std::make_shared<commands::Repeat>(botCluster->me.id, this));
-    commandsArray.push_back(std::make_shared<commands::Queue>(botCluster->me.id, this));
-    commandsArray.push_back(std::make_shared<commands::Skip>(botCluster->me.id, this));
-    commandsArray.push_back(std::make_shared<commands::Leave>(botCluster->me.id, this));
-    commandsArray.push_back(std::make_shared<commands::Delete>(botCluster->me.id, this));
-    
-    botCluster->on_voice_track_marker([&](const dpp::voice_track_marker_t &marker)
-    {
-        marker.voice_client->log(dpp::loglevel::ll_debug, "nowPlaying " + nowPlayingMusic);
-        std::shared_ptr<dpp::embed> embed;
-        if (nowPlayingMusic == "") {
-            nowPlayingMusic = marker.track_meta;
-            embed = findEmbed(nowPlayingMusic);
-        }
-        else {
-            embed = findEmbed(nowPlayingMusic);
-            nowPlayingMusic = marker.track_meta;
-        }
-        auto voice_members = dpp::find_guild(marker.voice_client->server_id)->voice_members;
-        dpp::snowflake connectedChannel = marker.voice_client->channel_id;
-        int memberCount = 0;
-        for (auto member : voice_members)
-            if ( member.second.channel_id == connectedChannel )
-                memberCount++;
-
-        if (!memberCount)
-        {
-            auto joinedShard = marker.from;
-            std::cout << "voicechat is empty.";
-            marker.voice_client->stop_audio();
-            joinedShard->disconnect_voice(marker.voice_client->server_id);
-            return;
-        }
-
-<<<<<<< HEAD
-            if (!memberCount)
-            {
-                auto joinedShard = marker.from;
-                marker.voice_client->log(dpp::loglevel::ll_info, "voicechat is empty.");
-=======
-        marker.voice_client->log(dpp::loglevel::ll_debug, "Playing " + marker.track_meta + "on channel id " + marker.voice_client->channel_id.str() + ".");
-
-        int remainingSongsCount = marker.voice_client->get_tracks_remaining();
-        marker.voice_client->log(dpp::loglevel::ll_debug, "Marker count : " + std::to_string(remainingSongsCount));
-
-        if (remainingSongsCount <= 1 && !marker.voice_client->is_playing())
-        {
-            auto joinedShard = marker.from;
-            std::cout << "Queue ended\n";
-            if (!joinedShard)
-                return;
-
-            if (repeat) {
-                std::shared_ptr<dpp::embed> embed = findEmbed(nowPlayingMusic);
-                enqueueMusic({nowPlayingMusic, *embed}, marker.voice_client);
-            }
-            else {
->>>>>>> 68b6105ac3ddf1c27f40e0e552780171352e734d
-                marker.voice_client->stop_audio();
-                joinedShard->disconnect_voice(marker.voice_client->server_id);
-                return;
-            }
-        }
-
-<<<<<<< HEAD
-
-            marker.voice_client->log(dpp::loglevel::ll_debug, "Playing " + marker.track_meta + "on channel id " + marker.voice_client->channel_id.str() + ".");
-
-            int remainingSongsCount = marker.voice_client->get_tracks_remaining();
-            marker.voice_client->log(dpp::loglevel::ll_info, "Marker count : " + remainingSongsCount);
-
-            if (remainingSongsCount <= 1 && !marker.voice_client->is_playing())
-            {
-                auto joinedShard = marker.from;
-                marker.voice_client->log(dpp::loglevel::ll_info, "Queue ended");
-                if (!joinedShard)
-                    return;
-                marker.voice_client->stop_audio();
-                joinedShard->disconnect_voice(marker.voice_client->server_id);
-=======
-        if (repeat) {
-            if (!embed) {
-                botCluster->log(dpp::loglevel::ll_error, std::string("알 수 없는 오류 발생!"));
->>>>>>> 68b6105ac3ddf1c27f40e0e552780171352e734d
-                return;
-            }
-
-            enqueueMusic({nowPlayingMusic, *embed}, marker.voice_client);
-        }
-    });
-}
-
-BumbleCeepp::~BumbleCeepp()
-{
-    conn->close();
-}
-
-void BumbleCeepp::enqueueMusic(FQueueElement item, dpp::discord_voice_client* vc)
-{
-    vc->insert_marker(item.ID);
-    vc->log(dpp::loglevel::ll_debug, "Enqueueuing " + item.ID + "on channel id " + vc->channel_id.str() + ".");
-    std::lock_guard<std::mutex> lock(enqueuingMutexMap[vc->server_id]);
-
-    OGGZ *track_og = oggz_open(("Music/" + item.ID + ".ogg").c_str(), OGGZ_READ);
-
-    /* If there was an issue reading the file, tell the user and stop */
-    if (!track_og) {
-        fprintf(stderr, "Error opening file\n");
-        return;
-    }
-
-    /* set read callback, this callback will be called on packets with the serialno,
-        * -1 means every packet will be handled with this callback.
-        */
-    oggz_set_read_callback(
-        track_og, -1,
-        [](OGGZ *oggz, oggz_packet *packet, long serialno, void *user_data) {
-            dpp::discord_voice_client *vc = (dpp::discord_voice_client *)user_data;
-
-            /* send the audio */
-            vc->send_audio_opus(packet->op.packet, packet->op.bytes);
-
-            /* make sure to always return 0 here, read more on oggz documentation */
-            return 0;
-        },
-        /* this will be the value of void *user_data */
-        (void *)vc
-    );
-
-    // read loop
-    while (vc && !vc->terminating) {
-        /* you can tweak this to whatever. Here I use BUFSIZ, defined in
-            * stdio.h as 8192.
-            */
-        static const constexpr long CHUNK_READ = BUFSIZ * 2;
-
-        const long read_bytes = oggz_read(track_og, CHUNK_READ);
-
-        /* break on eof */
-        if (!read_bytes) {
-            break;
-        }
-    }
-
-    /* Don't forget to free the memory */
-    oggz_close(track_og);
-
-    vc->log(dpp::loglevel::ll_debug, "Enqueued " + item.ID + "on channel id " + vc->channel_id.str() + ".");
-}
-
-std::shared_ptr<dpp::embed> BumbleCeepp::findEmbed(std::string musicID)
-{
-    sql::ResultSet* res;
-    std::shared_ptr<dpp::embed> returnValue;
-    try {
-        std::unique_ptr<sql::PreparedStatement> stmnt(conn->prepareStatement("SELECT * FROM songs_info WHERE ID = ?"));
-        stmnt->setString(1, musicID);
-        res = stmnt->executeQuery();
-
-        if (!res->next()) {
-            return nullptr;
-        }
-
-        returnValue = makeEmbed(
-            res->getString("webpage_url").c_str(),
-            res->getString("title").c_str(),
-            res->getString("uploader").c_str(),
-            musicID,
-            res->getString("thumbnail").c_str(),
-            res->getInt("duration"));
-    }
-    catch(sql::SQLException& e){
-        botCluster->log(dpp::loglevel::ll_error, std::string("SQLError: ") + e.what());
-        return nullptr;
-    }
-
-    return returnValue;
-}
-
-bool BumbleCeepp::insertDB(
-    std::string webpage_url, std::string title, std::string uploader, std::string id, std::string thumbnail, time_t duration)
-{
-    try {
-        std::unique_ptr<sql::PreparedStatement> stmnt(
-            conn->prepareStatement("REPLACE INTO songs_info (ID, webpage_url, title, uploader, thumbnail, duration) VALUE (?, ?, ?, ?, ?, ?)"));
-        stmnt->setString(1, id);
-        stmnt->setString(2, webpage_url);
-        stmnt->setString(3, title);
-        stmnt->setString(4, uploader);
-        stmnt->setString(5, thumbnail);
-        stmnt->setInt(6, duration);
-        stmnt->executeQuery();
-
-        return true;
-    }
-    catch(sql::SQLException& e){
-        botCluster->log(dpp::loglevel::ll_debug, std::string("SQLError: ") + e.what());
-        return false;
-    }
-}
-
-std::shared_ptr<dpp::embed> BumbleCeepp::makeEmbed(
-    std::string webpage_url, std::string title, std::string uploader, std::string id, std::string thumbnail, time_t duration)
-{
-    char SongLengthStr[10];
-    tm t;
-    t.tm_mday = duration / 86400;
-    t.tm_hour = (duration % 86400)/3600;
-    t.tm_min = (duration % 3600)/60;
-    t.tm_sec = duration%60;
-    strftime(SongLengthStr, sizeof(SongLengthStr), "%X", &t);
-
-    dpp::embed returnValue = dpp::embed()
-        .set_color(dpp::colors::sti_blue)
-        .set_title(title)
-        .set_description(uploader)
-        .set_url(webpage_url)
-        .set_image(thumbnail)
-        .add_field(
-            "길이",
-            SongLengthStr,
-            true
-        );
-
-    insertDB(webpage_url, title, uploader, id, thumbnail, duration);
-
-    return std::make_shared<dpp::embed>(returnValue);
-}
--- a/src/Commands/Delete.cpp
+++ b/src/Commands/Delete.cpp
@@ -1,58 +1,32 @@
-#include <Commands/Delete.hpp>
-#include <iostream>
+#include <Commands/BumbleBeeCommand.hpp>
+#include <format>

-commands::Delete::Delete(dpp::snowflake botID, BumbleCeepp* Bot)
- : ICommand(botID, Bot)
-{
-    dpp::slashcommand Command = dpp::slashcommand("d", "큐의 해당하는 번호의 노래를 지웁니다", botID);
+namespace bumbleBee::commands {
+    void Delete::execute(const dpp::slashcommand_t &event) {
+        int pos = std::get<std::int64_t>(event.get_parameter("pos"));

-    Command.add_option(
-        dpp::command_option(dpp::co_string, "pos", "큐 번호", botID)
-    );
-
-    commandObjectVector.push_back(Command);
-}
-
-void commands::Delete::operator()(const dpp::slashcommand_t& event)
-{
-    if (std::holds_alternative<std::monostate>(event.get_parameter("pos"))) {
-        event.reply("삭제할 노래의 인덱스가 정확하지 않습니다.");
-        return;
-    }
-    std::string Pos = std::get<std::string>(event.get_parameter("pos"));
-    event.thinking();
-
-    auto index = atoi(Pos.c_str());
-
-    auto vc = event.from->connecting_voice_channels.find(event.command.guild_id)->second->voiceclient;
-    int remainingSongsCount = vc->get_tracks_remaining() - 1;
-    std::vector<std::string> queuedSongs = vc->get_marker_metadata();
-
-    vc->log(dpp::loglevel::ll_info, "Queue size : " + remainingSongsCount);
-
-    if (index < 0 || remainingSongsCount+1 < index || (!vc->is_playing() && index == 0)) {
-        std::cout << "invalid index : " << index << ", " + Pos + "\n";
-
-        event.edit_original_response(dpp::message(event.command.channel_id, "이상한 인덱스 위치. Pos : " + Pos));
-        return;
-    }
-
-    dpp::embed embed = (*Bot->findEmbed(queuedSongs[index - 1]))
-        .set_timestamp(time(0));
-
-    dpp::message msg(event.command.channel_id, "다음 항목을 큐에서 삭제했습니다!:");
-
-    if (index == 0) {
-        dpp::voiceconn* v = event.from->get_voice(event.command.guild_id);
-
-        if (!v || !v->voiceclient || !v->voiceclient->is_ready()) {
+        if (pos < 0 || pos > musicManager->size(event.command.guild_id))
+        {
+            event.edit_original_response(dpp::message(std::string("이상한 인덱스 위치. Pos :") + std::to_string(pos)));
            return;
        }

-        v->voiceclient->skip_to_next_marker();
-    }
-    
-    msg.add_embed(embed);
+        dpp::voiceconn* v = event.from->get_voice(event.command.guild_id);

-    event.edit_original_response(msg);
+        std::shared_ptr<MusicQueueElement> removed;
+        
+        if (!v) // v-> 로 nullptr을 참조하면 안 되므로.
+            removed = musicManager->remove(event.command.guild_id, nullptr, pos);
+        else
+            removed = musicManager->remove(event.command.guild_id, v->voiceclient, pos);
+
+        dpp::message msg("다음 항목을 큐에서 삭제했습니다!:");
+        msg.add_embed(removed->embed);
+
+        event.edit_original_response(msg);
+    }
+
+    void Delete::init() {
+        add_option(dpp::command_option(dpp::co_integer, "pos", "지울 위치(위치는 1부터 시작, 현재 재생곡은 0)", true));
+    }
 }
--- a/src/Commands/Leave.cpp
+++ b/src/Commands/Leave.cpp
@@ -1,25 +1,23 @@
-#include <Commands/Leave.hpp>
-#include <iostream>
+#include <Commands/BumbleBeeCommand.hpp>

-commands::Leave::Leave(dpp::snowflake botID, BumbleCeepp* Bot)
- : ICommand(botID, Bot)
-{
-    dpp::slashcommand command = dpp::slashcommand("l", "음챗을 떠납니다", botID);
+namespace bumbleBee::commands {
+    void Leave::execute(const dpp::slashcommand_t &event) {
+        dpp::voiceconn* v = event.from->get_voice(event.command.guild_id);

-    commandObjectVector.push_back(command);
-}
+        if (!v || !v->voiceclient || !v->voiceclient->is_ready()) {
+            event.edit_original_response(dpp::message("현재 음성 채팅방에 있는 상태가 아닙니다!"));
+            return;
+        }
+        musicManager->clear(event.command.guild_id);
+        
+        v->voiceclient->stop_audio();
+        v->voiceclient->pause_audio(true);
+        event.from->clear_queue();
+        event.from->disconnect_voice(event.command.guild_id);

-void commands::Leave::operator()(const dpp::slashcommand_t& event)
-{
-    dpp::voiceconn* v = event.from->get_voice(event.command.guild_id);
-
-    if (!v || !v->voiceclient || !v->voiceclient->is_ready()) {
-        return;
+        event.edit_original_response(dpp::message("음성 채팅방을 떠납니다!"));
    }
-    v->voiceclient->stop_audio();
-    event.from->disconnect_voice(event.command.guild_id);

-    dpp::message msg(event.command.channel_id, "음성 채팅방을 떠납니다!");
-
-    event.reply(msg);
+    void Leave::init() {
+    }
 }
--- a/src/Commands/Play.cpp
+++ b/src/Commands/Play.cpp
@@ -1,212 +1,240 @@
-#include <Commands/Play.hpp>
-#include <dpp/dpp.h>
+#include <Commands/BumbleBeeCommand.hpp>
+#include <Utils/ConsoleUtils.hpp>
+#include <Settings/SettingsManager.hpp>
 #include <dpp/nlohmann/json.hpp>
-#include <string>
-#include <filesystem>
-#include <ctime>
-#include <thread>
+#include <Utils/QueuedMusicListEmbedProvider.hpp>
+#include <Utils/ConsoleUtils.hpp>
+#include <variant>

-using json = nlohmann::json;
+namespace bumbleBee::commands {
+    void Play::execute(const dpp::slashcommand_t &event) { // TODO : 길드 단위로 잠구고 메타데이터 로딩 중엔 로딩 중임을 표시할 수 있는 UI 만들 것것
+        dpp::guild *g = dpp::find_guild(event.command.guild_id);

-std::string getResultFromCommand(std::string cmd) {
-	std::string result;
-	FILE* stream;
-	const int maxBuffer = 256; // 버퍼의 크기는 적당하게
-	char buffer[maxBuffer];
-	cmd.append(" 2>&1"); // 표준에러를 표준출력으로 redirect
-
-    stream = popen(cmd.c_str(), "r"); // 주어진 command를 shell로 실행하고 파이프 연결 (fd 반환)
-    	if (stream) {
-    		while (fgets(buffer, maxBuffer, stream) != NULL) result.append(buffer); // fgets: fd (stream)를 길이 (maxBuffer)만큼 읽어 버퍼 (buffer)에 저장
-    		pclose(stream); // 파이프 닫는 것 잊지 마시고요!
-    	}
-	return result;
-}
-
-commands::Play::Play(dpp::snowflake botID, BumbleCeepp* Bot)
- : ICommand(botID, Bot)
-{
-    dpp::slashcommand command = dpp::slashcommand("p", "노래 재생", botID);
-
-    command.add_option(
-        dpp::command_option(dpp::co_string, "query", "링크 또는 검색어", botID)
-    );
-
-    commandObjectVector.push_back(command);
-}
-
-<<<<<<< HEAD
-static void _Internal_Enqueue_Func(const dpp::slashcommand_t& event, BumbleCeepp* Bot){
-    std::string Query = std::get<std::string>(event.get_parameter("query"));
-
-    event.from->log(dpp::loglevel::ll_info, "음악 다운로드 시작");
-    std::system(("python3 yt-download.py \"" + Query + "\" & wait").c_str());
-    event.from->log(dpp::loglevel::ll_info, "음악 다운로드 완료");
-=======
-void commands::Play::operator()(const dpp::slashcommand_t& event)
-{
-    if (std::holds_alternative<std::monostate>(event.get_parameter("query")))
-    {
-        event.reply("노래를 재생하려면 검색어 또는 링크를 입력해 주십시오.");
-        return;
-    }
-
-    /* Attempt to connect to a voice channel, returns false if we fail to connect. */
-    if (!event.from->get_voice(event.command.guild_id))
-    {
-        dpp::guild* g = dpp::find_guild(event.command.guild_id);
-        bool memberIsInVoice = g->connect_member_voice(event.command.get_issuing_user().id);
-        if (!memberIsInVoice)
-        {
-            event.reply("노래를 재생할 음성 채팅방에 먼저 참가하고 신청해야 합니다!");
+        if (!g) { //wtf?
+            event.edit_original_response(dpp::message("GUILD NOT FOUND!! WHAT IS THIS SORCERY??"));
            return;
        }
-    }
-
-    std::string Query = std::get<std::string>(event.get_parameter("query"));
-
-    event.thinking();
-
-    event.from->log(dpp::loglevel::ll_debug, "음악 ID 쿼리: " + Query);
->>>>>>> 68b6105ac3ddf1c27f40e0e552780171352e734d
-
-    std::string musicIDs = getResultFromCommand(("python3 youtube-search.py \"" + Query + "\" & wait").c_str());
-
-    if (!musicIDs.length())
-    {
-<<<<<<< HEAD
-        event.from->log(dpp::loglevel::ll_info, "Red ID : " + ID);
-        infofile.open("Music/" + ID + ".info.json");
-        infofile >> document;
-        infofile.close();
-
-        FQueueElement Data = {
-            ID,
-            Bot->makeEmbed(
-            document["webpage_url"],
-            document["title"],
-            document["uploader"],
-            document["id"],
-            document["thumbnail"],
-            int(document["duration"]))
-        };
-
-        RequestedMusic.push(Data);
-=======
-        event.from->log(dpp::loglevel::ll_debug, "유튜브 검색 결과 없음");
-        event.edit_response("검색 결과가 없습니다.");
-        return;
->>>>>>> 68b6105ac3ddf1c27f40e0e552780171352e734d
-    }
-    
-    std::stringstream sstream(musicIDs);
-    std::string musicID;
-    while (getline(sstream, musicID, '\n')) {
-        event.from->log(dpp::loglevel::ll_debug, "musicID: " + musicID);
-            event.from->log(dpp::loglevel::ll_debug, "DB쿼리 시도..");
-        std::shared_ptr<dpp::embed> embed = Bot->findEmbed(musicID);
-
-        if (embed == nullptr) {
-            event.from->log(dpp::loglevel::ll_debug, "DB쿼리 실패");
-            event.from->log(dpp::loglevel::ll_debug, "다운로드 시작");
-            std::system(("python3 yt-download.py \"" + musicID + "\" & wait").c_str());
-
-<<<<<<< HEAD
-    if (v && v->voiceclient && v->voiceclient->is_ready())
-    {
-        auto _copiedQueue = RequestedMusic;
-        while (!_copiedQueue.empty())
+        if (std::holds_alternative<std::monostate>(event.get_parameter("query"))) // 이거 필요한가???
        {
-            Bot->enqueueMusic(_copiedQueue.front(), v->voiceclient);
-            _copiedQueue.pop();
-=======
-            event.from->log(dpp::loglevel::ll_debug, "musicID: " + musicID);
-            std::ifstream infofile;
-            infofile.open((std::string("Music/") + musicID + ".info.json").c_str());
-            event.from->log(dpp::loglevel::ll_debug, std::string("json file name: ") + "Music/" + musicID + ".info.json");
-            json document;
-            infofile >> document;
-            infofile.close();
+            event.reply("노래를 재생하려면 검색어 또는 링크를 입력해 주십시오.");
+            return;
+        }
+        if (!event.from->get_voice(event.command.guild_id) && !g->connect_member_voice(event.command.usr.id)) {
+            event.edit_original_response(dpp::message("노래를 재생할 음성 채팅방에 먼저 참가하고 신청해야 합니다!"));
+            return;
+        }
+        std::string query = std::get<std::string>(event.get_parameter("query"));
+        // query = "\"" + query + "\"";

-            embed = Bot->makeEmbed(
-                document["webpage_url"],
-                document["title"],
-                document["uploader"],
-                document["id"],
-                document["thumbnail"],
-                int(document["duration"]));
+        std::queue<std::string> ids =
+            ConsoleUtils::safe_execute_command(
+            SettingsManager::getYTDLP_CMD(), {
+            "--default-search",
+            "ytsearch",
+            "--flat-playlist",
+            "--skip-download",
+            "--quiet",
+            "--ignore-errors",
+            "--print",
+            "id",
+            query});
+
+        std::queue<std::shared_ptr<MusicQueueElement>> musics;
+
+        int initialQueuedCount = musicManager->size(event.command.guild_id);
+
+        dpp::message msg;
+
+        if (musicManager->size(event.command.guild_id) == 0)
+            msg.content = "다음 곡을 재생합니다:";
+        else
+            msg.content = "큐에 다음 곡을 추가했습니다:";
+
+        if (!ids.empty()) { // TODO : 이거 멀티스레드로 바꿔서 더 빨리 정보를 받아올 수 있도록 개선할 것것
+            if (ids.front() == "") {
+                ids.pop();
+            }
+
+            std::string jsonData = ConsoleUtils::safe_execute_command(SettingsManager::getYTDLP_CMD(), {
+                "--default-search",
+                "ytsearch",
+                "--flat-playlist",
+                "--skip-download",
+                "--quiet",
+                "--ignore-errors",
+                "-J",
+                "http://youtu.be/" + ids.front()
+            }).front();
+
+            std::istringstream iss(jsonData);
+            nlohmann::json videoDataJson;
+            iss >> videoDataJson;
+
+            time_t SongLength = int(videoDataJson["duration"]);
+            char SongLengthStr[13];
+            tm t;
+            t.tm_mday = SongLength / 86400;
+            t.tm_hour = (SongLength % 86400)/3600;
+            t.tm_min = (SongLength % 3600)/60;
+            t.tm_sec = SongLength%60;
+            if (t.tm_mday > 0)
+                strftime(SongLengthStr, sizeof(SongLengthStr), "%d:%H:%M:%S", &t);
+            else if (t.tm_hour > 0)
+                strftime(SongLengthStr, sizeof(SongLengthStr), "%H:%M:%S", &t);
+            else
+                strftime(SongLengthStr, sizeof(SongLengthStr), "%M:%S", &t);
+
+            dpp::embed embed = dpp::embed()
+                .set_color(dpp::colors::sti_blue)
+                .set_title(std::string(videoDataJson["title"]))
+                .set_description(std::string(videoDataJson["uploader"]))
+                .set_url(std::string(videoDataJson["webpage_url"]))
+                .set_image(std::string(videoDataJson["thumbnail"]))
+                .add_field(
+                    "길이",
+                    SongLengthStr,
+                    true
+                );
+
+            musics.push(std::make_shared<MusicQueueElement>(ids.front(), query, event.command.usr, embed));
+            ids.pop();
+        }
+
+        if (!ids.empty()) {
+            std::thread t([](
+                std::queue<std::string> ids,
+                dpp::snowflake guildId,
+                dpp::snowflake channelId,
+                std::string query,
+                dpp::user user,
+                dpp::cluster* cluster,
+                std::shared_ptr<MusicPlayManager> manager
+                ) {
+                    while (!ids.empty()) {
+                        if (ids.front() == "") {
+                            ids.pop();
+                            continue;
+                        }
+
+                        std::string jsonData = ConsoleUtils::safe_execute_command(SettingsManager::getYTDLP_CMD(), {
+                            "--default-search",
+                            "ytsearch",
+                            "--flat-playlist",
+                            "--skip-download",
+                            "--quiet",
+                            "--ignore-errors",
+                            "-J",
+                            "http://youtu.be/" + ids.front()
+                        }).front();
            
-            on_DLCompleted(musicID, *embed, event);
+                        std::istringstream iss(jsonData);
+                        nlohmann::json videoDataJson;
+                        iss >> videoDataJson;
+
+                        time_t SongLength = int(videoDataJson["duration"]);
+                        char SongLengthStr[13];
+                        tm t;
+                        t.tm_mday = SongLength / 86400;
+                        t.tm_hour = (SongLength % 86400)/3600;
+                        t.tm_min = (SongLength % 3600)/60;
+                        t.tm_sec = SongLength%60;
+                        if (t.tm_mday > 0)
+                            strftime(SongLengthStr, sizeof(SongLengthStr), "%d:%H:%M:%S", &t);
+                        else if (t.tm_hour > 0)
+                            strftime(SongLengthStr, sizeof(SongLengthStr), "%H:%M:%S", &t);
+                        else
+                            strftime(SongLengthStr, sizeof(SongLengthStr), "%M:%S", &t);
+
+                        dpp::embed embed = dpp::embed()
+                            .set_color(dpp::colors::sti_blue)
+                            .set_title(std::string(videoDataJson["title"]))
+                            .set_description(std::string(videoDataJson["uploader"]))
+                            .set_url(std::string(videoDataJson["webpage_url"]))
+                            .set_image(std::string(videoDataJson["thumbnail"]))
+                            .add_field(
+                                "길이",
+                                SongLengthStr,
+                                true
+                            );
+
+                        auto music = std::make_shared<MusicQueueElement>(ids.front(), query, user, embed);
+
+                        cluster->log(dpp::ll_info, "Enqueuing " + music->embed.title + " - " + music->id);
+                        manager->queue_music(guildId, music);
+                        ids.pop();
+                    }
+
+                    std::mutex messageorder;
+                    std::unique_lock lock(messageorder);
+                    std::condition_variable messageSentCondition;                   // 개씨발 코드 개더러워 ;;
+                    bool messagesent = false;
+                    auto queue = manager->getQueue(guildId);
+                    auto queued = QueuedMusicListEmbedProvider::makeEmbed(queue.first, queue.second, manager->getRepeat(guildId));
+                    if (!queued.empty()) {
+                        dpp::message followMsg(channelId, "현재 큐에 있는 항목:");
+
+                        followMsg.add_embed(queued.front());
+                        messagesent = false;
+                        cluster->message_create(followMsg, [&](const dpp::confirmation_callback_t &callback){
+                            messagesent = true;
+                            messageSentCondition.notify_all();
+                        });
+
+                        messageSentCondition.wait(lock, [&](){ return messagesent; });
+                        queued.pop();
+                    }
+                    while (!queued.empty()) {
+                        dpp::message followMsg(channelId, "");
+
+                        followMsg.add_embed(queued.front());
+                        messagesent = false;
+                        cluster->message_create(followMsg, [&](const dpp::confirmation_callback_t &callback){
+                            messagesent = true;
+                            messageSentCondition.notify_all();
+                        });
+
+                        messageSentCondition.wait(lock, [&](){ return messagesent; });
+                        queued.pop();
+                    }
+                },
+                ids,
+                event.command.guild_id,
+                event.command.channel_id,
+                query,
+                event.command.usr,
+                event.from->creator,
+                musicManager);
+
+            t.detach();
+        }
+        
+        if (!musics.empty()) {
+            event.from->creator->log(dpp::ll_info, "Enqueuing " + musics.front()->embed.title + " - " + musics.front()->id);
+            musicManager->queue_music(event.command.guild_id, musics.front());
+            msg.add_embed(musics.front()->embed);
+            musics.pop();
+
+            event.edit_original_response(msg);
+            musicManager->queuedCondition.notify_all();
        }
        else {
-            event.from->log(dpp::loglevel::ll_debug, "DB쿼리 완료");
-            on_DLCompleted(musicID, *embed, event);
->>>>>>> 68b6105ac3ddf1c27f40e0e552780171352e734d
+            msg.content = "검색 결과가 없습니다";
+            event.edit_original_response(msg);
        }
-    }
-    return;
-}

-void commands::Play::on_DLCompleted(std::string musicID, dpp::embed embed, const dpp::slashcommand_t& event)
-{
-    static std::string raw_event;
-    if (raw_event != event.raw_event){
-        raw_event = event.raw_event;
+        if (musicManager->getNowPlaying(event.command.guild_id).id == "") {
+            dpp::voiceconn* v = event.from->get_voice(event.command.guild_id);

-        dpp::message msg(event.command.channel_id, "큐에 다음 곡을 추가했습니다:");
-        msg.add_embed(embed);
-        event.edit_response(msg);
-    }
-    else {
-        dpp::message followMsg(event.command.channel_id, "");
-
-        dpp::embed followEmbed = dpp::embed()
-            .add_field(
-                embed.title,
-                embed.description,
-                true
-            )
-            .add_field(
-                "",
-                ""
-            );
-
-        followMsg.add_embed(followEmbed);
-
-        event.from->creator->message_create(followMsg);
-    }
-}
-
-void commands::Play::operator()(const dpp::slashcommand_t& event)
-{
-    if (std::holds_alternative<std::monostate>(event.get_parameter("query")))
-    {
-        event.reply("노래를 재생하려면 검색어 또는 링크를 입력해 주십시오.");
-        return;
-    }
-
-    /* Attempt to connect to a voice channel, returns false if we fail to connect. */
-    if (!event.from->get_voice(event.command.guild_id))
-    {
-        if (!dpp::find_guild(event.command.guild_id)->connect_member_voice(event.command.get_issuing_user().id))
-        {
-            return event.reply("노래를 재생할 음성 채팅방에 먼저 참가하고 신청해야 합니다!");
+            if (!v || !v->voiceclient || !v->voiceclient->is_ready()) {
+                event.edit_original_response(dpp::message("현재 음성 채팅방에 있는 상태가 아닙니다!"));
+                return;
+            }
+            v->voiceclient->insert_marker();
+            v->voiceclient->pause_audio(false);
        }
    }

-    event.thinking();
-
-    std::thread t1(_Internal_Enqueue_Func, event, Bot);
-    t1.detach();
-
-    auto voiceconn = event.from->get_voice(event.command.guild_id);
-
-    if (!voiceconn || !voiceconn->voiceclient || !voiceconn->voiceclient->is_ready()) {
-        event.from->creator->on_voice_ready([this, musicID, embed](const dpp::voice_ready_t& Voice){
-            this->Bot->enqueueMusic({musicID, embed}, Voice.voice_client);
-        });
-    }
-    else {
-        Bot->enqueueMusic({musicID, embed}, voiceconn->voiceclient);
+    void Play::init() {
+        add_option(dpp::command_option(dpp::co_string, "query", "링크 또는 검색어", true));
    }
 }
--- a/src/Commands/Queue.cpp
+++ b/src/Commands/Queue.cpp
@@ -1,90 +1,73 @@
-#include <Commands/Queue.hpp>
-#include <iostream>
-#include <sstream>
-#include <cmath>
+#include <Commands/BumbleBeeCommand.hpp>
+#include <Utils/QueuedMusicListEmbedProvider.hpp>

-commands::Queue::Queue(dpp::snowflake botID, BumbleCeepp* Bot)
- : ICommand(botID, Bot)
-{
-    dpp::slashcommand command = dpp::slashcommand("q", "노래 예약 큐 확인", botID);
+namespace bumbleBee::commands {
+    void Queue::execute(const dpp::slashcommand_t &event) {
+        auto queue = musicManager->getQueue(event.command.guild_id);

-    commandObjectVector.push_back(command);
-}
+        dpp::message msg;
+        dpp::embed embed;

-void commands::Queue::operator()(const dpp::slashcommand_t& event) {
-    dpp::message msg;
-    msg.set_channel_id(event.command.channel_id);
+        auto queued = QueuedMusicListEmbedProvider::makeEmbed(queue.first, queue.second, musicManager->getRepeat(event.command.guild_id));

-    auto voiceconn = event.from->get_voice(event.command.guild_id);
+        // if (queue.first.size() == 0) {
+        //     msg.add_embed(queued.front());
+        //     event.edit_original_response(msg);
+        //     return;
+        // }

-    if (!voiceconn || !voiceconn->voiceclient) {
-        event.reply("음성 채팅방에 참가하지 않은 상태입니다.");
-        return;
-    }
-    auto vc = voiceconn->voiceclient;
+        //  &&
+        // queue.first.size() != 0 &&
+        // *queue.second != nullptr &&
+        // (*queue.second)->id != ""

-    int remainingSongsCount = vc->get_tracks_remaining() - 1;
-    if (remainingSongsCount <= 0 && !vc->is_playing()) {
-        //재생 중인 노래가 없고 큐에 노래가 없는 상황
-        dpp::embed embed = dpp::embed()
-            .set_color(dpp::colors::sti_blue)
-            .set_title("큐가 비었습니다!")
-            .set_timestamp(time(0));
-
-        if (Bot->repeat)
-            embed.add_field(":repeat:","");
-
-        msg.add_embed(embed);
-    }
-    else {
-        msg.set_content("지금 재생 중:");
-        dpp::embed curMusicEmbed = *Bot->findEmbed(Bot->nowPlayingMusic);
-        msg.add_embed(curMusicEmbed);
-    }
-
-    event.reply(msg, [&](const dpp::confirmation_callback_t& _event) {
-        auto shard_id = dpp::find_guild(event.command.guild_id)->shard_id;
-        dpp::cluster* cluster = const_cast<dpp::cluster *>(_event.bot);
-        auto shard = cluster->get_shard(shard_id);
-        auto iter = shard->connecting_voice_channels.find(event.command.guild_id);
-        std::vector<std::string> queuedSongs = iter->second->voiceclient->get_marker_metadata();
-
-        int j;
-        for (int i = 0; i < (queuedSongs.size()+4) / 5; i++)
-        {
-            dpp::embed followEmbed = dpp::embed();
-            for (j = i * 5; j < i * 5 + 5 && j < queuedSongs.size(); j++)
-            {
-                dpp::embed originalEmbed = *Bot->findEmbed(queuedSongs[j]);
-
-                followEmbed.add_field(
-                    std::to_string(j + 1),
-                    "",
-                    true
-                )
-                .add_field(
-                    originalEmbed.title,
-                    originalEmbed.description,
-                    true
-                )
-                .add_field(
-                    "",
-                    ""
-                );
-            }
-
-            if (j >= queuedSongs.size())
-            {
-                followEmbed.set_timestamp(time(0));
-                if (Bot->repeat)
-                    followEmbed.add_field(":repeat:","");
-            }
-
-            dpp::message followMsg;
-            followMsg.channel_id = event.command.channel_id;
-
-            followMsg.add_embed(followEmbed);
-            event.from->creator->message_create(followMsg);
+        if (queue.first->size() != 0 && queue.first->end() != queue.second && (*queue.second)->id != "") {
+            msg.content = "지금 재생 중:";
+            msg.add_embed((*queue.second)->embed);
+            event.edit_original_response(msg);
        }
-    });
+        else {
+            msg.content = "재생 중인 노래가 없습니다";
+            event.edit_original_response(msg);
+        }
+
+        std::thread t([](std::queue<dpp::embed> queued, dpp::snowflake channel_id, dpp::cluster* cluster) {
+            std::mutex messageorder;
+            std::unique_lock lock(messageorder);
+            std::condition_variable messageSentCondition;
+            bool messagesent = false;
+            if (!queued.empty()) {
+                dpp::message followMsg(channel_id, "현재 큐에 있는 항목:");
+
+                followMsg.add_embed(queued.front());
+                messagesent = false;
+                cluster->message_create(followMsg, [&](const dpp::confirmation_callback_t &callback){
+                    messagesent = true;
+                    messageSentCondition.notify_all();
+                });
+
+                messageSentCondition.wait(lock, [&](){ return messagesent; });
+
+                queued.pop();
+            }
+            while (!queued.empty()) {
+                dpp::message followMsg(channel_id, "");
+
+                followMsg.add_embed(queued.front());
+
+                messagesent = false;
+                cluster->message_create(followMsg, [&](const dpp::confirmation_callback_t &callback){
+                    messagesent = true;
+                    messageSentCondition.notify_all();
+                });
+
+                messageSentCondition.wait(lock, [&](){ return messagesent; });
+                queued.pop();
+            }
+        }, queued, event.command.channel_id, event.from->creator);
+        t.detach();
+    }
+
+    void Queue::init() {
+    }
 }
--- a/src/Commands/Repeat.cpp
+++ b/src/Commands/Repeat.cpp
@@ -1,25 +1,16 @@
-#include <Commands/Repeat.hpp>
-#include <dpp/dpp.h>
-#include <string>
+#include <Commands/BumbleBeeCommand.hpp>

-commands::Repeat::Repeat(dpp::snowflake botID, BumbleCeepp* Bot)
- : ICommand(botID, Bot)
-{
-    dpp::slashcommand command = dpp::slashcommand("r", "반복 켜기/끄기", botID);
-
-    commandObjectVector.push_back(command);
-}
-
-void commands::Repeat::operator()(const dpp::slashcommand_t& event) {
-    
-    if (Bot->repeat) {
-        event.reply("반복을 껐습니다.");
-        Bot->repeat = false;
-    }
-    else {
-        event.reply("반복을 켰습니다.");
-        Bot->repeat = true;
+namespace bumbleBee::commands {
+    void Repeat::execute(const dpp::slashcommand_t &event) {
+        if (musicManager->getRepeat(event.command.guild_id)) {
+            event.edit_original_response(dpp::message("반복을 껐습니다."));
+            musicManager->setRepeat(event.command.guild_id, false);
+        }
+        else {
+            event.edit_original_response(dpp::message("반복을 켰습니다."));
+            musicManager->setRepeat(event.command.guild_id, true);
+        }
    }

-    return;
+    void Repeat::init() {}
 }
--- a/src/Commands/Shuffle.cpp
+++ b/src/Commands/Shuffle.cpp
@@ -0,0 +1,11 @@
+#include <Commands/BumbleBeeCommand.hpp>
+
+namespace bumbleBee::commands {
+    void Shuffle::execute(const dpp::slashcommand_t &event) {
+        event.edit_original_response(dpp::message("shuffle"));
+        // TODO : 구현
+    }
+
+    void Shuffle::init() {
+    }
+}
--- a/src/Commands/Skip.cpp
+++ b/src/Commands/Skip.cpp
@@ -1,24 +1,19 @@
-#include <Commands/Skip.hpp>
-#include <dpp/dpp.h>
-#include <string>
+#include <Commands/BumbleBeeCommand.hpp>

-commands::Skip::Skip(dpp::snowflake botID, BumbleCeepp* Bot)
- : ICommand(botID, Bot)
-{
-    dpp::slashcommand command = dpp::slashcommand("s", "현재곡 스킵", botID);
+namespace bumbleBee::commands {
+    void Skip::execute(const dpp::slashcommand_t &event) {
+        dpp::voiceconn* v = event.from->get_voice(event.command.guild_id);

-    commandObjectVector.push_back(command);
-}
+        if (!v || !v->voiceclient || !v->voiceclient->is_ready()) {
+            event.edit_original_response(dpp::message("스킵하려면 음악을 재생중이어야 합니다!"));
+            return;
+        }
+        v->voiceclient->stop_audio();
+        v->voiceclient->insert_marker();

-void commands::Skip::operator()(const dpp::slashcommand_t& event) {
-    dpp::voiceconn* v = event.from->get_voice(event.command.guild_id);
-
-    if (!v || !v->voiceclient || !v->voiceclient->is_ready()) {
-        return;
+        event.edit_original_response(dpp::message("스킵했습니다!"));
    }
-    v->voiceclient->skip_to_next_marker();

-    event.reply("스킵했습니다!");
-
-    return;
+    void Skip::init() {
+    }
 }
--- a/src/Manager/ThreadManager.cpp
+++ b/src/Manager/ThreadManager.cpp
--- a/src/Queue/MusicQueue.cpp
+++ b/src/Queue/MusicQueue.cpp
@@ -0,0 +1,115 @@
+#include <Queue/MusicQueue.hpp>
+#include <iostream>
+#include <algorithm>
+#include <Utils/QueuedMusicListEmbedProvider.hpp>
+
+namespace bumbleBee {
+
+void MusicQueue::enqueue(std::shared_ptr<MusicQueueElement> Element) {
+    std::lock_guard<std::mutex> lock(queueMutex);
+        queue.push_back(Element);
+    if (queue.size() == 1) // 이전에 하나도 없었다는 말이므로.
+        currentPlayingPosition = queue.begin(); // 첫번째 곡으로 iterator를 옮겨준다.
+}
+
+std::shared_ptr<MusicQueueElement> MusicQueue::dequeue() {
+    std::lock_guard<std::mutex> lock(queueMutex);
+    auto value = queue.front();
+    queue.pop_front();
+    return value;
+}
+std::list<std::shared_ptr<MusicQueueElement>>::iterator MusicQueue::findById(std::string id) {
+    std::lock_guard<std::mutex> lock(queueMutex);
+    int index = 0;
+    for (auto iter = queue.begin(); iter != queue.end(); iter++) {
+        if ((*iter).get()->id == id)
+            return iter;
+    }
+    return queue.end();
+}
+std::list<std::shared_ptr<MusicQueueElement>>::iterator MusicQueue::findByIndex(int index) {
+    std::lock_guard<std::mutex> lock(queueMutex);
+    if (index < 0)
+        return queue.end();
+    if (index == 0)
+        return currentPlayingPosition;
+    return std::next(queue.begin(), index - 1);
+}
+std::shared_ptr<MusicQueueElement> MusicQueue::nowplaying() {
+    std::lock_guard<std::mutex> lock(queueMutex);
+    if (currentPlayingPosition == queue.end())
+        return nullptr;
+    else
+        return *currentPlayingPosition;
+}
+std::list<std::shared_ptr<MusicQueueElement>>::iterator MusicQueue::next_music() {
+    std::lock_guard<std::mutex> lock(queueMutex);
+    if (currentPlayingPosition == --queue.end() && repeat)
+        currentPlayingPosition = queue.begin();
+    else if (currentPlayingPosition == --queue.end() && !repeat) // 반복이 꺼져있을 때 큐 재생이 끝난 경우
+        currentPlayingPosition = queue.end();
+    else if (currentPlayingPosition == queue.end() && !repeat) // 반복이 꺼져있고 현재 재생 곡이 없는데 새 곡이 들어왔을 경우
+        currentPlayingPosition = --queue.end();
+    else
+        ++currentPlayingPosition;
+    return currentPlayingPosition;
+}
+std::shared_ptr<MusicQueueElement> MusicQueue::jump_to_index(int idx) {
+    std::lock_guard<std::mutex> lock(queueMutex);
+    int index = 0;
+    for (auto iter = queue.begin(); iter != queue.end(); iter++) {
+        if (idx == index++) {
+            currentPlayingPosition = iter;
+            return *iter;
+        }
+    }
+    return std::shared_ptr<MusicQueueElement>();
+}
+void MusicQueue::clear() {
+    std::lock_guard<std::mutex> lock(queueMutex);
+    queue.clear();
+    currentPlayingPosition = queue.begin();
+}
+std::shared_ptr<MusicQueueElement> MusicQueue::erase(std::list<std::shared_ptr<MusicQueueElement>>::iterator it) {
+    std::lock_guard<std::mutex> lock(queueMutex);
+    if (it == queue.end())
+        return nullptr;
+    
+    if (currentPlayingPosition == it) {
+        auto removedValue = *it;
+        auto after = queue.erase(currentPlayingPosition++);
+        if (after == queue.end())
+            currentPlayingPosition = --queue.end();
+        return removedValue;
+    }
+    else {
+        auto removedValue = *it;
+        queue.erase(it);
+        return removedValue;
+    }
+}
+std::pair<std::shared_ptr<std::list<std::shared_ptr<MusicQueueElement>>>, std::list<std::shared_ptr<MusicQueueElement>>::iterator>
+    MusicQueue::getQueueCopy() {
+    std::lock_guard<std::mutex> lock(queueMutex);
+    std::shared_ptr<std::list<std::shared_ptr<MusicQueueElement>>> returnValue = std::make_shared<std::list<std::shared_ptr<MusicQueueElement>>>();
+
+    for (auto i = queue.begin(); i != queue.end(); i++)
+        returnValue->push_back(*i);
+
+    if (returnValue->begin() == returnValue->end() || currentPlayingPosition == queue.end())
+        return std::make_pair(returnValue, returnValue->end());
+
+    std::list<std::shared_ptr<MusicQueueElement>>::iterator iter = returnValue->begin();
+    std::advance(iter, std::distance(queue.begin(), currentPlayingPosition));
+
+    return std::make_pair(returnValue, iter);
+}
+int MusicQueue::size() {
+    std::lock_guard<std::mutex> lock(queueMutex);
+    return queue.size();
+}
+std::list<std::shared_ptr<MusicQueueElement>>::iterator MusicQueue::end() {
+    std::lock_guard<std::mutex> lock(queueMutex);
+    return queue.end();
+}
+}
--- a/src/Settings/SettingsManager.cpp
+++ b/src/Settings/SettingsManager.cpp
@@ -0,0 +1,124 @@
+#include <Settings/SettingsManager.hpp>
+#include <dpp/nlohmann/json.hpp>
+#include <Utils/ConsoleUtils.hpp>
+#include <fstream>
+#include <sstream>
+
+namespace bumbleBee {
+
+std::string SettingsManager::TOKEN = "";
+std::string SettingsManager::YTDLP_CMD = "./yt-dlp";
+std::string SettingsManager::FFMPEG_CMD = "./ffmpeg";
+dpp::loglevel SettingsManager::LOGLEVEL = dpp::ll_debug;
+bool SettingsManager::REGISTER_COMMAND = false;
+
+bool SettingsManager::validateToken() {
+    nlohmann::json response;
+    std::string curl = ConsoleUtils::safe_execute_command("/usr/bin/which", {"curl"}).front();
+    if (curl == "") {
+        std::cout << "curl is unavaliable. unresolable error please install curl." << std::endl;
+        return false;
+    }
+
+    std::string stresult = ConsoleUtils::safe_execute_command(curl, {
+        "-sX",
+        "GET",
+        "https://discord.com/api/v10/users/@me",
+        "-H",
+        "Authorization: Bot " + TOKEN + ""
+    }).front();
+    std::stringstream ss(stresult);
+    ss >> response;
+
+    if (response.contains("message") && response["message"] == "401: Unauthorized") {
+        std::cout << "Token is invalid" << std::endl;
+        return false;
+    }
+    else
+        return true;
+}
+
+bool SettingsManager::load() {
+    nlohmann::json configdocument;
+    try {
+        std::ifstream configfile("config.json");
+        if (!configfile) {
+            saveToFile();
+            return false;
+        }
+        configfile >> configdocument;
+
+        TOKEN = configdocument["TOKEN"];
+
+        if (!validateToken())
+            return false;
+
+        YTDLP_CMD = configdocument["YTDLP_CMD"];
+        FFMPEG_CMD = configdocument["FFMPEG_CMD"];
+
+        std::string level = configdocument["LOGLEVEL"];
+        
+        std::transform(level.begin(), level.end(), level.begin(), ::tolower);
+        if (level == "trace")
+            LOGLEVEL = dpp::ll_trace;
+        else if (level == "debug")
+            LOGLEVEL = dpp::ll_debug;
+        else if (level == "warning")
+            LOGLEVEL = dpp::ll_warning;
+        else if (level == "error")
+            LOGLEVEL = dpp::ll_error;
+        else if (level == "critical")
+            LOGLEVEL = dpp::ll_critical;
+        else // 값이 병신같을때 기본값으로 ll_info 부여
+            LOGLEVEL = dpp::ll_info;
+
+        REGISTER_COMMAND = configdocument["CLEAR_PREVIOUS_COMMAND"];
+    }
+    catch (const nlohmann::json::type_error& e) {
+        saveToFile();
+        return load();
+    }
+    catch (const nlohmann::json::parse_error& e) {
+        saveToFile();
+        return load();
+    }
+    return true;
+}
+
+void SettingsManager::saveToFile() {
+    nlohmann::json configdocument;
+
+    configdocument["TOKEN"] = TOKEN;
+    configdocument["YTDLP_CMD"] = YTDLP_CMD;
+    configdocument["FFMPEG_CMD"] = FFMPEG_CMD;
+
+    switch (LOGLEVEL) {
+    case dpp::ll_trace:
+        configdocument["LOGLEVEL"] = "trace";
+        break;
+    case dpp::ll_debug:
+        configdocument["LOGLEVEL"] = "debug";
+        break;
+    case dpp::ll_info:
+        configdocument["LOGLEVEL"] = "info";
+        break;
+    case dpp::ll_warning:
+        configdocument["LOGLEVEL"] = "warning";
+        break;
+    case dpp::ll_error:
+        configdocument["LOGLEVEL"] = "error";
+        break;
+    default:
+        configdocument["LOGLEVEL"] = "critical";
+        break;
+    }
+    
+    configdocument["CLEAR_PREVIOUS_COMMAND"] = REGISTER_COMMAND;
+
+    std::ofstream configFile("config.json");
+    if (configFile.is_open()) {
+        configFile << configdocument.dump(4);
+        configFile.close();
+    }
+}
+}
--- a/src/Utils/AsyncDownloadManager.cpp
+++ b/src/Utils/AsyncDownloadManager.cpp
@@ -0,0 +1,103 @@
+#include <Utils/AsyncDownloadManager.hpp>
+#include <sstream>
+#include "Utils/ConsoleUtils.hpp"
+#include "Settings/SettingsManager.hpp"
+#include <ogg/ogg.h>
+#include <oggz/oggz.h>
+#include <opus/opusfile.h>
+#include <memory>
+
+namespace bumbleBee {
+void AsyncDownloadManager::enqueueAsyncDL(std::pair<std::string, dpp::message> query) {
+    std::lock_guard<std::mutex> lock(dlQueueMutex);
+    downloadQueue.push(query);
+    dlQueueCondition.notify_one();
+}
+
+void AsyncDownloadManager::downloadWorker() {
+    std::ostringstream tid;
+    tid << std::this_thread::get_id();
+    while (true) {
+        //mutex lock
+        std::unique_lock<std::mutex> dlQueueLock(dlQueueMutex);
+        dlQueueCondition.wait(dlQueueLock, [&]{ return !downloadQueue.empty() || terminate; });
+        auto cluster = weak_cluster.lock();
+        if (weak_cluster.expired()) {
+            cluster->log(dpp::ll_error, "Missing cluster, terminating thread " + tid.str());
+            break;
+        }
+        if (terminate) {
+            cluster->log(dpp::ll_info, "Terminating thread " + tid.str());
+            break;
+        }
+        std::string query = downloadQueue.front().first;
+        dpp::message oRes = downloadQueue.front().second;
+        downloadQueue.pop();
+        dlQueueLock.unlock();
+
+        cluster->log(dpp::ll_info, "AsyncDownloadManager: " + query + " accepted.");
+
+        std::queue<std::string> ids =
+            ConsoleUtils::safe_execute_command(
+            SettingsManager::getYTDLP_CMD(), {
+            "--default-search",
+            "ytsearch",
+            "--flat-playlist",
+            "--skip-download",
+            "--quiet",
+            "--ignore-errors",
+            "--print",
+            "id",
+            query});
+
+        if (ids.size() >= 2) {
+            cluster->log(dpp::ll_info, query + " is playlist");
+            while (!ids.empty()) {
+                if (ids.front() == "") {
+                    ids.pop();
+                    continue;
+                }
+                cluster->log(dpp::ll_info, "Enqueuing playlist element " + ids.front());
+                enqueue(std::make_pair("https://youtu.be/" + ids.front(), oRes));
+                ids.pop();
+            }
+            continue;
+        }
+
+        std::queue<std::string> urls =
+            ConsoleUtils::safe_execute_command(SettingsManager::getYTDLP_CMD(), {
+            "-f",
+            "ba*",
+            "--print",
+            "urls",
+            "https://youtu.be/" + ids.front()
+        });
+
+        cluster->log(dpp::ll_debug, "url: " + urls.front());
+
+        FILE* stream;
+
+        // musicQueue->enqueue(std::make_shared<MusicQueueElement>(oRes, ids.front(), urls.front(), stream));
+
+        std::string downloadID = ids.front();
+
+        std::thread th([&, downloadID](){
+            if (terminate)
+                return;
+            std::ostringstream tid;
+            tid << std::this_thread::get_id();
+
+            cluster->log(dpp::ll_info, "Thread id: " + tid.str() + ": " + downloadID + " accepted.");
+
+            stream = ConsoleUtils::safe_open_pipe("./streamOpus.sh", {
+                SettingsManager::getYTDLP_CMD(),
+                downloadID,
+                SettingsManager::getFFMPEG_CMD()
+            });
+
+            cluster->log(dpp::ll_info, "Thread id: " + tid.str() + " Opened stream: " + downloadID);
+        });
+        th.detach();
+    }
+}
+}
--- a/src/Utils/ThreadPool.cpp
+++ b/src/Utils/ThreadPool.cpp
@@ -0,0 +1,28 @@
+#include "Utils/ThreadPool.hpp"
+
+namespace bumbleBee {
+
+template <typename FuncRet, typename FuncParam>
+ThreadPool<FuncRet, FuncParam>::ThreadPool(std::int32_t threadCount) {
+    this.threadCount = threadCount;
+    while (threadCount--) {
+        threadPool.
+    }
+}
+
+template <typename FuncRet, typename FuncParam>
+void ThreadPool<FuncRet, FuncParam>::gracefullAllStop() {
+    std::unique_lock<std::mutex> lock(mutex_);
+    for (auto& thread : threadPool_) {
+        terminating_[thread] = true;
+        condition_.notify_all();
+    }
+    for (auto& thread : threadPool_) {
+        if (thread.joinable()) {
+            thread.join();
+        }
+    }
+    threadPool_.clear();
+    terminating_.clear();
+}
+}
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -1,19 +1,9 @@
-#include <BumbleCeepp.hpp>
-#include <dpp/nlohmann/json.hpp>
-#include <memory>
+#include <iostream>
+#include <BumbleBee.hpp>
+#include <thread>

-using json = nlohmann::json;
-
-int main()
-{
-    json configdocument;
-    std::ifstream configfile("config.json");
-    configfile >> configdocument;
-
-    std::shared_ptr<BumbleCeepp> bumbleBee = std::make_shared<BumbleCeepp>(
-        configdocument["token"], configdocument["dbURL"], configdocument["user"], configdocument["password"]);
-
-    bumbleBee->start();
-    
+int main(int argc, char* argv[]) {
+    bumbleBee::BumbleBee bot;
+    bot.start();
    return 0;
 }
--- a/src/out
+++ b/src/out
--- a/src/test.py
+++ b/src/test.py
@@ -1,20 +0,0 @@
-import yt_dlp
-import json
-import sys
-
-if len(sys.argv) != 2:
-    sys.exit()
-
-ydl_opts = {
-    'quiet': True,
-    'clean_infojson': False,
-    'default_search': 'ytsearch',
-    'format': '251',
-    'outtmpl': {'default': 'Temp/%(id)s.temp'},
-    'overwrites': False,
-    'writeinfojson': True }
-
-with yt_dlp.YoutubeDL(ydl_opts) as ydl:
-    info = ydl.extract_info(sys.argv[1], download=False)
-    with open("out", "w") as f:
-        f.write(json.dumps(ydl.sanitize_info(info)))
--- a/src/yt-download.py
+++ b/src/yt-download.py
@@ -1,47 +0,0 @@
-import yt_dlp
-import sys
-import os
-import json
-
-if len(sys.argv) != 2:
-    sys.exit()
-
-ydl_opts = {
-    'quiet': True,
-    'clean_infojson': False,
-    'default_search': 'ytsearch',
-    'format': '251',
-    'outtmpl': {'default': 'Temp/%(id)s.temp'},
-    'overwrites': False,
-    'writeinfojson': True }
-
-with yt_dlp.YoutubeDL(ydl_opts) as ydl:
-    info = ydl.extract_info(sys.argv[1], download=False)
-    id = list()
-    with open("out", "w") as f:
-        f.write(json.dumps(ydl.sanitize_info(info)))
-    with open("Music/Archive", "r") as f:
-        ArchiveList = f.read().split("\n")
-        if "entries" in info:
-            if len(info["entries"]) != 0:
-                for entry in info["entries"]:
-                    if entry["id"] not in ArchiveList:
-                        ydl.download(entry["webpage_url"])
-                        os.system("echo " + entry["id"] + " >> Music/Archive")
-                        os.system("yes n 2>/dev/null | ffmpeg -hide_banner -loglevel error -i \"" + "Temp/" + entry["id"] + ".temp" + "\" -c copy Music/" + entry["id"] + ".ogg")
-                        os.system("mv Temp/" + entry["id"] + ".temp.info.json Music/" + entry["id"] + ".info.json")
-                    id.append(entry["id"])
-        else:
-            if info["id"] not in ArchiveList:
-                ydl.download(info["webpage_url"])
-                os.system("echo " + info["id"] + " >> Music/Archive")
-                os.system("yes n 2>/dev/null | ffmpeg -hide_banner -loglevel error -i \"" + "Temp/" + info["id"] + ".temp" + "\" -c copy Music/" + info["id"] + ".ogg")
-                os.system("mv Temp/" + info["id"] + ".temp.info.json Music/" + info["id"] + ".info.json")
-            id.append(info["id"])
-
-    os.system("rm -f Temp/*.temp")
-    os.system("rm -f Temp/*.json")
-
-    with open("Temp/CurMusic", "w") as f:
-        for item in id:
-            f.write(item + "\n")
--- a/streamOpus.sh
+++ b/streamOpus.sh
@@ -0,0 +1,12 @@
+#!/bin/bash
+
+YTDLP_CMD=$1
+FFMPEG_CMD=$2
+URL=$3
+
+$YTDLP_CMD -o - --quiet --ignore-errors -f bestaudio $URL 2>/dev/null | \
+$FFMPEG_CMD -hwaccel vaapi -i - -loglevel quiet -hide_banner -c:a copy -f opus - || \
+$YTDLP_CMD -o - --quiet --ignore-errors -f bestaudio $URL 2>/dev/null | \
+$FFMPEG_CMD -hwaccel vaapi -i - -loglevel quiet -hide_banner -f opus -c:a libopus -b:a 128k -ar 48000 -ac 2 -
+
+#  -loglevel quiet
--- a/youtube-search.py
+++ b/youtube-search.py
@@ -1,54 +0,0 @@
-import sys
-
-if len(sys.argv) != 2:
-    sys.exit()
-
-import urllib.parse
-
-def uri_validator(x):
-    try:
-        result = urllib.parse.urlparse(x)
-        return all([result.scheme, result.netloc])
-    except AttributeError:
-        return False
-
-#URL인 경우
-if uri_validator(sys.argv[1]) == True:
-    result = urllib.parse.urlparse(sys.argv[1])
-
-    #youtu.be짧은 주소인 경우
-    if (result.netloc == 'youtu.be'):
-        print(result.path[1:13])
-
-    #플레이리스트인 경우
-    if result.path == '/playlist':
-        import re, requests
-
-        response = requests.get("https://www.youtube.com/playlist?" + result.query)
-
-        pattern = re.compile('"videoId":"(.{11})"')
-
-        IDlist = set(pattern.findall(response.text))
-
-        # list_to_return = list()
-        # list_to_return.append(IDlist[0])
-        # list_to_return_count = 0
-        # for it in range(0, len(list_to_return)):
-        #     if (list_to_return[list_to_return_count] == IDlist[it]):
-        #         continue
-        #     else:
-        #         list_to_return[list_to_return_count] = IDlist[it]
-        #         list_to_return_count += 1
-            
-        for it in IDlist:
-            print(it)
-    #영상인 경우
-    elif result.path == '/watch':
-        print(result.query[2:13])
-else:
-    from youtube_search import YoutubeSearch
-
-    results = YoutubeSearch(sys.argv[1], max_results=10).to_dict()
-
-    #검색 결과가 없는 경우 확인 불가
-    print(results[0]["id"])
--- a/BIN
+++ b/BIN
--- a/yt-download.py
+++ b/yt-download.py
@@ -1,19 +0,0 @@
-import yt_dlp
-import sys
-import os
-
-if len(sys.argv) != 2:
-    sys.exit()
-
-ydl_opts = {
-    'quiet': True,
-    'format': '251',
-    'outtmpl': {'default': 'Temp/' + sys.argv[1]},
-    'writeinfojson': True
-}
-
-with yt_dlp.YoutubeDL(ydl_opts) as ydl:
-    info = ydl.extract_info("https://www.youtube.com/watch?v=" + sys.argv[1])
-    os.system("yes n 2>/dev/null | ffmpeg -hide_banner -loglevel error -i \"" + "Temp/" + sys.argv[1] + "\" -c copy Music/" + sys.argv[1] + ".ogg > /dev/null 2> /dev/null")
-    os.system("mv Temp/" + sys.argv[1] + ".info.json Music/" + sys.argv[1] + ".info.json > /dev/null 2> /dev/null")
-    os.system("rm -rf Temp/ > /dev/null 2> /dev/null")
Author	SHA1	Message	Date
HappyTanuki	c59fef1d0b	일단 저장	2025-08-28 20:46:37 +09:00
HappyTanuki	125fbcc49c	TODO 추가가	2025-03-09 17:29:09 +09:00
HappyTanuki	4915a5c3b8	TODO리스트는 늘어만 간다..	2025-03-09 17:27:42 +09:00
HappyTanuki	4435337f40	TODO 추가가	2025-03-07 17:25:58 +09:00
HappyTanuki	77d16c1cdb	아마도? 쉘 인젝션 취약점 픽스	2025-03-07 17:19:58 +09:00
HappyTanuki	5760f1afdc	todo 추가가	2025-02-13 17:42:17 +09:00
Kim Minsu	bb6cd89f51	Update README.md	2025-02-13 17:31:17 +09:00
HappyTanuki	2a238f804d	사람 나갈 때 음악 꺼지는 문제 해결결	2025-02-13 17:22:42 +09:00
HappyTanuki	ea7d42638e	코드 리팩터링 중..	2025-02-13 17:18:03 +09:00
HappyTanuki	30f97e3dfb	3차 코드 리팩터터	2025-02-13 17:01:38 +09:00
HappyTanuki	17236f32b5	도커파일 이미지 크기최적화	2025-02-13 16:54:10 +09:00
HappyTanuki	00134ee7b1	2차 리팩터터	2025-02-13 16:50:03 +09:00
HappyTanuki	52146c1f6a	코드 가독성 리팩터	2025-02-13 16:43:11 +09:00
HappyTanuki	bf0268c1e9	Merge branch 'master' of github.com:HappyTanuki/BumbleCee	2025-02-03 01:42:06 +09:00
HappyTanuki	2f5185e0c3	큐 출력 스타일 변경	2025-02-03 01:42:02 +09:00
Kim Minsu	96a4096971	Update README.md	2025-02-03 01:32:55 +09:00
Kim Minsu	ec65b550e6	Update README.md	2025-02-03 01:32:19 +09:00
HappyTanuki	14db2a31e8	와 이제 진짜 진짜 버그 다 고친 듯?	2025-02-02 23:55:47 +09:00
HappyTanuki	1af829c711	Merge branch 'master' of github.com:HappyTanuki/BumbleCee	2025-02-02 07:51:56 +09:00
HappyTanuki	46c59d40de	도커허브 업로드 자동화 구현	2025-02-02 07:51:52 +09:00
Kim Minsu	b08641f87e	Update README.md	2025-02-02 07:10:21 +09:00
Kim Minsu	1ca928c4df	Update README.md	2025-02-02 07:09:57 +09:00
HappyTanuki	2935a844a0	아직 read loop ended는 못잡았지만 아무튼 완성(진) 일단 셔플 빼그 기능은 다 작동하니 된 게 아닐까?	2025-02-02 06:37:31 +09:00
HappyTanuki	0cb7ea8225	완성(준)	2025-02-01 23:50:49 +09:00
HappyTanuki	7e43900f22	스트리밍 구현 끝	2025-02-01 03:36:31 +09:00
HappyTanuki	c2cb16c6d7	일단은 임시저장, 스트리밍의 실마리를 잡았다	2025-01-30 22:57:01 +09:00
HappyTanuki	3186561818	임시저장	2025-01-30 01:11:26 +09:00
HappyTanuki	30569f4472	비동기 다운로드 구현 완료	2024-10-19 05:06:21 +09:00
HappyTanuki	b4476c68d7	중간저장(다시 큐 방식으로 돌아가되, 실시간 스트리밍 방식으로 비동기 처리를 구현할 것임)	2024-10-19 01:12:19 +09:00