socketManager.js

const { DisconnectReason, fetchLatestBaileysVersion } = require('@whiskeysockets/baileys');
const makeWASocket = require('@whiskeysockets/baileys').default;
const useMongoDBAuthState = require('./mongoAuthState');
const qrcode = require('qrcode-terminal');
const { connectToDB } = require('./db');
const { wireSocketLogging, appLogger } = require('./logger');
const MediaHandler = require('./mediaHandler');
const socketLog = appLogger('socket');

class SocketManager {
  constructor() {
    this.sockets = new Map(); // accountId -> { socket, status, qr, collection, etc. }
    this.db = null;
    this.mediaHandler = null;
    // Browser configurations for user agent rotation
    this.browserConfigs = [
      ['Chrome', '107.0.5304.87', 'Windows 10'],
      ['Chrome', '107.0.5304.87', 'Windows 11'],
      ['Chrome', '119.0.6045.105', 'Mac OS'],
      ['Chrome', '119.0.6045.105', 'Linux'],
      ['Firefox', '119.0', 'Windows 10'],
      ['Firefox', '119.0', 'Mac OS'],
      ['Safari', '17.0', 'Mac OS'],
      ['Edge', '119.0.2151.44', 'Windows 11'],
      ['Safari', '14.4.1', 'Mac OS'],
      ['Safari', '14.4.1', 'iOS'],
    ];
  }

  _getRandomBrowser() {
    return this.browserConfigs[Math.floor(Math.random() * this.browserConfigs.length)];
  }

  async init() {
    this.db = await connectToDB();
    this.mediaHandler = new MediaHandler(this.db);
  }

