settings, token entry, receive READY

4 files changed, 123 insertions, 7 deletions

diff --git a/discord/discord.cpp b/discord/discord.cpp
index cd1e723..42c6550 100644
--- a/discord/discord.cpp
+++ b/discord/discord.cpp
@@ -1,10 +1,18 @@
+#include "../abaddon.hpp"
 #include "discord.hpp"
+#include <cassert>
 
-DiscordClient::DiscordClient() {}
+DiscordClient::DiscordClient() {
+    LoadEventMap();
+}
+
+void DiscordClient::SetAbaddon(Abaddon *ptr) {
+    m_abaddon = ptr;
+}
 
 void DiscordClient::Start() {
-    if (m_client_connected)
-        throw std::runtime_error("attempt to start client twice consecutively");
+    assert(!m_client_connected);
+    assert(!m_websocket.IsOpen());
 
     m_client_connected = true;
     m_websocket.StartConnection(DiscordGateway);
@@ -13,9 +21,11 @@ void DiscordClient::Start() {
 
 void DiscordClient::Stop() {
     if (!m_client_connected) return;
+
     m_heartbeat_waiter.kill();
     m_heartbeat_thread.join();
     m_client_connected = false;
+    m_websocket.Stop();
 }
 
 bool DiscordClient::IsStarted() const {
@@ -36,16 +46,33 @@ void DiscordClient::HandleGatewayMessage(nlohmann::json j) {
             HelloMessageData d = m.Data;
             m_heartbeat_msec = d.HeartbeatInterval;
             m_heartbeat_thread = std::thread(std::bind(&DiscordClient::HeartbeatThread, this));
+            SendIdentify();
         } break;
         case GatewayOp::HeartbeatAck: {
             m_heartbeat_acked = true;
         } break;
+        case GatewayOp::Event: {
+            auto iter = m_event_map.find(m.Type);
+            if (iter == m_event_map.end()) {
+                printf("Unknown event %s\n", m.Type.c_str());
+                break;
+            }
+            switch (iter->second) {
+                case GatewayEvent::READY: {
+                    HandleGatewayReady(m);
+                }
+            }
+        } break;
         default:
             printf("Unknown opcode %d\n", m.Opcode);
             break;
     }
 }
 
+void DiscordClient::HandleGatewayReady(const GatewayMessage &msg) {
+
+}
+
 void DiscordClient::HeartbeatThread() {
     while (m_client_connected) {
         if (!m_heartbeat_acked) {
@@ -57,13 +84,28 @@ void DiscordClient::HeartbeatThread() {
         HeartbeatMessage msg;
         msg.Sequence = m_last_sequence;
         nlohmann::json j = msg;
-        m_websocket.Send(j.dump());
+        m_websocket.Send(j);
 
         if (!m_heartbeat_waiter.wait_for(std::chrono::milliseconds(m_heartbeat_msec)))
             break;
     }
 }
 
+void DiscordClient::SendIdentify() {
+    auto token = m_abaddon->GetDiscordToken();
+    assert(token.size());
+    IdentifyMessage msg;
+    msg.Properties.OS = "OpenBSD";
+    msg.Properties.Device = GatewayIdentity;
+    msg.Properties.Browser = GatewayIdentity;
+    msg.Token = token;
+    m_websocket.Send(msg);
+}
+
+void DiscordClient::LoadEventMap() {
+    m_event_map["READY"] = GatewayEvent::READY;
+}
+
 void from_json(const nlohmann::json &j, GatewayMessage &m) {
     j.at("op").get_to(m.Opcode);
     m.Data = j.at("d");
@@ -76,6 +118,22 @@ void from_json(const nlohmann::json &j, HelloMessageData &m) {
     j.at("heartbeat_interval").get_to(m.HeartbeatInterval);
 }
 
+void to_json(nlohmann::json &j, const IdentifyProperties &m) {
+    j["$os"] = m.OS;
+    j["$browser"] = m.Browser;
+    j["$device"] = m.Device;
+}
+
+void to_json(nlohmann::json &j, const IdentifyMessage &m) {
+    j["op"] = GatewayOp::Identify;
+    j["d"] = nlohmann::json::object();
+    j["d"]["token"] = m.Token;
+    j["d"]["properties"] = m.Properties;
+
+    if (m.LargeThreshold)
+        j["d"]["large_threshold"] = m.LargeThreshold;
+}
+
 void to_json(nlohmann::json &j, const HeartbeatMessage &m) {
     j["op"] = GatewayOp::Heartbeat;
     if (m.Sequence == -1)
diff --git a/discord/discord.hpp b/discord/discord.hpp
index 692d57b..5a2d256 100644
--- a/discord/discord.hpp
+++ b/discord/discord.hpp
@@ -2,13 +2,20 @@
 #include "websocket.hpp"
 #include <nlohmann/json.hpp>
 #include <thread>
+#include <unordered_map>
 
 enum class GatewayOp : int {
+    Event = 0,
     Heartbeat = 1,
+    Identify = 2,
     Hello = 10,
     HeartbeatAck = 11,
 };
 
+enum class GatewayEvent : int {
+    READY,
+};
+
 struct GatewayMessage {
     GatewayOp Opcode;
     nlohmann::json Data;
@@ -23,6 +30,28 @@ struct HelloMessageData {
     friend void from_json(const nlohmann::json &j, HelloMessageData &m);
 };
 
+struct ReadyEventData {
+    std::string AnalyticsToken; // opt
+
+};
+
+struct IdentifyProperties {
+    std::string OS;
+    std::string Browser;
+    std::string Device;
+
+    friend void to_json(nlohmann::json &j, const IdentifyProperties &m);
+};
+
+struct IdentifyMessage : GatewayMessage {
+    std::string Token;
+    IdentifyProperties Properties;
+    bool DoesSupportCompression = false;
+    int LargeThreshold = 0;
+
+    friend void to_json(nlohmann::json &j, const IdentifyMessage &m);
+};
+
 struct HeartbeatMessage : GatewayMessage {
     int Sequence;
 
@@ -49,23 +78,32 @@ private:
     bool terminate = false;
 };
 
+class Abaddon;
 class DiscordClient {
 public:
     static const constexpr char *DiscordGateway = "wss://gateway.discord.gg/?v=6&encoding=json";
     static const constexpr char *DiscordAPI = "https://discord.com/api";
+    static const constexpr char *GatewayIdentity = "Discord";
 
 public:
     DiscordClient();
+    void SetAbaddon(Abaddon *ptr);
     void Start();
     void Stop();
     bool IsStarted() const;
 
 private:
     void HandleGatewayMessage(nlohmann::json msg);
+    void HandleGatewayReady(const GatewayMessage &msg);
     void HeartbeatThread();
+    void SendIdentify();
+
+    Abaddon *m_abaddon = nullptr;
 
     Websocket m_websocket;
     bool m_client_connected = false;
+    std::unordered_map<std::string, GatewayEvent> m_event_map;
+    void LoadEventMap();
 
     std::thread m_heartbeat_thread;
     int m_last_sequence = -1;
diff --git a/discord/websocket.cpp b/discord/websocket.cpp
index 3590db3..01d01ca 100644
--- a/discord/websocket.cpp
+++ b/discord/websocket.cpp
@@ -10,21 +10,38 @@ void Websocket::StartConnection(std::string url) {
     m_websocket.start();
 }
 
+void Websocket::Stop() {
+    m_websocket.stop();
+}
+
+bool Websocket::IsOpen() const {
+    auto state = m_websocket.getReadyState();
+    return state == ix::ReadyState::Open;
+}
+
 void Websocket::SetJSONCallback(JSONCallback_t func) {
     m_json_callback = func;
 }
 
 void Websocket::Send(const std::string &str) {
+    printf("sending %s\n", str.c_str());
     m_websocket.sendText(str);
 }
 
+void Websocket::Send(const nlohmann::json &j) {
+    Send(j.dump());
+}
+
 void Websocket::OnMessage(const ix::WebSocketMessagePtr &msg) {
     switch (msg->type) {
-        case ix::WebSocketMessageType::Message:
-            printf("%s\n", msg->str.c_str());
+        case ix::WebSocketMessageType::Message: {
+            if (msg->str.size() > 1000)
+                printf("%s\n", msg->str.substr(0, 1000).c_str());
+            else
+                printf("%s\n", msg->str.c_str());
             auto obj = nlohmann::json::parse(msg->str);
             if (m_json_callback)
                 m_json_callback(obj);
-            break;
+        } break;
     }
 }
diff --git a/discord/websocket.hpp b/discord/websocket.hpp
index 47a60d5..dc8cbec 100644
--- a/discord/websocket.hpp
+++ b/discord/websocket.hpp
@@ -13,6 +13,9 @@ public:
     using JSONCallback_t = std::function<void(nlohmann::json)>;
     void SetJSONCallback(JSONCallback_t func);
     void Send(const std::string &str);
+    void Send(const nlohmann::json &j);
+    void Stop();
+    bool IsOpen() const;
 
 private:
     void OnMessage(const ix::WebSocketMessagePtr &msg);