beniocord.js 2.0.6 → 2.0.8

package/Client.js

@@ -23,6 +23,7 @@ let global = {
   token: "",
   apiUrl: "https://api-bots.beniocord.site"
 };
+
 /**
  * @fires Client#ready
  * @fires Client#messageCreate
@@ -40,14 +41,17 @@ class Client extends EventEmitter {
       throw new ClientError("Valid token is required", "INVALID_TOKEN");
     }
 
-    // this.token = token.trim();
+    // Global configuration
     global.token = token.trim();
-    // this.apiUrl = "https://api-bots.beniocord.site";
+
+    // Client state
     this.socket = null;
     this.user = null;
     this.isConnected = false;
     this.isReady = false;
+    this.status = 'online';
 
+    // Configuration options
     this.config = {
       connectionTimeout: 15000,
       requestTimeout: 10000,
@@ -56,18 +60,21 @@ class Client extends EventEmitter {
     };
 
     this.retryCount = 0;
+    this.heartbeatInterval = null;
 
+    // Cache system
     this.cache = {
       users: new Map(),
       channels: new Map(),
       messages: new Map(),
       emojis: new Map(),
       stickers: new Map(),
-      presence: new Map(),
     };
 
+    // Track sent messages to avoid duplicates
     this._sentMessages = new Set();
 
+    // Setup axios instance
     this._axios = axios.create({
       baseURL: global.apiUrl,
       timeout: this.config.requestTimeout,
@@ -84,59 +91,22 @@ class Client extends EventEmitter {
       error => this._handleAxiosError(error)
     );
 
+    // Clean up sent messages cache periodically
     setInterval(() => {
       if (this._sentMessages.size > 1000) {
         this._sentMessages.clear();
       }
     }, 30 * 60 * 1000);
-
   }
 
-  _handleAxiosError(error) {
-    if (error.response) {
-      const { status, data } = error.response;
-      const errorCode = data?.error || 'UNKNOWN_ERROR';
-      const errorMessage = data?.message || error.message;
-
-      switch (status) {
-        case 401:
-          throw new ClientError(
-            errorMessage || "Invalid or expired token",
-            errorCode || "UNAUTHORIZED"
-          );
-        case 403:
-          throw new ClientError(
-            errorMessage || "Token lacks necessary permissions",
-            errorCode || "FORBIDDEN"
-          );
-        case 404:
-          throw new ClientError(
-            errorMessage || "Resource not found",
-            errorCode || "NOT_FOUND"
-          );
-        case 429:
-          throw new ClientError(
-            errorMessage || "Rate limit exceeded",
-            errorCode || "RATE_LIMITED"
-          );
-        default:
-          throw new ClientError(
-            errorMessage || "API request failed",
-            errorCode
-          );
-      }
-    } else if (error.code === 'ECONNABORTED') {
-      throw new ClientError("Request timeout", "TIMEOUT");
-    } else if (error.code === 'ECONNREFUSED') {
-      throw new ClientError("Cannot connect to API server", "CONNECTION_REFUSED");
-    } else {
-      throw new ClientError(
-        error.message || "Network error",
-        error.code || "NETWORK_ERROR"
-      );
-    }
-  }
+  // ============================================================================
+  // PUBLIC API METHODS - Authentication & Connection
+  // ============================================================================
 
+  /**
+   * Validates the bot token with the API
+   * @returns {Promise<Object>} Validation response
+   */
   async validateToken() {
     try {
       const response = await this._axios.get('/api/auth/verify');
@@ -149,6 +119,10 @@ class Client extends EventEmitter {
     }
   }
 
+  /**
+   * Logs in the bot and establishes connection
+   * @returns {Promise<User>} The bot user object
+   */
   async login() {
     try {
       await this.validateToken();
@@ -164,6 +138,8 @@ class Client extends EventEmitter {
         );
       }
 
+      await this._joinAllChannelRooms();
+
       this.isReady = true;
       this.emit("ready", this.user);
 
@@ -174,148 +150,21 @@ class Client extends EventEmitter {
     }
   }
 
-  async _connectSocket() {
-    return new Promise((resolve, reject) => {
-      const connectionTimeout = setTimeout(() => {
-        if (this.socket) {
-          this.socket.disconnect();
-        }
-        reject(new ClientError(
-          `Connection timeout - failed to connect within ${this.config.connectionTimeout}ms`,
-          "CONNECTION_TIMEOUT"
-        ));
-      }, this.config.connectionTimeout);
-
-      this.socket = io(global.apiUrl, {
-        auth: { token: global.token },
-        extraHeaders: { 'Origin': global.apiUrl },
-        timeout: 5000,
-        reconnection: true,
-        reconnectionDelay: this.config.reconnectionDelay,
-        reconnectionAttempts: this.config.maxRetries,
-        transports: ['websocket', 'polling']
-      });
-
-      this.socket.on("connect", () => {
-        clearTimeout(connectionTimeout);
-        this.isConnected = true;
-        this.retryCount = 0;
-        this._setupSocketHandlers();
-        this._startHeartbeat();
-        resolve();
-      });
-
-      this.socket.on("disconnect", (reason) => {
-        this.isConnected = false;
-        this._stopHeartbeat(); // Para o heartbeat
-        this.emit("disconnect", reason);
-
-        if (reason === "io server disconnect") {
-          this.emit("error", new ClientError(
-            "Disconnected by server - token may be invalid or revoked",
-            "SERVER_DISCONNECT"
-          ));
-        }
-      });
-
-      this.socket.on("connect_error", (error) => {
-        clearTimeout(connectionTimeout);
-        this.retryCount++;
-
-        let errorCode = "CONNECTION_ERROR";
-        let errorMessage = "Failed to connect to server";
-
-        const errorStr = error.message.toLowerCase();
-
-        if (errorStr.includes("401") || errorStr.includes("unauthorized")) {
-          errorCode = "UNAUTHORIZED";
-          errorMessage = "Invalid token";
-        } else if (errorStr.includes("403") || errorStr.includes("forbidden")) {
-          errorCode = "FORBIDDEN";
-          errorMessage = "Token expired or revoked";
-        } else if (errorStr.includes("timeout")) {
-          errorCode = "TIMEOUT";
-          errorMessage = "Connection timeout";
-        }
-
-        const clientError = new ClientError(errorMessage, errorCode);
-        this.emit("error", clientError);
-
-        if (this.retryCount >= this.config.maxRetries) {
-          reject(clientError);
-        }
-      });
-
-      this.socket.on("reconnect", (attemptNumber) => {
-        this.isConnected = true;
-        this._startHeartbeat();
-        this.emit("reconnect", attemptNumber);
-      });
-
-      this.socket.on("reconnect_error", (error) => {
-        this.emit("reconnectError", error);
-      });
-
-      this.socket.on("reconnect_failed", () => {
-        this._stopHeartbeat();
-        this.emit("error", new ClientError(
-          "Failed to reconnect after maximum attempts",
-          "RECONNECT_FAILED"
-        ));
-      });
-    });
-  }
-
-  /**
-   * Inicia o sistema de heartbeat
-   * @private
-   */
-  _startHeartbeat() {
-    // Para qualquer heartbeat existente
-    this._stopHeartbeat();
-
-    // Intervalo de 30 segundos (mesmo do frontend)
-    const HEARTBEAT_INTERVAL = 30000;
-
-    this.heartbeatInterval = setInterval(() => {
-      if (this.socket && this.isConnected) {
-        // Envia heartbeat simples para bots
-        // Bots não precisam de isPageVisible/isAppFocused
-        this.socket.emit("presence:heartbeat", {
-          status: this.status || "online",
-          clientType: "bot" // Identifica como bot
-        });
-      }
-    }, HEARTBEAT_INTERVAL);
-
-    // Envia primeiro heartbeat imediatamente
-    if (this.socket && this.isConnected) {
-      this.socket.emit("presence:heartbeat", {
-        status: this.status || "online",
-        clientType: "bot"
-      });
-    }
-  }
-
   /**
-   * Para o sistema de heartbeat
-   * @private
+   * Checks if the client is ready and connected
+   * @returns {boolean} True if ready and connected
    */
-  _stopHeartbeat() {
-    if (this.heartbeatInterval) {
-      clearInterval(this.heartbeatInterval);
-      this.heartbeatInterval = null;
-    }
+  ready() {
+    return this.isReady && this.isConnected && this.socket && this.socket.connected;
   }
 
   /**
-   * Desconecta o cliente e limpa recursos
+   * Disconnects the bot from the server
    */
   disconnect() {
     this._stopHeartbeat();
 
     if (this.socket) {
-      // Notifica o servidor antes de desconectar
       if (this.isConnected) {
         this.socket.emit("presence:update", {
           isPageVisible: false,
@@ -342,351 +191,280 @@ class Client extends EventEmitter {
     this.isReady = false;
   }
 
+  // ============================================================================
+  // PUBLIC API METHODS - User & Bot Status
+  // ============================================================================
 
-  _setupSocketHandlers() {
-    this._removeSocketHandlers();
+  /**
+   * Sets the bot's status
+   * @param {string} status - Status: "online", "away", "dnd", "offline"
+   */
+  async setStatus(status) {
+    const validStatuses = ["online", "offline", "away", "dnd"];
 
-    this.socket.on('message:new', async (data) => {
-      try {
-        if (this._sentMessages.has(data.id)) {
-          this._sentMessages.delete(data.id);
-          return;
-        }
+    if (!validStatuses.includes(status)) {
+      throw new ClientError(
+        `Invalid status. Valid statuses are: ${validStatuses.join(", ")}`,
+        "INVALID_STATUS"
+      );
+    }
 
-        const msg = await this._processSocketMessage(data);
-        this._cacheMessage(msg);
-        this.emit("messageCreate", msg);
-      } catch (error) {
-        this.emit("error", error);
-      }
-    });
+    this._ensureConnected();
+    this.status = status;
+    this.socket.emit('status:update', { status });
+  }
 
-    this.socket.on('message:deleted', (data) => {
-      const { messageId } = data;
-      this._markMessageDeleted(messageId);
-      this.emit('messageDelete', data);
-    });
+  /**
+   * Fetches information about the bot user
+   * @param {boolean} force - Force fetch from API instead of cache
+   * @returns {Promise<User>} Bot user object
+   */
+  async fetchMe(force = false) {
+    if (!force && this.user) {
+      return this.user;
+    }
 
-    this.socket.on('message:edited', (data) => {
-      const { messageId, content, editedAt } = data;
-      this._updateMessageContent(messageId, content, editedAt);
-      this.emit('messageEdit', data);
-    });
+    try {
+      const res = await this._axios.get('/api/users/me');
+      const user = new User(res.data, this);
+      this.cache.users.set(user.id, user);
+      this.user = user;
+      return user;
+    } catch (error) {
+      throw error instanceof ClientError
+        ? error
+        : new ClientError(error.message, "FETCH_ME_ERROR");
+    }
+  }
 
-    this.socket.on('typing:user-start', (data) => {
-      this.emit('typingStart', data);
-    });
+  /**
+   * Fetches a user by ID
+   * @param {string} id - User ID
+   * @param {boolean} force - Force fetch from API instead of cache
+   * @returns {Promise<User>} User object
+   */
+  async fetchUser(id, force = false) {
+    if (!force && this.cache.users.has(id)) {
+      return this.cache.users.get(id);
+    }
 
-    this.socket.on('typing:user-stop', (data) => {
-      this.emit('typingStop', data);
-    });
+    try {
+      const res = await this._axios.get(`/api/users/${id}`);
+      const user = new User(res.data, this);
+      this.cache.users.set(user.id, user);
+      return user;
+    } catch (error) {
+      throw error instanceof ClientError
+        ? error
+        : new ClientError(error.message, "FETCH_USER_ERROR");
+    }
+  }
 
-    this.socket.on('user:status-update', (data) => {
-      this._updateUserStatus(data);
-      this.emit('userStatusUpdate', data);
-    });
-
-    this.socket.on('presence:update', (data) => {
-      this.cache.presence.set(data.userId, data);
-      this.emit('presenceUpdate', data);
-    });
-
-    this.socket.on('member:join', async (data) => {
-      const member = await this.fetchUser(data.memberId).catch(() => null);
-      const channel = await this.fetchChannel(data.channelId).catch(() => null);
-
-      if (data.addedBy) {
-        data.addedBy = new User(data.addedBy, this);
-      }
-
-      data.member = member;
-      data.channel = channel;
-
-      // 🔥 Se EU fui adicionado ao canal
-      if (data.memberId === this.user?.id) {
-        // Adiciona o canal na cache se não existir
-        if (channel && !this.cache.channels.has(data.channelId)) {
-          this.cache.channels.set(data.channelId, channel);
-        }
-
-        // Entra na room do canal no socket
-        this.socket.emit('channel:join', { channelId: data.channelId });
-      }
-
-      // 🔥 Se o canal já existe na cache, adiciona o membro nele
-      if (channel && member) {
-        // Assumindo que o Channel tem uma lista/Map de membros
-        if (!channel.members) {
-          channel.members = new Map();
-        }
-        channel.members.set(member.id, member);
-      }
-
-      this.emit('memberJoin', data);
-      console.log('join', data);
-    });
-
-    this.socket.on('member:leave', async (data) => {
-      const member = await this.fetchUser(data.memberId).catch(() => null);
-      const channel = await this.fetchChannel(data.channelId).catch(() => null);
-
-      if (data.removedBy) {
-        data.removedBy = new User(data.removedBy, this);
-      }
-
-      data.member = member;
-      data.channel = channel;
-
-      // 🔥 Se EU fui removido do canal
-      if (data.memberId === this.user?.id) {
-        // Remove o canal da cache
-        this.cache.channels.delete(data.channelId);
-
-        // Sai da room do canal no socket
-        this.socket.emit('channel:leave', { channelId: data.channelId });
-      }
-
-      // 🔥 Se o canal existe na cache, remove o membro dele
-      if (channel && member && channel.members) {
-        channel.members.delete(member.id);
-      }
+  // ============================================================================
+  // PUBLIC API METHODS - Channels
+  // ============================================================================
 
-      this.emit('memberLeave', data);
-      console.log('leave', data);
-    });
-
-    this.socket.on('channel:update', (data) => {
-      this._updateChannel(data);
-      this.emit('channelUpdate', data);
-    });
-
-    this.socket.on('channel:delete', (data) => {
-      this.cache.channels.delete(data.channelId);
-      this.emit('channelDelete', data);
-    });
+  /**
+   * Fetches all available channels
+   * @returns {Promise<Channel[]>} Array of channel objects
+   */
+  async fetchChannels() {
+    try {
+      const res = await this._axios.get('/api/channels');
+      const channels = res.data.map(c => {
+        const channel = new Channel(c, this);
+        this.cache.channels.set(channel.id, channel);
+        return channel;
+      });
 
-    this.socket.on('rate:limited', (data) => {
-      this.emit('rateLimited', data);
-    });
+      return channels;
+    } catch (error) {
+      throw error instanceof ClientError ? error : new ClientError(error.message, "FETCH_CHANNELS_ERROR");
+    }
   }
 
-  _removeSocketHandlers() {
-    if (!this.socket) return;
+  /**
+   * Fetches a specific channel by ID
+   * @param {string} id - Channel ID
+   * @param {boolean} force - Force fetch from API instead of cache
+   * @returns {Promise<Channel>} Channel object
+   */
+  async fetchChannel(id, force = false) {
+    if (!force && this.cache.channels.has(id)) {
+      return this.cache.channels.get(id);
+    }
 
-    // Remove todos os listeners customizados
-    this.socket.off("message:new");
-    this.socket.off("message:deleted");
-    this.socket.off("message:edited");
-    this.socket.off("typing:user-start");
-    this.socket.off("typing:user-stop");
-    this.socket.off("user:status-update");
-    this.socket.off("presence:update");
-    this.socket.off("member:join");
-    this.socket.off("member:leave");
-    this.socket.off("channel:update");
-    this.socket.off("channel:delete");
-    this.socket.off("rate:limited");
+    try {
+      const res = await this._axios.get(`/api/channels/${id}`);
+      const channel = new Channel(res.data, this);
+      this.cache.channels.set(channel.id, channel);
+      return channel;
+    } catch (error) {
+      throw error instanceof ClientError
+        ? error
+        : new ClientError(error.message, "FETCH_CHANNEL_ERROR");
+    }
   }
 
-  async _processSocketMessage(data) {
-    const msg = new Message(data, this);
-
-    if (!msg.author && data.user_id) {
-      msg.author = new User({
-        id: data.user_id,
-        username: data.username,
-        display_name: data.display_name,
-        avatar_url: data.avatar_url
-      }, this);
+  /**
+   * Creates a new channel
+   * @param {Object} options - Channel options
+   * @param {string} options.name - Channel name
+   * @param {string} options.description - Channel description
+   * @returns {Promise<Channel>} Created channel object
+   */
+  async createChannel({ name, description = "" }) {
+    if (!name || name.trim() === "") {
+      throw new ClientError("Channel name is required", "INVALID_CHANNEL_NAME");
     }
 
-    if (!msg.channel && data.channel_id) {
-      msg.channel = await this.fetchChannel(data.channel_id);
-    }
+    try {
+      const data = {
+        name: name.trim(),
+        description,
+        type: "text"
+      };
 
-    return msg;
+      const res = await this._axios.post('/api/channels', data);
+      const channel = new Channel(res.data.channel, this);
+      this.cache.channels.set(channel.id, channel);
+      return channel;
+    } catch (error) {
+      throw error instanceof ClientError ? error : new ClientError(error.message, "CREATE_CHANNEL_ERROR");
+    }
   }
 
-  _cacheMessage(msg) {
-    if (msg.author) {
-      this._ensureCached(this.cache.users, msg.author.id, msg.author);
+  /**
+   * Updates a channel's information
+   * @param {string} channelId - Channel ID
+   * @param {Object} options - Update options
+   * @param {string} options.name - New channel name
+   * @param {string} options.description - New channel description
+   * @returns {Promise<Channel>} Updated channel object
+   */
+  async updateChannel(channelId, { name, description }) {
+    if (!name && !description) {
+      throw new ClientError("At least one field must be provided to update", "NO_UPDATE_FIELDS");
     }
 
-    if (msg.channel) {
-      this._ensureCached(this.cache.channels, msg.channel.id, msg.channel);
-
-      if (!this.cache.messages.has(msg.channel.id)) {
-        this.cache.messages.set(msg.channel.id, []);
-      }
-
-      const messages = this.cache.messages.get(msg.channel.id);
-      messages.push(msg);
+    try {
+      const data = { type: "text" };
+      if (name !== undefined) data.name = name.trim();
+      if (description !== undefined) data.description = description;
 
-      if (messages.length > 50) {
-        messages.shift();
-      }
+      const res = await this._axios.patch(`/api/channels/${channelId}`, data);
+      const channel = new Channel(res.data.channel, this);
+      this.cache.channels.set(channel.id, channel);
+      return channel;
+    } catch (error) {
+      throw error instanceof ClientError ? error : new ClientError(error.message, "UPDATE_CHANNEL_ERROR");
     }
   }
 
-  _markMessageDeleted(messageId) {
-    for (const [channelId, messages] of this.cache.messages) {
-      const msg = messages.find(m => m.id === messageId);
-      if (msg) {
-        msg.deleted = true;
-        break;
-      }
+  /**
+   * Deletes a channel
+   * @param {string} channelId - Channel ID
+   * @returns {Promise<Object>} Deletion response
+   */
+  async deleteChannel(channelId) {
+    try {
+      const res = await this._axios.delete(`/api/channels/${channelId}`);
+      this.cache.channels.delete(channelId);
+      return res.data;
+    } catch (error) {
+      throw error instanceof ClientError ? error : new ClientError(error.message, "DELETE_CHANNEL_ERROR");
     }
   }
 
-  _updateMessageContent(messageId, content, editedAt) {
-    for (const [channelId, messages] of this.cache.messages) {
-      const msg = messages.find(m => m.id === messageId);
-      if (msg) {
-        msg.content = content;
-        msg.editedAt = editedAt;
-        msg.edited = true;
-        break;
-      }
-    }
-  }
+  // ============================================================================
+  // PUBLIC API METHODS - Channel Members
+  // ============================================================================
 
-  _updateUserStatus(data) {
-    const { userId, status, lastSeen } = data;
+  /**
+   * Fetches all members of a channel
+   * @param {string} channelId - Channel ID
+   * @returns {Promise<User[]>} Array of user objects
+   */
+  async fetchChannelMembers(channelId) {
+    try {
+      const res = await this._axios.get(`/api/channels/${channelId}/members`);
+      const channel = this.cache.channels.get(channelId);
 
-    if (this.cache.users.has(userId)) {
-      const user = this.cache.users.get(userId);
-      user.status = status;
-      if (lastSeen) user.lastSeen = lastSeen;
-    }
+      if (!channel) throw new ClientError("Canal não encontrado", "CHANNEL_NOT_FOUND");
 
-    if (this.cache.presence.has(userId)) {
-      const presence = this.cache.presence.get(userId);
-      presence.status = status;
-    }
-  }
+      const members = res.data.map(m => {
+        const user = new User(m, this);
+        this.cache.users.set(user.id, user);
+        channel.members.set(user.id, user);
+        return user;
+      });
 
-  _updateChannel(data) {
-    if (this.cache.channels.has(data.id)) {
-      const channel = this.cache.channels.get(data.id);
-      Object.assign(channel, data);
+      return members;
+    } catch (error) {
+      throw error instanceof ClientError ? error : new ClientError(error.message, "FETCH_MEMBERS_ERROR");
     }
   }
 
-  _ensureCached(map, key, value) {
-    const existing = map.get(key);
-    if (existing) return existing;
-    map.set(key, value);
-    return value;
+  /**
+   * Adds a member to a channel
+   * @param {string} channelId - Channel ID
+   * @param {string} userId - User ID to add
+   * @param {string} role - Member role (default: 'member')
+   * @returns {Promise<Object>} Response data
+   */
+  async addChannelMember(channelId, userId, role = 'member') {
+    try {
+      const res = await this._axios.post(`/api/channels/${channelId}/members`, {
+        userId,
+        role
+      });
+      return res.data;
+    } catch (error) {
+      throw error instanceof ClientError ? error : new ClientError(error.message, "ADD_MEMBER_ERROR");
+    }
   }
 
-  _ensureConnected() {
-    if (!this.socket || !this.socket.connected || !this.isConnected) {
-      throw new ClientError(
-        "Socket is not connected - please call login() first",
-        "NOT_CONNECTED"
-      );
+  /**
+   * Updates a channel member's information
+   * @param {string} channelId - Channel ID
+   * @param {string} userId - User ID
+   * @param {Object} data - Update data
+   * @returns {Promise<Object>} Response data
+   */
+  async updateChannelMember(channelId, userId, data) {
+    try {
+      const res = await this._axios.patch(`/api/channels/${channelId}/members/${userId}`, data);
+      return res.data;
+    } catch (error) {
+      throw error instanceof ClientError ? error : new ClientError(error.message, "UPDATE_MEMBER_ERROR");
     }
   }
 
   /**
-   * Set the user status
-   * @param {string} status - Status: "online", "away", "dnd", "offline"
+   * Removes a member from a channel
+   * @param {string} channelId - Channel ID
+   * @param {string} userId - User ID to remove
+   * @returns {Promise<Object>} Response data
    */
-  async setStatus(status) {
-    const validStatuses = ["online", "offline", "away", "dnd"];
-
-    if (!validStatuses.includes(status)) {
-      throw new ClientError(
-        `Invalid status. Valid statuses are: ${validStatuses.join(", ")}`,
-        "INVALID_STATUS"
-      );
+  async removeChannelMember(channelId, userId) {
+    try {
+      const res = await this._axios.delete(`/api/channels/${channelId}/members/${userId}`);
+      return res.data;
+    } catch (error) {
+      throw error instanceof ClientError ? error : new ClientError(error.message, "REMOVE_MEMBER_ERROR");
     }
-
-    this._ensureConnected();
-    this.socket.emit('status:update', { status });
   }
 
-
-  // async sendMessage(channelId, content, opts = {}) {
-  //   return new Promise(async (resolve, reject) => {
-  //     try {
-  //       this._ensureConnected();
-
-  //       let toSend = content;
-
-  //       if (content instanceof MessageEmbed) {
-  //         toSend = content.toText();
-  //       }
-
-  //       if (opts instanceof MessageAttachment) {
-  //         const uploadedFile = await this.uploadFile(opts);
-
-  //         if (uploadedFile) {
-  //           const mimetype = opts.name.split('.').pop().toLowerCase();
-  //           const messageType = ['png', 'jpg', 'jpeg', 'gif', 'webp'].includes(mimetype)
-  //             ? 'image'
-  //             : 'file';
-
-  //           opts = {
-  //             fileUrl: uploadedFile.url,
-  //             fileName: uploadedFile.originalName,
-  //             fileSize: uploadedFile.size,
-  //             messageType
-  //           };
-  //         }
-  //       }
-
-  //       if (opts.file) {
-  //         const fileData = await this._handleFileUpload(opts.file, opts.fileName);
-  //         opts.fileUrl = fileData.url;
-  //         opts.fileName = fileData.originalName;
-  //         opts.fileSize = fileData.size;
-  //         opts.messageType = opts.messageType || fileData.detectedType;
-  //       }
-
-  //       // const timeout = setTimeout(() => {
-  //       //   reject(new ClientError("Message send timeout", "SEND_TIMEOUT"));
-  //       // }, 15000);
-
-  //       this.socket.emit(
-  //         'message:send',
-  //         {
-  //           channelId,
-  //           content: toSend,
-  //           messageType: opts.messageType || 'text',
-  //           replyTo: opts.replyTo || null,
-  //           fileUrl: opts.fileUrl || null,
-  //           fileName: opts.fileName || null,
-  //           fileSize: opts.fileSize || null,
-  //           stickerId: opts.stickerId || null,
-  //         },
-  //         async (response) => {
-  //           // clearTimeout(timeout);
-
-  //           if (response && response.error) {
-  //             reject(new ClientError(response.error, "SEND_ERROR"));
-  //           } else {
-  //             this._sentMessages.add(response.id);
-  //             const msg = await this._processSocketMessage(response);
-  //             this._cacheMessage(msg);
-  //             resolve(msg);
-  //           }
-  //         }
-  //       );
-
-  //     } catch (error) {
-  //       reject(error instanceof ClientError ? error : new ClientError(error.message, "SEND_ERROR"));
-  //     }
-  //   });
-  // }
-
+  // ============================================================================
+  // PUBLIC API METHODS - Messages
+  // ============================================================================
 
   /**
-   * Send a message
+   * Sends a message to a channel
    * @param {string} channelId - Channel ID
-   * @param {string|MessageEmbed} content - Message content or MessageEmbed
-   * @param {Object|MessageAttachment} opts - Extra options
-   * @returns {Promise<Message>}
+   * @param {string|MessageEmbed} content - Message content or embed
+   * @param {Object|MessageAttachment} opts - Additional options
+   * @returns {Promise<Message>} Sent message object
    */
   async sendMessage(channelId, content, opts = {}) {
     return new Promise(async (resolve, reject) => {
@@ -697,19 +475,19 @@ class Client extends EventEmitter {
         let messageType = 'text';
         let embedData = null;
 
-        // Se o conteúdo é um MessageEmbed
+        // Handle MessageEmbed as content
         if (content instanceof MessageEmbed) {
           try {
-            content.validate(); // Valida o embed
+            content.validate();
             embedData = content.toJSON();
-            toSend = ''; // Embed não precisa de conteúdo de texto
+            toSend = '';
             messageType = 'embed';
           } catch (error) {
             return reject(new ClientError(`Invalid embed: ${error.message}`, "INVALID_EMBED"));
           }
         }
 
-        // Se opts é um MessageAttachment (mantém compatibilidade)
+        // Handle MessageAttachment as opts (backward compatibility)
         if (opts instanceof MessageAttachment) {
           const uploadedFile = await this.uploadFile(opts);
           if (uploadedFile) {
@@ -727,7 +505,7 @@ class Client extends EventEmitter {
           }
         }
 
-        // Se opts.file existe (upload de arquivo)
+        // Handle file upload
         if (opts.file) {
           const fileData = await this._handleFileUpload(opts.file, opts.fileName);
           opts.fileUrl = fileData.url;
@@ -736,7 +514,7 @@ class Client extends EventEmitter {
           messageType = opts.messageType || fileData.detectedType;
         }
 
-        // Se opts.embed existe (nova forma de enviar embed)
+        // Handle embed in opts
         if (opts.embed) {
           if (opts.embed instanceof MessageEmbed) {
             try {
@@ -752,7 +530,7 @@ class Client extends EventEmitter {
           }
         }
 
-        // Sobrescreve messageType se fornecido explicitamente
+        // Override messageType if explicitly provided
         if (opts.messageType && !embedData) {
           messageType = opts.messageType;
         }
@@ -768,7 +546,7 @@ class Client extends EventEmitter {
             fileName: opts.fileName || null,
             fileSize: opts.fileSize || null,
             stickerId: opts.stickerId || null,
-            embedData: embedData, // Nova propriedade
+            embedData: embedData,
           },
           async (response) => {
             if (response && response.error) {
@@ -787,93 +565,11 @@ class Client extends EventEmitter {
     });
   }
 
-  async _handleFileUpload(file, fileName) {
-    let fileBuffer;
-    let finalFileName;
-    let detectedType;
-
-    if (Buffer.isBuffer(file)) {
-      if (!fileName) {
-        throw new ClientError('fileName is required when sending a Buffer', 'MISSING_FILENAME');
-      }
-      fileBuffer = file;
-      finalFileName = fileName;
-    }
-    else if (typeof file === 'string') {
-      if (file.startsWith('data:')) {
-        const matches = file.match(/^data:([^;]+);base64,(.+)$/);
-        if (!matches) {
-          throw new ClientError('Invalid base64 string', 'INVALID_BASE64');
-        }
-
-        const mimeType = matches[1];
-        const base64Data = matches[2];
-        fileBuffer = Buffer.from(base64Data, 'base64');
-
-        const mimeToExt = {
-          'image/png': '.png',
-          'image/jpeg': '.jpg',
-          'image/jpg': '.jpg',
-          'image/gif': '.gif',
-          'image/webp': '.webp',
-          'video/mp4': '.mp4',
-          'video/webm': '.webm',
-        };
-
-        const ext = mimeToExt[mimeType] || '.bin';
-        finalFileName = fileName || `file${ext}`;
-      }
-      else if (file.match(/^[A-Za-z0-9+/=]+$/)) {
-        if (!fileName) {
-          throw new ClientError('fileName is required when sending base64 without data URI', 'MISSING_FILENAME');
-        }
-        fileBuffer = Buffer.from(file, 'base64');
-        finalFileName = fileName;
-      }
-      else {
-        if (!fs.existsSync(file)) {
-          throw new ClientError('File not found', 'FILE_NOT_FOUND');
-        }
-        fileBuffer = fs.readFileSync(file);
-        finalFileName = path.basename(file);
-      }
-    } else {
-      throw new ClientError('Invalid file type. Expected Buffer, base64 string, or file path', 'INVALID_FILE_TYPE');
-    }
-
-    const ext = path.extname(finalFileName).toLowerCase();
-    const imageExts = ['.jpg', '.jpeg', '.png', '.gif', '.webp', '.bmp', '.svg'];
-    const videoExts = ['.mp4', '.avi', '.mov', '.wmv', '.flv', '.mkv', '.webm'];
-
-    if (imageExts.includes(ext)) {
-      detectedType = 'image';
-    } else if (videoExts.includes(ext)) {
-      detectedType = 'video';
-    } else {
-      detectedType = 'file';
-    }
-
-    const formData = new FormData();
-    formData.append('file', fileBuffer, finalFileName);
-
-    try {
-      const uploadResponse = await this._axios.post('/api/upload', formData, {
-        headers: formData.getHeaders(),
-        timeout: 30000
-      });
-
-      return {
-        ...uploadResponse.data,
-        detectedType
-      };
-    } catch (error) {
-      throw new ClientError(`File upload error: ${error.message}`, 'UPLOAD_FAILED');
-    }
-  }
-
   /**
-   * @param {string} messageId
-   * @param {string} newContent
+   * Edits a message
+   * @param {string} messageId - Message ID
+   * @param {string} newContent - New message content
+   * @returns {Promise<Object>} Response data
    */
   async editMessage(messageId, newContent) {
     return new Promise((resolve, reject) => {
@@ -883,16 +579,10 @@ class Client extends EventEmitter {
         return reject(error);
       }
 
-      // const timeout = setTimeout(() => {
-      //   reject(new ClientError("Message edit timeout", "EDIT_TIMEOUT"));
-      // }, 15000);
-
       this.socket.emit(
         'message:edit',
         { messageId, content: newContent },
         (response) => {
-          // clearTimeout(timeout);
-
           if (response && response.error) {
             reject(new ClientError(response.error, "EDIT_ERROR"));
           } else {
@@ -905,7 +595,9 @@ class Client extends EventEmitter {
   }
 
   /**
-   * @param {string} messageId
+   * Deletes a message
+   * @param {string} messageId - Message ID
+   * @returns {Promise<Object>} Response data
    */
   async deleteMessage(messageId) {
     return new Promise((resolve, reject) => {
@@ -915,13 +607,7 @@ class Client extends EventEmitter {
         return reject(error);
       }
 
-      // const timeout = setTimeout(() => {
-      //   reject(new ClientError("Message delete timeout", "DELETE_TIMEOUT"));
-      // }, 15000);
-
       this.socket.emit('message:delete', { messageId }, (response) => {
-        clearTimeout(timeout);
-
         if (response && response.error) {
           reject(new ClientError(response.error, "DELETE_ERROR"));
         } else {
@@ -933,8 +619,12 @@ class Client extends EventEmitter {
   }
 
   /**
-   * @param {string} channelId
-   * @param {object} options
+   * Fetches messages from a channel
+   * @param {string} channelId - Channel ID
+   * @param {Object} options - Fetch options
+   * @param {number} options.limit - Maximum number of messages (default: 50, max: 100)
+   * @param {string} options.before - Fetch messages before this message ID
+   * @returns {Promise<Message[]>} Array of message objects
    */
   async fetchChannelMessages(channelId, options = {}) {
     try {
@@ -967,8 +657,10 @@ class Client extends EventEmitter {
   }
 
   /**
-   * @param {string} channelId
-   * @param {string} messageId
+   * Fetches a specific message
+   * @param {string} channelId - Channel ID
+   * @param {string} messageId - Message ID
+   * @returns {Promise<Message>} Message object
    */
   async fetchMessage(channelId, messageId) {
     try {
@@ -979,385 +671,721 @@ class Client extends EventEmitter {
     }
   }
 
-  async fetchChannels() {
-    try {
-      const res = await this._axios.get('/api/channels');
-      const channels = res.data.map(c => {
-        const channel = new Channel(c, this);
-        this.cache.channels.set(channel.id, channel);
-        return channel;
-      });
+  // ============================================================================
+  // PUBLIC API METHODS - Typing Indicators
+  // ============================================================================
 
-      return channels;
+  /**
+   * Starts typing indicator in a channel
+   * @param {string} channelId - Channel ID
+   */
+  startTyping(channelId) {
+    try {
+      this._ensureConnected();
+      this.socket.emit('typing:start', { channelId });
     } catch (error) {
-      throw error instanceof ClientError ? error : new ClientError(error.message, "FETCH_CHANNELS_ERROR");
+      this.emit("error", error);
     }
   }
 
   /**
-   * @param {string} id
+   * Stops typing indicator in a channel
+   * @param {string} channelId - Channel ID
    */
-  async fetchChannel(id, force = false) {
-    if (!force && this.cache.channels.has(id)) {
-      return this.cache.channels.get(id);
-    }
-
+  stopTyping(channelId) {
     try {
-      const res = await this._axios.get(`/api/channels/${id}`);
-      const channel = new Channel(res.data, this);
-      this.cache.channels.set(channel.id, channel);
-      return channel;
+      this._ensureConnected();
+      this.socket.emit('typing:stop', { channelId });
     } catch (error) {
-      throw error instanceof ClientError
-        ? error
-        : new ClientError(error.message, "FETCH_CHANNEL_ERROR");
+      this.emit("error", error);
     }
   }
 
+  // ============================================================================
+  // PUBLIC API METHODS - Emojis & Stickers
+  // ============================================================================
+
   /**
-   * @param {object} options
-   * @param {string} options.name
-   * @param {string} options.description
+   * Fetches an emoji by ID
+   * @param {string} id - Emoji ID
+   * @param {boolean} force - Force fetch from API instead of cache
+   * @returns {Promise<Emoji>} Emoji object
    */
-  async createChannel({ name, description = "" }) {
-    if (!name || name.trim() === "") {
-      throw new ClientError("Channel name is required", "INVALID_CHANNEL_NAME");
+  async fetchEmoji(id, force = false) {
+    if (!force && this.cache.emojis.has(id)) {
+      return this.cache.emojis.get(id);
     }
 
     try {
-      const data = {
-        name: name.trim(),
-        description,
-        type: "text"
-      };
-
-      const res = await this._axios.post('/api/channels', data);
-      const channel = new Channel(res.data.channel, this);
-      this.cache.channels.set(channel.id, channel);
-      return channel;
+      const res = await this._axios.get(`/api/emojis/${id}`);
+      const emoji = new Emoji(res.data);
+      this.cache.emojis.set(emoji.id, emoji);
+      return emoji;
     } catch (error) {
-      throw error instanceof ClientError ? error : new ClientError(error.message, "CREATE_CHANNEL_ERROR");
+      throw error instanceof ClientError
+        ? error
+        : new ClientError(error.message, "FETCH_EMOJI_ERROR");
     }
   }
 
   /**
-   * @param {string} channelId
-   * @param {object} options
+   * Fetches all available emojis
+   * @param {Object} options - Fetch options
+   * @param {boolean} options.includeOthers - Include emojis from other users
+   * @param {string} options.search - Search query
+   * @returns {Promise<Emoji[]>} Array of emoji objects
    */
-  async updateChannel(channelId, { name, description }) {
-    if (!name && !description) {
-      throw new ClientError("At least one field must be provided to update", "NO_UPDATE_FIELDS");
-    }
-
+  async fetchAllEmojis(options = {}) {
     try {
-      const data = { type: "text" };
-      if (name !== undefined) data.name = name.trim();
-      if (description !== undefined) data.description = description;
+      const endpoint = options.includeOthers ? '/api/emojis/all' : '/api/emojis';
+      const params = {};
 
-      const res = await this._axios.patch(`/api/channels/${channelId}`, data);
-      const channel = new Channel(res.data.channel, this);
-      this.cache.channels.set(channel.id, channel);
-      return channel;
+      if (options.search) {
+        params.search = options.search;
+      }
+
+      const res = await this._axios.get(endpoint, { params });
+      const emojis = res.data.map(e => {
+        const emoji = new Emoji(e);
+        this.cache.emojis.set(emoji.id, emoji);
+        return emoji;
+      });
+
+      return emojis;
     } catch (error) {
-      throw error instanceof ClientError ? error : new ClientError(error.message, "UPDATE_CHANNEL_ERROR");
+      throw error instanceof ClientError ? error : new ClientError(error.message, "FETCH_EMOJIS_ERROR");
     }
   }
 
   /**
-   * @param {string} channelId
+   * Fetches a sticker by ID
+   * @param {string} id - Sticker ID
+   * @param {boolean} force - Force fetch from API instead of cache
+   * @returns {Promise<Object>} Sticker data
    */
-  async deleteChannel(channelId) {
+  async fetchSticker(id, force = false) {
+    if (!force && this.cache.stickers.has(id)) {
+      return this.cache.stickers.get(id);
+    }
+
     try {
-      const res = await this._axios.delete(`/api/channels/${channelId}`);
-      this.cache.channels.delete(channelId);
+      const res = await this._axios.get(`/api/stickers/${id}`);
+      this.cache.stickers.set(res.data.id, res.data);
       return res.data;
     } catch (error) {
-      throw error instanceof ClientError ? error : new ClientError(error.message, "DELETE_CHANNEL_ERROR");
+      throw error instanceof ClientError
+        ? error
+        : new ClientError(error.message, "FETCH_STICKER_ERROR");
     }
   }
 
   /**
-   * @param {string} channelId
+   * Fetches all available stickers
+   * @param {Object} options - Fetch options
+   * @param {string} options.search - Search query
+   * @returns {Promise<Object[]>} Array of sticker objects
    */
-  async fetchChannelMembers(channelId) {
+  async fetchAllStickers(options = {}) {
     try {
-      const res = await this._axios.get(`/api/channels/${channelId}/members`);
-      const members = res.data.map(m => {
-        const user = new User(m, this);
-        this.cache.users.set(user.id, user);
-        return user;
-      });
+      const params = {};
 
-      return members;
-    } catch (error) {
-      throw error instanceof ClientError ? error : new ClientError(error.message, "FETCH_MEMBERS_ERROR");
-    }
-  }
+      if (options.search) {
+        params.search = options.search;
+      }
 
-  /**
-   * @param {string} channelId
-   * @param {string} userId
-   * @param {string} role
-   */
-  async addChannelMember(channelId, userId, role = 'member') {
-    try {
-      const res = await this._axios.post(`/api/channels/${channelId}/members`, {
-        userId,
-        role
+      const res = await this._axios.get('/api/stickers/all', { params });
+      res.data.forEach(s => {
+        this.cache.stickers.set(s.id, s);
       });
+
       return res.data;
     } catch (error) {
-      throw error instanceof ClientError ? error : new ClientError(error.message, "ADD_MEMBER_ERROR");
+      throw error instanceof ClientError ? error : new ClientError(error.message, "FETCH_STICKERS_ERROR");
     }
   }
 
+  // ============================================================================
+  // PUBLIC API METHODS - File Upload
+  // ============================================================================
+
   /**
-   * @param {string} channelId
-   * @param {string} userId
-   * @param {object} data
+   * Uploads a file to the server
+   * @param {MessageAttachment} file - File attachment to upload
+   * @returns {Promise<Object>} Upload response with file URL
    */
-  async updateChannelMember(channelId, userId, data) {
+  async uploadFile(file) {
     try {
-      const res = await this._axios.patch(`/api/channels/${channelId}/members/${userId}`, data);
+      const formData = new FormData();
+      formData.append('file', file.buffer, { filename: file.name });
+      const res = await this._axios.post('/api/upload', formData, {
+        headers: formData.getHeaders(),
+        timeout: 30000
+      });
+
       return res.data;
     } catch (error) {
-      throw error instanceof ClientError ? error : new ClientError(error.message, "UPDATE_MEMBER_ERROR");
+      throw error instanceof ClientError ? error : new ClientError(error.message, "UPLOAD_ERROR");
     }
   }
 
+  // ============================================================================
+  // PUBLIC API METHODS - Cache Management
+  // ============================================================================
+
   /**
-   * @param {string} channelId
-   * @param {string} userId
+   * Clears all cached data
    */
-  async removeChannelMember(channelId, userId) {
-    try {
-      const res = await this._axios.delete(`/api/channels/${channelId}/members/${userId}`);
-      return res.data;
-    } catch (error) {
-      throw error instanceof ClientError ? error : new ClientError(error.message, "REMOVE_MEMBER_ERROR");
-    }
+  clearCache() {
+    this.cache.users.clear();
+    this.cache.channels.clear();
+    this.cache.messages.clear();
+    this.cache.emojis.clear();
+    this.cache.stickers.clear();
   }
 
+  // ============================================================================
+  // PRIVATE METHODS - Socket Connection & Management
+  // ============================================================================
+
   /**
-   * @param {string} id
+   * Establishes WebSocket connection to the server
+   * @private
    */
-  async fetchUser(id, force = false) {
-    if (!force && this.cache.users.has(id)) {
-      return this.cache.users.get(id);
-    }
-
+  async _connectSocket() {
+    return new Promise((resolve, reject) => {
+      const connectionTimeout = setTimeout(() => {
+        if (this.socket) {
+          this.socket.disconnect();
+        }
+        reject(new ClientError(
+          `Connection timeout - failed to connect within ${this.config.connectionTimeout}ms`,
+          "CONNECTION_TIMEOUT"
+        ));
+      }, this.config.connectionTimeout);
+
+      this.socket = io(global.apiUrl, {
+        auth: { token: global.token },
+        extraHeaders: { 'Origin': global.apiUrl },
+        timeout: 5000,
+        reconnection: true,
+        reconnectionDelay: this.config.reconnectionDelay,
+        reconnectionAttempts: this.config.maxRetries,
+        transports: ['websocket', 'polling']
+      });
+
+      this.socket.on("connect", () => {
+        clearTimeout(connectionTimeout);
+        this.isConnected = true;
+        this.retryCount = 0;
+        this._setupSocketHandlers();
+        this._startHeartbeat();
+        resolve();
+      });
+
+      this.socket.on("disconnect", (reason) => {
+        this.isConnected = false;
+        this._stopHeartbeat();
+        this.emit("disconnect", reason);
+
+        if (reason === "io server disconnect") {
+          this.emit("error", new ClientError(
+            "Disconnected by server - token may be invalid or revoked",
+            "SERVER_DISCONNECT"
+          ));
+        }
+      });
+
+      this.socket.on("connect_error", (error) => {
+        clearTimeout(connectionTimeout);
+        this.retryCount++;
+
+        let errorCode = "CONNECTION_ERROR";
+        let errorMessage = "Failed to connect to server";
+
+        const errorStr = error.message.toLowerCase();
+
+        if (errorStr.includes("401") || errorStr.includes("unauthorized")) {
+          errorCode = "UNAUTHORIZED";
+          errorMessage = "Invalid token";
+        } else if (errorStr.includes("403") || errorStr.includes("forbidden")) {
+          errorCode = "FORBIDDEN";
+          errorMessage = "Token expired or revoked";
+        } else if (errorStr.includes("timeout")) {
+          errorCode = "TIMEOUT";
+          errorMessage = "Connection timeout";
+        }
+
+        const clientError = new ClientError(errorMessage, errorCode);
+        this.emit("error", clientError);
+
+        if (this.retryCount >= this.config.maxRetries) {
+          reject(clientError);
+        }
+      });
+
+      this.socket.on("reconnect", (attemptNumber) => {
+        this.isConnected = true;
+        this._startHeartbeat();
+        this.emit("reconnect", attemptNumber);
+      });
+
+      this.socket.on("reconnect_error", (error) => {
+        this.emit("reconnectError", error);
+      });
+
+      this.socket.on("reconnect_failed", () => {
+        this._stopHeartbeat();
+        this.emit("error", new ClientError(
+          "Failed to reconnect after maximum attempts",
+          "RECONNECT_FAILED"
+        ));
+      });
+    });
+  }
+
+  /**
+   * Joins all channel rooms on connection
+   * @private
+   */
+  async _joinAllChannelRooms() {
     try {
-      const res = await this._axios.get(`/api/users/${id}`);
-      const user = new User(res.data, this);
-      this.cache.users.set(user.id, user);
-      return user;
+      const channels = await this.fetchChannels();
+
+      for (const channel of channels) {
+        if (this.socket && this.socket.connected) {
+          this.socket.emit('channel:join', { channelId: channel.id });
+        }
+      }
     } catch (error) {
-      throw error instanceof ClientError
-        ? error
-        : new ClientError(error.message, "FETCH_USER_ERROR");
+      console.error('Error joining channel rooms:', error);
     }
   }
 
-  async fetchMe(force = false) {
-    if (!force && this.user) {
-      return this.user;
+  /**
+   * Sets up all socket event handlers
+   * @private
+   */
+  _setupSocketHandlers() {
+    this._removeSocketHandlers();
+
+    this.socket.on('message:new', async (data) => {
+      try {
+        if (this._sentMessages.has(data.id)) {
+          this._sentMessages.delete(data.id);
+          return;
+        }
+
+        const msg = await this._processSocketMessage(data);
+        this._cacheMessage(msg);
+        this.emit("messageCreate", msg);
+      } catch (error) {
+        this.emit("error", error);
+      }
+    });
+
+    this.socket.on('message:deleted', (data) => {
+      const { messageId } = data;
+      this._markMessageDeleted(messageId);
+      this.emit('messageDelete', data);
+    });
+
+    this.socket.on('message:edited', (data) => {
+      const { messageId, content, editedAt } = data;
+      this._updateMessageContent(messageId, content, editedAt);
+      this.emit('messageEdit', data);
+    });
+
+    this.socket.on('typing:user-start', (data) => {
+      this.emit('typingStart', data);
+    });
+
+    this.socket.on('typing:user-stop', (data) => {
+      this.emit('typingStop', data);
+    });
+
+    this.socket.on('user:status-update', (data) => {
+      this._updateUserStatus(data);
+      this.emit('userStatusUpdate', data);
+    });
+
+    this.socket.on('member:join', async (data) => {
+      const member = await this.fetchUser(data.memberId).catch(() => null);
+      const channel = this.cache.channels.get(data.channelId);
+      if (!channel || !member) return;
+      channel.members.set(member.id, member);
+      channel.memberCount = (channel.memberCount || 0) + 1;
+      this.emit('memberJoin', { channel, member });
+    });
+
+    this.socket.on('member:leave', async (data) => {
+      const channel = this.cache.channels.get(data.channelId);
+      const member = this.cache.users.get(data.memberId);
+
+      if (channel && member) {
+        const wasDeleted = channel.members.delete(member.id);
+
+        if (wasDeleted && channel.memberCount > 0) {
+          channel.memberCount -= 1;
+        }
+      }
+
+      this.emit('memberLeave', { channel, member });
+    });
+
+    this.socket.on('channel:update', (data) => {
+      this._updateChannel(data);
+      this.emit('channelUpdate', data);
+    });
+
+    this.socket.on('channel:delete', (data) => {
+      this.cache.channels.delete(data.channelId);
+      this.emit('channelDelete', data);
+    });
+
+    this.socket.on('rate:limited', (data) => {
+      this.emit('rateLimited', data);
+    });
+  }
+
+  /**
+   * Removes all socket event handlers
+   * @private
+   */
+  _removeSocketHandlers() {
+    if (!this.socket) return;
+
+    this.socket.off("message:new");
+    this.socket.off("message:deleted");
+    this.socket.off("message:edited");
+    this.socket.off("typing:user-start");
+    this.socket.off("typing:user-stop");
+    this.socket.off("user:status-update");
+    this.socket.off("presence:update");
+    this.socket.off("member:join");
+    this.socket.off("member:leave");
+    this.socket.off("channel:update");
+    this.socket.off("channel:delete");
+    this.socket.off("rate:limited");
+  }
+
+  /**
+   * Starts the heartbeat interval to maintain connection
+   * @private
+   */
+  _startHeartbeat() {
+    this._stopHeartbeat();
+
+    const HEARTBEAT_INTERVAL = 30000;
+
+    this.heartbeatInterval = setInterval(() => {
+      if (this.socket && this.isConnected) {
+        this.socket.emit("presence:heartbeat", {
+          status: this.status || "online",
+          clientType: "bot"
+        });
+      }
+    }, HEARTBEAT_INTERVAL);
+
+    if (this.socket && this.isConnected) {
+      this.socket.emit("presence:heartbeat", {
+        status: this.status || "online",
+        clientType: "bot"
+      });
     }
+  }
 
-    try {
-      const res = await this._axios.get('/api/users/me');
-      const user = new User(res.data, this);
-      this.cache.users.set(user.id, user);
-      this.user = user;
-      return user;
-    } catch (error) {
-      throw error instanceof ClientError
-        ? error
-        : new ClientError(error.message, "FETCH_ME_ERROR");
+  /**
+   * Stops the heartbeat interval
+   * @private
+   */
+  _stopHeartbeat() {
+    if (this.heartbeatInterval) {
+      clearInterval(this.heartbeatInterval);
+      this.heartbeatInterval = null;
+    }
+  }
+
+  // ============================================================================
+  // PRIVATE METHODS - Error Handling
+  // ============================================================================
+
+  /**
+   * Handles axios request errors
+   * @private
+   */
+  _handleAxiosError(error) {
+    if (error.response) {
+      const { status, data } = error.response;
+      const errorCode = data?.error || 'UNKNOWN_ERROR';
+      const errorMessage = data?.message || error.message;
+
+      switch (status) {
+        case 401:
+          throw new ClientError(
+            errorMessage || "Invalid or expired token",
+            errorCode || "UNAUTHORIZED"
+          );
+        case 403:
+          throw new ClientError(
+            errorMessage || "Token lacks necessary permissions",
+            errorCode || "FORBIDDEN"
+          );
+        case 404:
+          throw new ClientError(
+            errorMessage || "Resource not found",
+            errorCode || "NOT_FOUND"
+          );
+        case 429:
+          throw new ClientError(
+            errorMessage || "Rate limit exceeded",
+            errorCode || "RATE_LIMITED"
+          );
+        default:
+          throw new ClientError(
+            errorMessage || "API request failed",
+            errorCode
+          );
+      }
+    } else if (error.code === 'ECONNABORTED') {
+      throw new ClientError("Request timeout", "TIMEOUT");
+    } else if (error.code === 'ECONNREFUSED') {
+      throw new ClientError("Cannot connect to API server", "CONNECTION_REFUSED");
+    } else {
+      throw new ClientError(
+        error.message || "Network error",
+        error.code || "NETWORK_ERROR"
+      );
     }
   }
 
   /**
-   * @param {string} userId
+   * Ensures the socket is connected before performing operations
+   * @private
    */
-  async fetchPresence(userId) {
-    try {
-      const res = await this._axios.get(`/api/presence/${userId}`);
-      this.cache.presence.set(userId, res.data);
-      return res.data;
-    } catch (error) {
-      throw error instanceof ClientError ? error : new ClientError(error.message, "FETCH_PRESENCE_ERROR");
+  _ensureConnected() {
+    if (!this.socket || !this.socket.connected || !this.isConnected) {
+      throw new ClientError(
+        "Socket is not connected - please call login() first",
+        "NOT_CONNECTED"
+      );
     }
   }
 
+  // ============================================================================
+  // PRIVATE METHODS - Message Processing
+  // ============================================================================
+
   /**
-   * @param {string} id
+   * Processes raw socket message data into Message object
+   * @private
    */
-  async fetchEmoji(id, force = false) {
-    if (!force && this.cache.emojis.has(id)) {
-      return this.cache.emojis.get(id);
+  async _processSocketMessage(data) {
+    const msg = new Message(data, this);
+
+    if (!msg.author && data.user_id) {
+      msg.author = new User({
+        id: data.user_id,
+        username: data.username,
+        display_name: data.display_name,
+        avatar_url: data.avatar_url
+      }, this);
     }
 
-    try {
-      const res = await this._axios.get(`/api/emojis/${id}`);
-      const emoji = new Emoji(res.data);
-      this.cache.emojis.set(emoji.id, emoji);
-      return emoji;
-    } catch (error) {
-      throw error instanceof ClientError
-        ? error
-        : new ClientError(error.message, "FETCH_EMOJI_ERROR");
+    if (!msg.channel && data.channel_id) {
+      msg.channel = await this.fetchChannel(data.channel_id);
+    }
+
+    if (msg.channel.memberCount !== msg.channel.members.size) {
+      await msg.channel.members.fetch();
     }
+
+    return msg;
   }
 
   /**
-   * @param {object} options
+   * Caches a message and related entities
+   * @private
    */
-  async fetchAllEmojis(options = {}) {
-    try {
-      const endpoint = options.includeOthers ? '/api/emojis/all' : '/api/emojis';
-      const params = {};
+  _cacheMessage(msg) {
+    if (msg.author) {
+      this._ensureCached(this.cache.users, msg.author.id, msg.author);
+    }
 
-      if (options.search) {
-        params.search = options.search;
-      }
+    if (msg.channel) {
+      const channel = msg.channel;
+      this._ensureCached(this.cache.channels, channel.id, channel);
 
-      const res = await this._axios.get(endpoint, { params });
-      const emojis = res.data.map(e => {
-        const emoji = new Emoji(e);
-        this.cache.emojis.set(emoji.id, emoji);
-        return emoji;
-      });
+      // guarda a mensagem no canal
+      channel.messages.set(msg.id, msg);
 
-      return emojis;
-    } catch (error) {
-      throw error instanceof ClientError ? error : new ClientError(error.message, "FETCH_EMOJIS_ERROR");
+      // limita a 50 mensagens
+      if (channel.messages.size > 50) {
+        const firstKey = channel.messages.firstKey(); // método do Collection
+        channel.messages.delete(firstKey);
+      }
     }
   }
 
   /**
-   * @param {string} id
+   * Marks a message as deleted in cache
+   * @private
    */
-  async fetchSticker(id, force = false) {
-    if (!force && this.cache.stickers.has(id)) {
-      return this.cache.stickers.get(id);
-    }
-
-    try {
-      const res = await this._axios.get(`/api/stickers/${id}`);
-      this.cache.stickers.set(res.data.id, res.data);
-      return res.data;
-    } catch (error) {
-      throw error instanceof ClientError
-        ? error
-        : new ClientError(error.message, "FETCH_STICKER_ERROR");
+  _markMessageDeleted(messageId) {
+    for (const [channelId, messages] of this.cache.messages) {
+      const msg = messages.find(m => m.id === messageId);
+      if (msg) {
+        msg.deleted = true;
+        break;
+      }
     }
   }
 
   /**
-   * @param {object} options
+   * Updates message content in cache
+   * @private
    */
-  async fetchAllStickers(options = {}) {
-    try {
-      const params = {};
-
-      if (options.search) {
-        params.search = options.search;
+  _updateMessageContent(messageId, content, editedAt) {
+    for (const [channelId, messages] of this.cache.messages) {
+      const msg = messages.find(m => m.id === messageId);
+      if (msg) {
+        msg.content = content;
+        msg.editedAt = editedAt;
+        msg.edited = true;
+        break;
       }
-
-      const res = await this._axios.get('/api/stickers/all', { params });
-      res.data.forEach(s => {
-        this.cache.stickers.set(s.id, s);
-      });
-
-      return res.data;
-    } catch (error) {
-      throw error instanceof ClientError ? error : new ClientError(error.message, "FETCH_STICKERS_ERROR");
     }
   }
 
-  async uploadFile(file) {
-    try {
-      const formData = new FormData();
-      formData.append('file', file.buffer, { filename: file.name });
-      const res = await this._axios.post('/api/upload', formData, {
-        headers: formData.getHeaders(),
-        timeout: 30000
-      });
+  // ============================================================================
+  // PRIVATE METHODS - Cache Utilities
+  // ============================================================================
 
-      return res.data;
-    } catch (error) {
-      throw error instanceof ClientError ? error : new ClientError(error.message, "UPLOAD_ERROR");
+  /**
+   * Updates user status in cache
+   * @private
+   */
+  _updateUserStatus(data) {
+    const { userId, status, lastSeen } = data;
+
+    if (this.cache.users.has(userId)) {
+      const user = this.cache.users.get(userId);
+      user.status = status;
+      if (lastSeen) user.lastSeen = lastSeen;
     }
   }
 
   /**
-   * @param {string} channelId
+   * Updates channel data in cache
+   * @private
    */
-  startTyping(channelId) {
-    try {
-      this._ensureConnected();
-      this.socket.emit('typing:start', { channelId });
-    } catch (error) {
-      this.emit("error", error);
+  _updateChannel(data) {
+    if (this.cache.channels.has(data.id)) {
+      const channel = this.cache.channels.get(data.id);
+      Object.assign(channel, data);
     }
   }
 
   /**
-   * @param {string} channelId
+   * Ensures a value is cached and returns it
+   * @private
    */
-  stopTyping(channelId) {
-    try {
-      this._ensureConnected();
-      this.socket.emit('typing:stop', { channelId });
-    } catch (error) {
-      this.emit("error", error);
-    }
+  _ensureCached(map, key, value) {
+    const existing = map.get(key);
+    if (existing) return existing;
+    map.set(key, value);
+    return value;
   }
 
-  disconnect() {
-    if (this.socket) {
-      this.socket.disconnect();
-      this.isConnected = false;
-      this.isReady = false;
+  // ============================================================================
+  // PRIVATE METHODS - File Upload Handling
+  // ============================================================================
+
+  /**
+   * Handles file upload from various input types
+   * @private
+   */
+  async _handleFileUpload(file, fileName) {
+    let fileBuffer;
+    let finalFileName;
+    let detectedType;
+
+    if (Buffer.isBuffer(file)) {
+      if (!fileName) {
+        throw new ClientError('fileName is required when sending a Buffer', 'MISSING_FILENAME');
+      }
+      fileBuffer = file;
+      finalFileName = fileName;
     }
-  }
+    else if (typeof file === 'string') {
+      if (file.startsWith('data:')) {
+        const matches = file.match(/^data:([^;]+);base64,(.+)$/);
+        if (!matches) {
+          throw new ClientError('Invalid base64 string', 'INVALID_BASE64');
+        }
 
-  ready() {
-    return this.isReady && this.isConnected && this.socket && this.socket.connected;
-  }
+        const mimeType = matches[1];
+        const base64Data = matches[2];
+        fileBuffer = Buffer.from(base64Data, 'base64');
 
-  clearCache() {
-    this.cache.users.clear();
-    this.cache.channels.clear();
-    this.cache.messages.clear();
-    this.cache.emojis.clear();
-    this.cache.stickers.clear();
-    this.cache.presence.clear();
-  }
+        const mimeToExt = {
+          'image/png': '.png',
+          'image/jpeg': '.jpg',
+          'image/jpg': '.jpg',
+          'image/gif': '.gif',
+          'image/webp': '.webp',
+          'video/mp4': '.mp4',
+          'video/webm': '.webm',
+        };
 
-  getCacheStats() {
-    return {
-      users: this.cache.users.size,
-      channels: this.cache.channels.size,
-      messages: Array.from(this.cache.messages.values()).reduce((acc, arr) => acc + arr.length, 0),
-      emojis: this.cache.emojis.size,
-      stickers: this.cache.stickers.size,
-      presence: this.cache.presence.size,
-    };
-  }
+        const ext = mimeToExt[mimeType] || '.bin';
+        finalFileName = fileName || `file${ext}`;
+      }
+      else if (file.match(/^[A-Za-z0-9+/=]+$/)) {
+        if (!fileName) {
+          throw new ClientError('fileName is required when sending base64 without data URI', 'MISSING_FILENAME');
+        }
+        fileBuffer = Buffer.from(file, 'base64');
+        finalFileName = fileName;
+      }
+      else {
+        if (!fs.existsSync(file)) {
+          throw new ClientError('File not found', 'FILE_NOT_FOUND');
+        }
+        fileBuffer = fs.readFileSync(file);
+        finalFileName = path.basename(file);
+      }
+    } else {
+      throw new ClientError('Invalid file type. Expected Buffer, base64 string, or file path', 'INVALID_FILE_TYPE');
+    }
 
-  getConnectionInfo() {
-    return {
-      connected: this.isConnected,
-      ready: this.isReady,
-      socketId: this.socket?.id,
-      retryCount: this.retryCount,
-      user: this.user ? {
-        id: this.user.id,
-        username: this.user.username,
-        isBot: this.user.isBot
-      } : null
-    };
+    const ext = path.extname(finalFileName).toLowerCase();
+    const imageExts = ['.jpg', '.jpeg', '.png', '.gif', '.webp', '.bmp', '.svg'];
+    const videoExts = ['.mp4', '.avi', '.mov', '.wmv', '.flv', '.mkv', '.webm'];
+
+    if (imageExts.includes(ext)) {
+      detectedType = 'image';
+    } else if (videoExts.includes(ext)) {
+      detectedType = 'video';
+    } else {
+      detectedType = 'file';
+    }
+
+    const formData = new FormData();
+    formData.append('file', fileBuffer, finalFileName);
+
+    try {
+      const uploadResponse = await this._axios.post('/api/upload', formData, {
+        headers: formData.getHeaders(),
+        timeout: 30000
+      });
+
+      return {
+        ...uploadResponse.data,
+        detectedType
+      };
+    } catch (error) {
+      throw new ClientError(`File upload error: ${error.message}`, 'UPLOAD_FAILED');
+    }
   }
 }