  async createSocket(accountId, collectionName) {
    const collName = collectionName || `auth_${accountId}`;
    const existing = this.sockets.get(accountId);
    if (existing && existing.status !== 'reconnecting' && existing.status !== 'logged_out') {
      return existing;
    }

    // Remove old socket if reconnecting or logged out
    if (existing) {
      try { await existing.socket.logout(); } catch {}
      this.sockets.delete(accountId);
    }

    const collection = this.db.collection(collName);
    const { state, saveCreds } = await useMongoDBAuthState(collection);
    // Use WhatsApp Web version that resolves "Connection Failure" (issue #2370)
    // This version is confirmed to work with WhatsApp's current servers
    const { version, isLatest } = await fetchLatestBaileysVersion().catch(() => ({ version: [2, 3000, 1033893291], isLatest: false }));
    const browser = this._getRandomBrowser();
    socketLog.info('socket_creating', { accountId, browser, waVersion: version.join('.'), isLatest });
    const sock = makeWASocket({
      version,
      auth: state,
      syncFullHistory: true,
      browser,
    });
    wireSocketLogging(sock);

    const socketInfo = {
      socket: sock,
      status: 'connecting',
      qr: null,
      lastDisconnect: null,
      collection: collName,
    };
    this.sockets.set(accountId, socketInfo);

    // Connection lifecycle
    sock.ev.on('connection.update', async (update = {}) => {
      const { connection, lastDisconnect, qr } = update;
      if (connection) socketInfo.status = connection;
      socketInfo.lastDisconnect = lastDisconnect;
      socketInfo.qr = qr;

      const accountsCol = this.db.collection('accounts');

      if (qr) {
        // Keep terminal friendly QR while also structured log
        console.log(`\n=== QR Code for account: ${accountId} ===`);
        qrcode.generate(qr, { small: true });
        console.log('=== Scan with WhatsApp to connect ===\n');
        socketLog.info('qr_generated', { accountId });
      }

      if (connection === 'close') {
        const loggedOut = lastDisconnect?.error?.output?.statusCode === DisconnectReason.loggedOut;
        if (!loggedOut) {
          socketInfo.status = 'reconnecting';
          socketLog.info('reconnecting_account', { accountId, delaySeconds: 5 });
          try {
            const res1 = await accountsCol.updateOne({ _id: { $eq: accountId } }, { $set: { status: 'reconnecting', updatedAt: new Date() } });
            socketLog.info('account_status_updated', { accountId, status: 'reconnecting', modifiedCount: res1.modifiedCount });
          } catch (err) {
            socketLog.error('account_status_update_failed', { accountId, status: 'reconnecting', error: err && err.message });
          }
          setTimeout(() => this.createSocket(accountId, collName), 5000);
        } else {
          socketInfo.status = 'logged_out';
          socketLog.info('account_logged_out', { accountId });
          try {
            const res2 = await accountsCol.updateOne({ _id: { $eq: accountId } }, { $set: { status: 'logged_out', updatedAt: new Date() } });
            socketLog.info('account_status_updated', { accountId, status: 'logged_out', modifiedCount: res2.modifiedCount });
          } catch (err) {
            socketLog.error('account_status_update_failed', { accountId, status: 'logged_out', error: err && err.message });
          }
        }
      } else if (connection === 'open') {
        socketInfo.status = 'connected';
        socketLog.info('account_connected', { accountId });
        try {
          const res3 = await accountsCol.updateOne({ _id: { $eq: accountId } }, { $set: { status: 'connected', updatedAt: new Date() } });
          socketLog.info('account_status_updated', { accountId, status: 'connected', modifiedCount: res3.modifiedCount });
        } catch (err) {
          socketLog.error('account_status_update_failed', { accountId, status: 'connected', error: err && err.message });
        }
        if (process.env.ADMIN_NUMBER) {
          try {
            await sock.sendMessage(process.env.ADMIN_NUMBER, { text: `\u2705 Account ${accountId} connected successfully!` });
          } catch (notifyErr) {
            socketLog.error('admin_notify_failed', { accountId, error: notifyErr.message });
          }
        }
      } else if (connection === 'connecting') {
        try {
          const res4 = await accountsCol.updateOne({ _id: { $eq: accountId } }, { $set: { status: 'connecting', updatedAt: new Date() } });
          socketLog.info('account_status_updated', { accountId, status: 'connecting', modifiedCount: res4.modifiedCount });
        } catch (err) {
          socketLog.error('account_status_update_failed', { accountId, status: 'connecting', error: err && err.message });
        }
      }
    });

    sock.ev.on('creds.update', saveCreds);

    // Per-account message handling
    sock.ev.on('messages.upsert', async (messageInfoUpsert) => {
      if (messageInfoUpsert.type !== 'notify') return;
      const messages = messageInfoUpsert.messages || [];
      const messagesCollection = this.db.collection('messages');

      for (const msg of messages) {
        try {
          const textContent = this._extractTextContent(msg);
          const hasMedia = this.mediaHandler.hasMedia(msg);
          let mediaInfo = null;

          if (hasMedia) {
            try {
              mediaInfo = await this.mediaHandler.downloadAndStoreMedia(
                msg,
                accountId,
                sock.updateMediaMessage,
              );
              socketLog.info('media_stored', { accountId, messageId: msg.key.id, mediaType: mediaInfo.mediaType });
            } catch (err) {
              socketLog.error('media_download_failed', { accountId, messageId: msg.key.id, error: err.message });
            }
          }

          const quotedMessage = this.mediaHandler.extractQuotedMessage(msg);
          const mentions = this.mediaHandler.extractMentions(msg);

          const messageDoc = {
            accountId,
            messageId: msg.key.id,
            chatId: msg.key.remoteJid,
            from: msg.key.remoteJid,
            fromMe: msg.key.fromMe,
            timestamp: msg.messageTimestamp,
            type: mediaInfo ? mediaInfo.mediaType : 'text',
            text: textContent,
            hasMedia,
            ...(mediaInfo && {
              mediaType: mediaInfo.mediaType,
              mediaGridFsId: mediaInfo.gridFsId.toString(),
              mediaUrl: this.mediaHandler.getMediaUrl(accountId, msg.key.id),
              mediaSize: mediaInfo.size,
              mediaMimetype: mediaInfo.mimetype,
              mediaFileName: mediaInfo.fileName,
              caption: mediaInfo.caption,
              mediaWidth: mediaInfo.width,
              mediaHeight: mediaInfo.height,
            }),
            quotedMessage,
            mentions,
            isForwarded: msg.message?.extendedTextMessage?.contextInfo?.isForwarded || false,
            rawMessage: msg,
            createdAt: new Date(),
            updatedAt: new Date(),
          };

          await messagesCollection.insertOne(messageDoc);

          // Webhooks
          const { sendToWebhook } = require('./webhookHandler');
          const webhooksCollection = this.db.collection('webhooks');
          const webhooks = await webhooksCollection.find({}).toArray();
          const webhookPayload = {
            accountId,
            messageId: msg.key.id,
            chatId: msg.key.remoteJid,
            from: msg.key.remoteJid,
            fromMe: msg.key.fromMe,
            timestamp: msg.messageTimestamp,
            type: messageDoc.type,
            text: textContent,
            hasMedia,
            mediaUrl: mediaInfo ? messageDoc.mediaUrl : null,
            mediaType: mediaInfo ? mediaInfo.mediaType : null,
            quotedMessage,
            mentions,
            createdAt: messageDoc.createdAt,
          };
          for (const webhook of webhooks) {
            const result = await sendToWebhook(webhook.url, webhookPayload);
            if (!result.ok) {
              let redactedUrl = '<redacted>';
              try {
                const parsed = new URL(webhook.url);
                redactedUrl = `${parsed.protocol}//${parsed.hostname}${parsed.port ? ':' + parsed.port : ''}${parsed.pathname}`;
              } catch {}
              socketLog.error('webhook_send_failed', { accountId, webhook: redactedUrl, error: result.error });
            }
          }
        } catch (err) {
          socketLog.error('message_processing_error', { accountId, messageId: msg.key?.id, error: err.message });
        }
      }
    });

    return socketInfo;
  }

  getSocket(accountId) {
    return this.sockets.get(accountId);
  }

  getAllSockets() {
    return Array.from(this.sockets.entries()).map(([id, info]) => ({
      id,
      status: info.status,
      qr: info.qr,
      collection: info.collection,
    }));
  }

  async removeSocket(accountId) {
    const info = this.sockets.get(accountId);
    if (info) {
      try {
        await info.socket.logout();
      } catch (e) {
        socketLog.error('logout_error', { accountId, error: e.message });
      }
      this.sockets.delete(accountId);
    }
  }

  async deleteAccountData(accountId) {
    const info = this.sockets.get(accountId);
    if (info) {
      await this.db.collection(info.collection).drop();
    }
  }

  async requestPairingCode(accountId, phoneNumber) {
    const socketInfo = this.sockets.get(accountId);
    if (!socketInfo) {
      const err = new Error('Account not found');
      err.code = 'account_not_found';
      throw err;
    }
    if (socketInfo.status !== 'connecting') {
      const err = new Error('Socket not ready for pairing');
      err.code = 'socket_not_ready';
      err.status = socketInfo.status;
      throw err;
    }
    if (!/^\d{10,15}$/.test(phoneNumber)) {
      const err = new Error('Invalid phone number format');
      err.code = 'invalid_phone_number';
      throw err;
    }
    const code = await socketInfo.socket.requestPairingCode(phoneNumber);
    socketLog.info('pairing_code_requested', { accountId });
    return code;
  }

  // Extract text content from Baileys message
  _extractTextContent(message) {
    const msg = message.message;
    if (!msg) return null;
    if (msg.conversation) return msg.conversation;
    if (msg.extendedTextMessage?.text) return msg.extendedTextMessage.text;
    if (msg.imageMessage?.caption) return msg.imageMessage.caption;
    if (msg.videoMessage?.caption) return msg.videoMessage.caption;
    if (msg.documentMessage?.caption) return msg.documentMessage.caption;
    return null;
  }
}

module.exports = SocketManager;