dubs-server 1.0.0

package/services/socialService.js

@@ -0,0 +1,1202 @@
+/**
+ * 👥 Social/Friends Service
+ * 
+ * Manages friend requests, friends, groups, and user search
+ */
+
+const { pool } = require('./db'); // Shared database pool
+const { forwardChatNotification } = require('./telegramNotifications');
+const notificationCacheService = require('./notificationCacheService');
+
+class SocialService {
+  constructor() {
+    // Use shared pool from services/db.js
+    this.pool = pool;
+    
+    this.initializeTables();
+  }
+
+  async initializeTables() {
+    try {
+      await this.pool.query(`
+        -- Friend requests
+        CREATE TABLE IF NOT EXISTS friend_requests (
+          id SERIAL PRIMARY KEY,
+          from_user_id INTEGER REFERENCES users(id) ON DELETE CASCADE,
+          to_user_id INTEGER REFERENCES users(id) ON DELETE CASCADE,
+          status VARCHAR(20) NOT NULL CHECK (status IN ('pending', 'accepted', 'rejected')) DEFAULT 'pending',
+          created_at TIMESTAMP DEFAULT NOW(),
+          updated_at TIMESTAMP DEFAULT NOW()
+        );
+
+        -- Add unique constraint if it doesn't exist
+        DO $$ 
+        BEGIN
+          IF NOT EXISTS (
+            SELECT 1 FROM pg_constraint 
+            WHERE conname = 'friend_requests_from_user_id_to_user_id_key'
+          ) THEN
+            ALTER TABLE friend_requests 
+            ADD CONSTRAINT friend_requests_from_user_id_to_user_id_key 
+            UNIQUE (from_user_id, to_user_id);
+          END IF;
+        END $$;
+
+        -- Groups (for future private rooms)
+        CREATE TABLE IF NOT EXISTS groups (
+          id SERIAL PRIMARY KEY,
+          name VARCHAR(100) NOT NULL,
+          created_by INTEGER REFERENCES users(id) ON DELETE CASCADE,
+          created_at TIMESTAMP DEFAULT NOW()
+        );
+
+        -- Group members
+        CREATE TABLE IF NOT EXISTS group_members (
+          id SERIAL PRIMARY KEY,
+          group_id INTEGER REFERENCES groups(id) ON DELETE CASCADE,
+          user_id INTEGER REFERENCES users(id) ON DELETE CASCADE,
+          joined_at TIMESTAMP DEFAULT NOW()
+        );
+
+        -- Add unique constraint for group_members if it doesn't exist
+        DO $$ 
+        BEGIN
+          IF NOT EXISTS (
+            SELECT 1 FROM pg_constraint 
+            WHERE conname = 'group_members_group_id_user_id_key'
+          ) THEN
+            ALTER TABLE group_members 
+            ADD CONSTRAINT group_members_group_id_user_id_key 
+            UNIQUE (group_id, user_id);
+          END IF;
+        END $$;
+
+        -- Indexes
+        CREATE INDEX IF NOT EXISTS idx_friend_requests_from ON friend_requests(from_user_id);
+        CREATE INDEX IF NOT EXISTS idx_friend_requests_to ON friend_requests(to_user_id);
+        CREATE INDEX IF NOT EXISTS idx_friend_requests_status ON friend_requests(status);
+        CREATE INDEX IF NOT EXISTS idx_group_members_group ON group_members(group_id);
+        CREATE INDEX IF NOT EXISTS idx_group_members_user ON group_members(user_id);
+      `);
+      console.log('✅ Social/Friends tables initialized');
+    } catch (error) {
+      console.error('❌ Failed to initialize social tables:', error.message);
+    }
+  }
+
+  /**
+   * Search users by username
+   */
+  async searchUsers(query, currentUserId, limit = 1000) {
+    try {
+      const result = await this.pool.query(
+        `SELECT
+          u.id,
+          u.wallet_address,
+          u.username,
+          u.avatar,
+          COALESCE((SELECT COUNT(*) FROM user_game_refs ugr WHERE ugr.wallet_address = u.wallet_address), 0) as games_played,
+          EXISTS (
+            SELECT 1 FROM user_relationships
+            WHERE user_id = $1 AND target_user_id = u.id AND relationship_type = 'friend'
+          ) as is_friend,
+          EXISTS (
+            SELECT 1 FROM user_relationships
+            WHERE user_id = $1 AND target_user_id = u.id AND relationship_type = 'block'
+          ) as is_blocked,
+          EXISTS (
+            SELECT 1 FROM friend_requests
+            WHERE from_user_id = $1 AND to_user_id = u.id AND status = 'pending'
+          ) as friend_request_sent,
+          EXISTS (
+            SELECT 1 FROM friend_requests
+            WHERE from_user_id = u.id AND to_user_id = $1 AND status = 'pending'
+          ) as friend_request_received,
+          (
+            SELECT id FROM friend_requests
+            WHERE from_user_id = u.id AND to_user_id = $1 AND status = 'pending'
+            LIMIT 1
+          ) as incoming_friend_request_id
+         FROM users u
+         WHERE u.username ILIKE $2
+         AND u.id != $1
+         ORDER BY games_played DESC, u.created_at DESC
+         LIMIT $3`,
+        [currentUserId, `%${query}%`, limit]
+      );
+
+      return result.rows.map(row => ({
+        userId: row.id,
+        walletAddress: row.wallet_address,
+        username: row.username,
+        avatar: row.avatar,
+        isFriend: row.is_friend,
+        isBlocked: row.is_blocked,
+        friendRequestSent: row.friend_request_sent,
+        friendRequestReceived: row.friend_request_received,
+        friendRequestId: row.incoming_friend_request_id,
+      }));
+    } catch (error) {
+      console.error('Error searching users:', error);
+      return [];
+    }
+  }
+
+  /**
+   * Send friend request
+   */
+  async sendFriendRequest(fromUserId, toUserId) {
+    try {
+      const result = await this.pool.query(
+        `INSERT INTO friend_requests (from_user_id, to_user_id, status, created_at)
+         VALUES ($1, $2, 'pending', NOW())
+         ON CONFLICT (from_user_id, to_user_id) 
+         DO UPDATE SET status = 'pending', updated_at = NOW()
+         RETURNING id`,
+        [fromUserId, toUserId]
+      );
+      
+      const requestId = result.rows[0].id;
+      
+      // Create notification in database so it persists if user is offline
+      const notifResult = await this.pool.query(
+        `INSERT INTO chat_notifications (user_id, sender_user_id, notification_type, read, created_at)
+         VALUES ($1, $2, 'friend_request', false, NOW())
+         RETURNING id, created_at`,
+        [toUserId, fromUserId]
+      );
+      
+      // Get sender info (username, wallet, avatar) for notifications
+      const senderResult = await this.pool.query(
+        'SELECT username, wallet_address, avatar FROM users WHERE id = $1',
+        [fromUserId]
+      );
+      const senderUsername = senderResult.rows[0]?.username || 'Someone';
+      const senderWallet = senderResult.rows[0]?.wallet_address || '';
+      const senderAvatar = senderResult.rows[0]?.avatar || null;
+      
+      // Forward to Telegram if connected
+      forwardChatNotification(this.pool, toUserId, 'friend_request', senderUsername).catch(err => 
+        console.error('[SocialService] Error forwarding friend_request notification to Telegram:', err.message)
+      );
+      
+      // Cache notification to Redis (non-blocking)
+      const notificationId = notifResult.rows[0].id;
+      const notification = {
+        id: notificationId,
+        type: 'friend_request',
+        read: false,
+        message: '',
+        senderUsername,
+        senderWallet,
+        senderAvatar,
+        createdAt: notifResult.rows[0].created_at,
+      };
+      notificationCacheService.cacheNotification(toUserId, notification)
+        .catch(err => console.error('[SocialService] Failed to cache notification:', err.message));
+      
+      return { requestId, notificationId };
+    } catch (error) {
+      console.error('Error sending friend request:', error);
+      return null;
+    }
+  }
+
+  /**
+   * Accept friend request
+   */
+  async acceptFriendRequest(requestId, userId) {
+    try {
+      // Update request status
+      const result = await this.pool.query(
+        `UPDATE friend_requests 
+         SET status = 'accepted', updated_at = NOW()
+         WHERE id = $1 AND to_user_id = $2
+         RETURNING from_user_id, to_user_id`,
+        [requestId, userId]
+      );
+
+      if (result.rows.length === 0) return { success: false };
+
+      const { from_user_id, to_user_id } = result.rows[0];
+
+      // Create bidirectional friendship in user_relationships
+      await this.pool.query(
+        `INSERT INTO user_relationships (user_id, target_user_id, relationship_type)
+         VALUES ($1, $2, 'friend'), ($2, $1, 'friend')
+         ON CONFLICT (user_id, target_user_id) 
+         DO UPDATE SET relationship_type = 'friend'`,
+        [from_user_id, to_user_id]
+      );
+
+      // Create notification for sender (their request was accepted!)
+      const notifResult = await this.pool.query(
+        `INSERT INTO chat_notifications (user_id, sender_user_id, notification_type, read, created_at)
+         VALUES ($1, $2, 'friend_request_accepted', false, NOW())
+         RETURNING id, created_at`,
+        [from_user_id, to_user_id]
+      );
+      
+      // Get accepter info (username, wallet, avatar) for notifications
+      const accepterResult = await this.pool.query(
+        'SELECT username, wallet_address, avatar FROM users WHERE id = $1',
+        [to_user_id]
+      );
+      const accepterUsername = accepterResult.rows[0]?.username || 'Someone';
+      const accepterWallet = accepterResult.rows[0]?.wallet_address || '';
+      const accepterAvatar = accepterResult.rows[0]?.avatar || null;
+      
+      // Forward to Telegram if connected
+      forwardChatNotification(this.pool, from_user_id, 'friend_request_accepted', accepterUsername).catch(err => 
+        console.error('[SocialService] Error forwarding friend_request_accepted notification to Telegram:', err.message)
+      );
+      
+      // Cache notification to Redis (non-blocking)
+      const notificationId = notifResult.rows[0].id;
+      const notification = {
+        id: notificationId,
+        type: 'friend_request_accepted',
+        read: false,
+        message: '',
+        senderUsername: accepterUsername,
+        senderWallet: accepterWallet,
+        senderAvatar: accepterAvatar,
+        createdAt: notifResult.rows[0].created_at,
+      };
+      notificationCacheService.cacheNotification(from_user_id, notification)
+        .catch(err => console.error('[SocialService] Failed to cache notification:', err.message));
+      
+      return { 
+        success: true, 
+        fromUserId: from_user_id,
+        notificationId
+      };
+    } catch (error) {
+      console.error('Error accepting friend request:', error);
+      return { success: false };
+    }
+  }
+
+  /**
+   * Reject friend request
+   */
+  async rejectFriendRequest(requestId, userId) {
+    try {
+      const result = await this.pool.query(
+        `UPDATE friend_requests 
+         SET status = 'rejected', updated_at = NOW()
+         WHERE id = $1 AND to_user_id = $2
+         RETURNING id, from_user_id`,
+        [requestId, userId]
+      );
+      console.log('[SocialService] Reject query result:', result.rowCount, 'rows affected');
+      
+      if (result.rowCount > 0) {
+        const fromUserId = result.rows[0].from_user_id;
+        
+        // Create notification for sender (their request was declined)
+        const notifResult = await this.pool.query(
+          `INSERT INTO chat_notifications (user_id, sender_user_id, notification_type, read, created_at)
+           VALUES ($1, $2, 'friend_request_declined', false, NOW())
+           RETURNING id, created_at`,
+          [fromUserId, userId]
+        );
+        
+        // Get decliner info (username, wallet, avatar) for notifications
+        const declinerResult = await this.pool.query(
+          'SELECT username, wallet_address, avatar FROM users WHERE id = $1',
+          [userId]
+        );
+        const declinerUsername = declinerResult.rows[0]?.username || 'Someone';
+        const declinerWallet = declinerResult.rows[0]?.wallet_address || '';
+        const declinerAvatar = declinerResult.rows[0]?.avatar || null;
+        
+        // Forward to Telegram if connected
+        forwardChatNotification(this.pool, fromUserId, 'friend_request_declined', declinerUsername).catch(err => 
+          console.error('[SocialService] Error forwarding friend_request_declined notification to Telegram:', err.message)
+        );
+        
+        // Cache notification to Redis (non-blocking)
+        const notificationId = notifResult.rows[0].id;
+        const notification = {
+          id: notificationId,
+          type: 'friend_request_declined',
+          read: false,
+          message: '',
+          senderUsername: declinerUsername,
+          senderWallet: declinerWallet,
+          senderAvatar: declinerAvatar,
+          createdAt: notifResult.rows[0].created_at,
+        };
+        notificationCacheService.cacheNotification(fromUserId, notification)
+          .catch(err => console.error('[SocialService] Failed to cache notification:', err.message));
+        
+        return { 
+          success: true, 
+          fromUserId: fromUserId,
+          notificationId
+        };
+      }
+      return { success: false };
+    } catch (error) {
+      console.error('Error rejecting friend request:', error);
+      return { success: false };
+    }
+  }
+
+  /**
+   * Get pending friend requests (received)
+   */
+  async getPendingRequests(userId) {
+    try {
+      const result = await this.pool.query(
+        `SELECT 
+          fr.id,
+          fr.from_user_id,
+          u.username as from_username,
+          u.avatar as from_avatar,
+          u.wallet_address as from_wallet,
+          fr.created_at
+         FROM friend_requests fr
+         JOIN users u ON fr.from_user_id = u.id
+         WHERE fr.to_user_id = $1 AND fr.status = 'pending'
+         ORDER BY fr.created_at DESC`,
+        [userId]
+      );
+
+      return result.rows.map(row => ({
+        id: row.id,
+        fromUserId: row.from_user_id,
+        fromUsername: row.from_username,
+        fromAvatar: row.from_avatar,
+        fromWallet: row.from_wallet,
+        createdAt: row.created_at,
+      }));
+    } catch (error) {
+      console.error('Error getting pending requests:', error);
+      return [];
+    }
+  }
+
+  /**
+   * Get friends list
+   */
+  async getFriends(userId) {
+    try {
+      const result = await this.pool.query(
+        `SELECT 
+          u.id,
+          u.wallet_address,
+          u.username,
+          u.avatar,
+          ur.created_at as friends_since
+         FROM user_relationships ur
+         JOIN users u ON ur.target_user_id = u.id
+         WHERE ur.user_id = $1 AND ur.relationship_type = 'friend'
+         ORDER BY ur.created_at DESC`,
+        [userId]
+      );
+
+      return result.rows.map(row => ({
+        userId: row.id,
+        walletAddress: row.wallet_address,
+        username: row.username,
+        avatar: row.avatar,
+        friendsSince: row.friends_since,
+      }));
+    } catch (error) {
+      console.error('Error getting friends:', error);
+      return [];
+    }
+  }
+
+  /**
+   * Remove friend
+   */
+  async removeFriend(userId, targetUserId) {
+    try {
+      // Remove bidirectional friendship
+      const result = await this.pool.query(
+        `DELETE FROM user_relationships 
+         WHERE (user_id = $1 AND target_user_id = $2 AND relationship_type = 'friend')
+         OR (user_id = $2 AND target_user_id = $1 AND relationship_type = 'friend')
+         RETURNING user_id, target_user_id`,
+        [userId, targetUserId]
+      );
+      return { success: result.rowCount > 0, targetUserId };
+    } catch (error) {
+      console.error('Error removing friend:', error);
+      return { success: false };
+    }
+  }
+
+  /**
+   * Get blocked users
+   */
+  async getBlockedUsers(userId) {
+    try {
+      const result = await this.pool.query(
+        `SELECT
+          u.id,
+          u.wallet_address,
+          u.username,
+          u.avatar,
+          ur.created_at as blocked_at
+         FROM user_relationships ur
+         JOIN users u ON ur.target_user_id = u.id
+         WHERE ur.user_id = $1 AND ur.relationship_type = 'block'
+         ORDER BY ur.created_at DESC`,
+        [userId]
+      );
+
+      return result.rows.map(row => ({
+        userId: row.id,
+        walletAddress: row.wallet_address,
+        username: row.username,
+        avatar: row.avatar,
+        blockedAt: row.blocked_at,
+      }));
+    } catch (error) {
+      console.error('Error getting blocked users:', error);
+      return [];
+    }
+  }
+
+  /**
+   * Get top players by wins for each category
+   * Calculates wins directly from games table (not sports_betting_stats which may be empty)
+   * @param {number} currentUserId - Current user's ID
+   * @param {number} limit - Number of top players per category
+   */
+  async getTopPlayers(currentUserId, limit = 10) {
+    try {
+      // Get top sports players by wins - calculated from games table
+      const sportsResult = await this.pool.query(`
+        WITH sports_stats AS (
+          SELECT
+            u.id as user_id,
+            u.wallet_address,
+            u.username,
+            u.avatar,
+            COUNT(*) as total_games,
+            SUM(CASE WHEN ugr.team_choice = g.sports_event->'finalScore'->>'winner' THEN 1 ELSE 0 END) as wins,
+            SUM(CASE WHEN ugr.team_choice != g.sports_event->'finalScore'->>'winner' THEN 1 ELSE 0 END) as losses
+          FROM users u
+          JOIN user_game_refs ugr ON ugr.wallet_address = u.wallet_address
+          JOIN games g ON g.game_id = ugr.game_id
+          WHERE g.game_type = 'sports'
+          AND g.is_resolved = true
+          AND g.sports_event->'finalScore' IS NOT NULL
+          AND u.id != $1
+          GROUP BY u.id, u.wallet_address, u.username, u.avatar
+        )
+        SELECT
+          user_id,
+          wallet_address,
+          username,
+          avatar,
+          wins,
+          total_games,
+          CASE WHEN (wins + losses) > 0
+            THEN ROUND((wins::numeric / (wins + losses)) * 100, 1)
+            ELSE 0
+          END as win_rate,
+          EXISTS (
+            SELECT 1 FROM user_relationships
+            WHERE user_id = $1 AND target_user_id = sports_stats.user_id AND relationship_type = 'friend'
+          ) as is_friend,
+          EXISTS (
+            SELECT 1 FROM friend_requests
+            WHERE from_user_id = $1 AND to_user_id = sports_stats.user_id AND status = 'pending'
+          ) as friend_request_sent
+        FROM sports_stats
+        WHERE wins > 0 AND (wins + losses) >= 3
+        ORDER BY win_rate DESC, wins DESC
+        LIMIT $2
+      `, [currentUserId, limit]);
+
+      // Get top connect4 players by wins - calculated from games table using team_choice
+      console.log('[TopPlayers] Fetching connect4 top players, excluding user:', currentUserId);
+      const connect4Result = await this.pool.query(`
+        WITH connect4_stats AS (
+          SELECT
+            u.id as user_id,
+            u.wallet_address,
+            u.username,
+            u.avatar,
+            COUNT(DISTINCT g.game_id) as total_games,
+            SUM(CASE WHEN g.game_status = 'completed' AND g.connect4_winner IN ('home', 'away') AND ugr.team_choice = g.connect4_winner THEN 1 ELSE 0 END) as wins,
+            SUM(CASE WHEN g.game_status = 'completed' AND g.connect4_winner IN ('home', 'away') AND ugr.team_choice != g.connect4_winner THEN 1 ELSE 0 END) as losses
+          FROM users u
+          JOIN user_game_refs ugr ON ugr.wallet_address = u.wallet_address
+          JOIN games g ON g.game_id = ugr.game_id
+          WHERE g.game_type = 'connect4'
+          AND u.id != $1
+          GROUP BY u.id, u.wallet_address, u.username, u.avatar
+        )
+        SELECT
+          user_id,
+          wallet_address,
+          username,
+          avatar,
+          wins,
+          total_games,
+          CASE WHEN (wins + losses) > 0
+            THEN ROUND((wins::numeric / (wins + losses)) * 100, 1)
+            ELSE 0
+          END as win_rate,
+          EXISTS (
+            SELECT 1 FROM user_relationships
+            WHERE user_id = $1 AND target_user_id = connect4_stats.user_id AND relationship_type = 'friend'
+          ) as is_friend,
+          EXISTS (
+            SELECT 1 FROM friend_requests
+            WHERE from_user_id = $1 AND to_user_id = connect4_stats.user_id AND status = 'pending'
+          ) as friend_request_sent
+        FROM connect4_stats
+        WHERE wins > 0
+        ORDER BY wins DESC, win_rate DESC, total_games DESC
+        LIMIT $2
+      `, [currentUserId, limit]);
+
+      console.log('[TopPlayers] Connect4 results:', connect4Result.rows.length, 'players found');
+      if (connect4Result.rows.length > 0) {
+        console.log('[TopPlayers] Top connect4 player:', connect4Result.rows[0].username, 'with', connect4Result.rows[0].wins, 'wins');
+      }
+
+      const mapPlayer = (row, rank) => ({
+        rank: rank + 1,
+        userId: row.user_id,
+        walletAddress: row.wallet_address,
+        username: row.username,
+        avatar: row.avatar,
+        wins: parseInt(row.wins),
+        totalGames: parseInt(row.total_games),
+        winRate: parseFloat(row.win_rate),
+        isFriend: row.is_friend,
+        friendRequestSent: row.friend_request_sent,
+      });
+
+      return {
+        sports: sportsResult.rows.map(mapPlayer),
+        connect4: connect4Result.rows.map(mapPlayer),
+      };
+    } catch (error) {
+      console.error('Error getting top players:', error);
+      return { sports: [], connect4: [] };
+    }
+  }
+
+  /**
+   * Get category summary for discover page
+   * Returns user counts for each game category plus "all" for users without game history
+   */
+  async getCategorySummary(currentUserId) {
+    try {
+      // Get game-based category counts
+      const categoryResult = await this.pool.query(`
+        WITH category_counts AS (
+          SELECT
+            CASE
+              WHEN g.game_type = 'connect4' THEN 'connect4'
+              WHEN g.sports_event->>'strLeague' = 'NBA' THEN 'NBA'
+              WHEN g.sports_event->>'strLeague' = 'NHL' THEN 'NHL'
+              WHEN g.sports_event->>'strLeague' = 'NFL' THEN 'NFL'
+              WHEN g.sports_event->>'strLeague' = 'UFC' THEN 'UFC'
+              WHEN g.sports_event->>'strLeague' = 'English Premier League' THEN 'EPL'
+              ELSE NULL
+            END as category,
+            COUNT(DISTINCT ugr.wallet_address) as user_count
+          FROM user_game_refs ugr
+          JOIN games g ON g.game_id = ugr.game_id
+          WHERE g.game_type IN ('sports', 'connect4')
+          GROUP BY
+            CASE
+              WHEN g.game_type = 'connect4' THEN 'connect4'
+              WHEN g.sports_event->>'strLeague' = 'NBA' THEN 'NBA'
+              WHEN g.sports_event->>'strLeague' = 'NHL' THEN 'NHL'
+              WHEN g.sports_event->>'strLeague' = 'NFL' THEN 'NFL'
+              WHEN g.sports_event->>'strLeague' = 'UFC' THEN 'UFC'
+              WHEN g.sports_event->>'strLeague' = 'English Premier League' THEN 'EPL'
+              ELSE NULL
+            END
+        )
+        SELECT category, user_count
+        FROM category_counts
+        WHERE category IS NOT NULL
+        ORDER BY user_count DESC
+      `);
+
+      // Get count of users who haven't played any games (new/inactive users)
+      const newUsersResult = await this.pool.query(`
+        SELECT COUNT(*) as user_count
+        FROM users u
+        WHERE u.id != $1
+        AND NOT EXISTS (
+          SELECT 1 FROM user_game_refs ugr WHERE ugr.wallet_address = u.wallet_address
+        )
+      `, [currentUserId || 0]);
+
+      const categoryMeta = {
+        NBA: { name: 'NBA', icon: 'basketball', order: 1 },
+        NHL: { name: 'NHL', icon: 'hockey', order: 2 },
+        NFL: { name: 'NFL', icon: 'football', order: 3 },
+        EPL: { name: 'Soccer', icon: 'soccer', order: 4 },
+        UFC: { name: 'UFC', icon: 'fighting', order: 5 },
+        connect4: { name: 'Connect4', icon: 'connect4', order: 6 },
+        all: { name: 'New Users', icon: 'users', order: 7 },
+      };
+
+      const categories = categoryResult.rows
+        .filter(row => categoryMeta[row.category])
+        .map(row => ({
+          id: row.category,
+          name: categoryMeta[row.category].name,
+          icon: categoryMeta[row.category].icon,
+          userCount: parseInt(row.user_count),
+          order: categoryMeta[row.category].order,
+        }));
+
+      // Add "New Users" category if there are users without game history
+      const newUsersCount = parseInt(newUsersResult.rows[0].user_count);
+      if (newUsersCount > 0) {
+        categories.push({
+          id: 'all',
+          name: categoryMeta.all.name,
+          icon: categoryMeta.all.icon,
+          userCount: newUsersCount,
+          order: categoryMeta.all.order,
+        });
+      }
+
+      return categories.sort((a, b) => a.order - b.order);
+    } catch (error) {
+      console.error('Error getting category summary:', error);
+      return [];
+    }
+  }
+
+  /**
+   * Discover users by category with pagination
+   * @param {string} category - NBA, NHL, NFL, EPL, UFC, connect4, or "all" (new users without game history)
+   * @param {number} currentUserId - Current user's ID (to exclude and check relationships)
+   * @param {object} options - { page, limit, sortBy }
+   */
+  async discoverByCategory(category, currentUserId, options = {}) {
+    const { page = 1, limit = 20, sortBy = 'games_played' } = options;
+    const offset = (page - 1) * limit;
+    const safeLimit = Math.min(Math.max(1, limit), 50); // Cap at 50
+
+    // Handle "all" category - users without game history (new/inactive users)
+    if (category === 'all') {
+      return this.discoverNewUsers(currentUserId, { page, limit: safeLimit, sortBy });
+    }
+
+    // Handle Connect4 separately - wins calculated from games table, not sports_betting_stats
+    if (category === 'connect4') {
+      return this.discoverConnect4Users(currentUserId, { page, limit: safeLimit, sortBy });
+    }
+
+    // Map category to SQL condition (sports only)
+    const categoryConditions = {
+      NBA: "g.sports_event->>'strLeague' = 'NBA'",
+      NHL: "g.sports_event->>'strLeague' = 'NHL'",
+      NFL: "g.sports_event->>'strLeague' = 'NFL'",
+      EPL: "g.sports_event->>'strLeague' = 'English Premier League'",
+      UFC: "g.sports_event->>'strLeague' = 'UFC'",
+    };
+
+    const categoryCondition = categoryConditions[category];
+    if (!categoryCondition) {
+      return { users: [], pagination: { page, limit: safeLimit, total: 0, totalPages: 0, hasMore: false } };
+    }
+
+    try {
+      // Get total count first
+      const countResult = await this.pool.query(`
+        SELECT COUNT(DISTINCT ugr.wallet_address) as total
+        FROM user_game_refs ugr
+        JOIN games g ON g.game_id = ugr.game_id
+        JOIN users u ON u.wallet_address = ugr.wallet_address
+        WHERE ${categoryCondition}
+        AND u.id != $1
+      `, [currentUserId]);
+
+      const total = parseInt(countResult.rows[0].total);
+      const totalPages = Math.ceil(total / safeLimit);
+
+      // Get paginated users with relationship info
+      // Sort by: wins first (top players), then win rate, then games_played
+      const result = await this.pool.query(`
+        WITH category_users AS (
+          SELECT
+            u.id as user_id,
+            u.wallet_address,
+            u.username,
+            u.avatar,
+            u.created_at,
+            COUNT(DISTINCT ugr.game_id) as games_played,
+            MAX(ugr.joined_at) as last_played_at
+          FROM users u
+          JOIN user_game_refs ugr ON ugr.wallet_address = u.wallet_address
+          JOIN games g ON g.game_id = ugr.game_id
+          WHERE ${categoryCondition}
+          AND u.id != $1
+          GROUP BY u.id, u.wallet_address, u.username, u.avatar, u.created_at
+        )
+        SELECT
+          cu.*,
+          COALESCE(sbs.games_won, 0) as wins,
+          CASE WHEN COALESCE(sbs.games_won, 0) + COALESCE(sbs.games_lost, 0) > 0
+            THEN ROUND((COALESCE(sbs.games_won, 0)::numeric / (COALESCE(sbs.games_won, 0) + COALESCE(sbs.games_lost, 0))) * 100, 1)
+            ELSE 0
+          END as win_rate,
+          EXISTS (
+            SELECT 1 FROM user_relationships
+            WHERE user_id = $1 AND target_user_id = cu.user_id AND relationship_type = 'friend'
+          ) as is_friend,
+          EXISTS (
+            SELECT 1 FROM user_relationships
+            WHERE user_id = $1 AND target_user_id = cu.user_id AND relationship_type = 'block'
+          ) as is_blocked,
+          EXISTS (
+            SELECT 1 FROM friend_requests
+            WHERE from_user_id = $1 AND to_user_id = cu.user_id AND status = 'pending'
+          ) as friend_request_sent,
+          EXISTS (
+            SELECT 1 FROM friend_requests
+            WHERE from_user_id = cu.user_id AND to_user_id = $1 AND status = 'pending'
+          ) as friend_request_received,
+          (
+            SELECT id FROM friend_requests
+            WHERE from_user_id = cu.user_id AND to_user_id = $1 AND status = 'pending'
+            LIMIT 1
+          ) as incoming_friend_request_id
+        FROM category_users cu
+        LEFT JOIN sports_betting_stats sbs ON sbs.wallet_address = cu.wallet_address
+        ORDER BY COALESCE(sbs.games_won, 0) DESC, win_rate DESC, games_played DESC
+        LIMIT $2 OFFSET $3
+      `, [currentUserId, safeLimit, offset]);
+
+      const users = result.rows.map(row => ({
+        userId: row.user_id,
+        walletAddress: row.wallet_address,
+        username: row.username,
+        avatar: row.avatar,
+        gamesPlayed: parseInt(row.games_played),
+        wins: parseInt(row.wins) || 0,
+        winRate: parseFloat(row.win_rate) || 0,
+        lastPlayedAt: row.last_played_at,
+        isFriend: row.is_friend,
+        isBlocked: row.is_blocked,
+        friendRequestSent: row.friend_request_sent,
+        friendRequestReceived: row.friend_request_received,
+        friendRequestId: row.incoming_friend_request_id,
+      }));
+
+      return {
+        users,
+        pagination: {
+          page,
+          limit: safeLimit,
+          total,
+          totalPages,
+          hasMore: page < totalPages,
+        },
+      };
+    } catch (error) {
+      console.error('Error discovering users by category:', error);
+      return { users: [], pagination: { page, limit: safeLimit, total: 0, totalPages: 0, hasMore: false } };
+    }
+  }
+
+  /**
+   * Discover Connect4 users with proper win/loss calculation from games table
+   * Sorted by: win_rate DESC (100% first), then wins DESC, then games_played DESC
+   */
+  async discoverConnect4Users(currentUserId, options = {}) {
+    const { page = 1, limit = 20 } = options;
+    const offset = (page - 1) * limit;
+    const safeLimit = Math.min(Math.max(1, limit), 50);
+
+    try {
+      // Get total count
+      const countResult = await this.pool.query(`
+        SELECT COUNT(DISTINCT ugr.wallet_address) as total
+        FROM user_game_refs ugr
+        JOIN games g ON g.game_id = ugr.game_id
+        JOIN users u ON u.wallet_address = ugr.wallet_address
+        WHERE g.game_type = 'connect4'
+        AND u.id != $1
+      `, [currentUserId]);
+
+      const total = parseInt(countResult.rows[0].total);
+      const totalPages = Math.ceil(total / safeLimit);
+
+      // Get Connect4 users with wins/losses calculated from games table
+      // Sort by: win_rate DESC (players with 100% win rate first), then wins, then games played
+      const result = await this.pool.query(`
+        WITH connect4_stats AS (
+          SELECT
+            u.id as user_id,
+            u.wallet_address,
+            u.username,
+            u.avatar,
+            u.created_at,
+            COUNT(DISTINCT g.game_id) as games_played,
+            SUM(CASE WHEN g.game_status = 'completed' AND g.connect4_winner IN ('home', 'away') AND ugr.team_choice = g.connect4_winner THEN 1 ELSE 0 END) as wins,
+            SUM(CASE WHEN g.game_status = 'completed' AND g.connect4_winner IN ('home', 'away') AND ugr.team_choice != g.connect4_winner THEN 1 ELSE 0 END) as losses,
+            MAX(ugr.joined_at) as last_played_at
+          FROM users u
+          JOIN user_game_refs ugr ON ugr.wallet_address = u.wallet_address
+          JOIN games g ON g.game_id = ugr.game_id
+          WHERE g.game_type = 'connect4'
+          AND u.id != $1
+          GROUP BY u.id, u.wallet_address, u.username, u.avatar, u.created_at
+        )
+        SELECT
+          cs.*,
+          CASE WHEN (cs.wins + cs.losses) > 0
+            THEN ROUND((cs.wins::numeric / (cs.wins + cs.losses)) * 100, 1)
+            ELSE 0
+          END as win_rate,
+          EXISTS (
+            SELECT 1 FROM user_relationships
+            WHERE user_id = $1 AND target_user_id = cs.user_id AND relationship_type = 'friend'
+          ) as is_friend,
+          EXISTS (
+            SELECT 1 FROM user_relationships
+            WHERE user_id = $1 AND target_user_id = cs.user_id AND relationship_type = 'block'
+          ) as is_blocked,
+          EXISTS (
+            SELECT 1 FROM friend_requests
+            WHERE from_user_id = $1 AND to_user_id = cs.user_id AND status = 'pending'
+          ) as friend_request_sent,
+          EXISTS (
+            SELECT 1 FROM friend_requests
+            WHERE from_user_id = cs.user_id AND to_user_id = $1 AND status = 'pending'
+          ) as friend_request_received,
+          (
+            SELECT id FROM friend_requests
+            WHERE from_user_id = cs.user_id AND to_user_id = $1 AND status = 'pending'
+            LIMIT 1
+          ) as incoming_friend_request_id
+        FROM connect4_stats cs
+        ORDER BY
+          CASE WHEN (cs.wins + cs.losses) >= 3 THEN 1 ELSE 2 END,
+          win_rate DESC,
+          wins DESC,
+          games_played DESC
+        LIMIT $2 OFFSET $3
+      `, [currentUserId, safeLimit, offset]);
+
+      const users = result.rows.map(row => ({
+        userId: row.user_id,
+        walletAddress: row.wallet_address,
+        username: row.username,
+        avatar: row.avatar,
+        gamesPlayed: parseInt(row.games_played),
+        wins: parseInt(row.wins) || 0,
+        winRate: parseFloat(row.win_rate) || 0,
+        lastPlayedAt: row.last_played_at,
+        isFriend: row.is_friend,
+        isBlocked: row.is_blocked,
+        friendRequestSent: row.friend_request_sent,
+        friendRequestReceived: row.friend_request_received,
+        friendRequestId: row.incoming_friend_request_id,
+      }));
+
+      return {
+        users,
+        pagination: {
+          page,
+          limit: safeLimit,
+          total,
+          totalPages,
+          hasMore: page < totalPages,
+        },
+      };
+    } catch (error) {
+      console.error('Error discovering Connect4 users:', error);
+      return { users: [], pagination: { page, limit: safeLimit, total: 0, totalPages: 0, hasMore: false } };
+    }
+  }
+
+  /**
+   * Discover new/inactive users who haven't played any games yet
+   * @param {number} currentUserId - Current user's ID
+   * @param {object} options - { page, limit, sortBy }
+   */
+  async discoverNewUsers(currentUserId, options = {}) {
+    const { page = 1, limit = 20, sortBy = 'recent' } = options;
+    const offset = (page - 1) * limit;
+    const safeLimit = Math.min(Math.max(1, limit), 50);
+
+    // Sort by created_at for new users
+    const sortOrders = {
+      recent: 'u.created_at DESC',
+      activity: 'u.created_at DESC', // Fallback to recent for new users
+    };
+    const orderBy = sortOrders[sortBy] || sortOrders.recent;
+
+    try {
+      // Get total count of users without game history
+      const countResult = await this.pool.query(`
+        SELECT COUNT(*) as total
+        FROM users u
+        WHERE u.id != $1
+        AND NOT EXISTS (
+          SELECT 1 FROM user_game_refs ugr WHERE ugr.wallet_address = u.wallet_address
+        )
+      `, [currentUserId]);
+
+      const total = parseInt(countResult.rows[0].total);
+      const totalPages = Math.ceil(total / safeLimit);
+
+      // Get paginated new users with relationship info
+      const result = await this.pool.query(`
+        SELECT
+          u.id as user_id,
+          u.wallet_address,
+          u.username,
+          u.avatar,
+          u.created_at,
+          0 as games_played,
+          NULL as last_played_at,
+          EXISTS (
+            SELECT 1 FROM user_relationships
+            WHERE user_id = $1 AND target_user_id = u.id AND relationship_type = 'friend'
+          ) as is_friend,
+          EXISTS (
+            SELECT 1 FROM user_relationships
+            WHERE user_id = $1 AND target_user_id = u.id AND relationship_type = 'block'
+          ) as is_blocked,
+          EXISTS (
+            SELECT 1 FROM friend_requests
+            WHERE from_user_id = $1 AND to_user_id = u.id AND status = 'pending'
+          ) as friend_request_sent,
+          EXISTS (
+            SELECT 1 FROM friend_requests
+            WHERE from_user_id = u.id AND to_user_id = $1 AND status = 'pending'
+          ) as friend_request_received,
+          (
+            SELECT id FROM friend_requests
+            WHERE from_user_id = u.id AND to_user_id = $1 AND status = 'pending'
+            LIMIT 1
+          ) as incoming_friend_request_id
+        FROM users u
+        WHERE u.id != $1
+        AND NOT EXISTS (
+          SELECT 1 FROM user_game_refs ugr WHERE ugr.wallet_address = u.wallet_address
+        )
+        ORDER BY ${orderBy}
+        LIMIT $2 OFFSET $3
+      `, [currentUserId, safeLimit, offset]);
+
+      const users = result.rows.map(row => ({
+        userId: row.user_id,
+        walletAddress: row.wallet_address,
+        username: row.username,
+        avatar: row.avatar,
+        gamesPlayed: 0,
+        lastPlayedAt: null,
+        isFriend: row.is_friend,
+        isBlocked: row.is_blocked,
+        friendRequestSent: row.friend_request_sent,
+        friendRequestReceived: row.friend_request_received,
+        friendRequestId: row.incoming_friend_request_id,
+      }));
+
+      return {
+        users,
+        pagination: {
+          page,
+          limit: safeLimit,
+          total,
+          totalPages,
+          hasMore: page < totalPages,
+        },
+      };
+    } catch (error) {
+      console.error('Error discovering new users:', error);
+      return { users: [], pagination: { page, limit: safeLimit, total: 0, totalPages: 0, hasMore: false } };
+    }
+  }
+  /**
+   * Get leaderboard for the modal with multiple tab perspectives
+   * @param {string} gameType - connect4 | sports
+   * @param {string} tab - wins | winrate | earnings | grinder | efficiency
+   * @param {number} limit - max players to return (default 25, max 50)
+   */
+  async getLeaderboard(gameType = 'connect4', tab = 'wins', limit = 25) {
+    const safeLimit = Math.min(Math.max(1, parseInt(limit) || 25), 50);
+    const validTabs = ['wins', 'winrate', 'earnings', 'grinder', 'efficiency'];
+    const safeTab = validTabs.includes(tab) ? tab : 'wins';
+    const safeGameType = ['sports', 'esports', 'connect4'].includes(gameType) ? gameType : 'connect4';
+
+    const tabConfig = {
+      wins: {
+        where: '',
+        orderBy: 'wins DESC, win_rate DESC, games_played DESC',
+      },
+      winrate: {
+        where: 'AND games_played >= 10',
+        orderBy: 'win_rate DESC, games_played DESC',
+      },
+      earnings: {
+        where: '',
+        orderBy: 'total_claimed DESC, claim_per_game DESC',
+      },
+      grinder: {
+        where: '',
+        orderBy: 'games_played DESC, win_rate DESC',
+      },
+      efficiency: {
+        where: 'AND games_played >= 5',
+        orderBy: 'claim_per_game DESC, games_played DESC',
+      },
+    };
+
+    const config = tabConfig[safeTab];
+
+    // Build game-type-specific stats CTE
+    let statsCTE;
+    if (safeGameType === 'connect4') {
+      statsCTE = `
+          SELECT
+            u.wallet_address,
+            u.username,
+            u.avatar,
+            COUNT(*) AS games_played,
+            COUNT(*) FILTER (
+              WHERE g.game_status = 'completed'
+                AND g.connect4_winner = ugr.team_choice
+            ) AS wins,
+            COUNT(*) FILTER (
+              WHERE g.game_status = 'completed'
+                AND g.connect4_winner IS NOT NULL
+                AND g.connect4_winner != 'draw'
+                AND g.connect4_winner != ugr.team_choice
+            ) AS losses,
+            COUNT(*) FILTER (
+              WHERE g.game_status = 'completed'
+                AND g.connect4_winner = 'draw'
+            ) AS draws,
+            COALESCE(SUM(ugr.amount_claimed), 0) AS total_claimed
+          FROM user_game_refs ugr
+          JOIN games g ON g.game_id = ugr.game_id
+          LEFT JOIN users u ON u.wallet_address = ugr.wallet_address
+          WHERE g.game_type = 'connect4'
+          GROUP BY u.wallet_address, u.username, u.avatar
+        `;
+    } else if (safeGameType === 'esports') {
+      // Esports: game_type='sports' + game_mode=5 (PandaScore matches)
+      statsCTE = `
+          SELECT
+            u.wallet_address,
+            u.username,
+            u.avatar,
+            COUNT(*) AS games_played,
+            COUNT(*) FILTER (
+              WHERE g.is_resolved = true
+                AND g.sports_event->'finalScore' IS NOT NULL
+                AND ugr.team_choice = g.sports_event->'finalScore'->>'winner'
+            ) AS wins,
+            COUNT(*) FILTER (
+              WHERE g.is_resolved = true
+                AND g.sports_event->'finalScore' IS NOT NULL
+                AND ugr.team_choice != g.sports_event->'finalScore'->>'winner'
+            ) AS losses,
+            0::bigint AS draws,
+            COALESCE(SUM(ugr.amount_claimed), 0) AS total_claimed
+          FROM user_game_refs ugr
+          JOIN games g ON g.game_id = ugr.game_id
+          LEFT JOIN users u ON u.wallet_address = ugr.wallet_address
+          WHERE g.game_type = 'sports' AND g.game_mode = 5
+          GROUP BY u.wallet_address, u.username, u.avatar
+        `;
+    } else {
+      // Traditional sports: game_type='sports' + game_mode=4
+      statsCTE = `
+          SELECT
+            u.wallet_address,
+            u.username,
+            u.avatar,
+            COUNT(*) AS games_played,
+            COUNT(*) FILTER (
+              WHERE g.is_resolved = true
+                AND g.sports_event->'finalScore' IS NOT NULL
+                AND ugr.team_choice = g.sports_event->'finalScore'->>'winner'
+            ) AS wins,
+            COUNT(*) FILTER (
+              WHERE g.is_resolved = true
+                AND g.sports_event->'finalScore' IS NOT NULL
+                AND ugr.team_choice != g.sports_event->'finalScore'->>'winner'
+            ) AS losses,
+            0::bigint AS draws,
+            COALESCE(SUM(ugr.amount_claimed), 0) AS total_claimed
+          FROM user_game_refs ugr
+          JOIN games g ON g.game_id = ugr.game_id
+          LEFT JOIN users u ON u.wallet_address = ugr.wallet_address
+          WHERE g.game_type = 'sports' AND g.game_mode = 4
+          GROUP BY u.wallet_address, u.username, u.avatar
+        `;
+    }
+
+    try {
+      const result = await this.pool.query(`
+        WITH stats AS (
+          ${statsCTE}
+        ),
+        ranked AS (
+          SELECT
+            wallet_address,
+            username,
+            avatar,
+            games_played,
+            wins,
+            losses,
+            draws,
+            total_claimed,
+            CASE WHEN games_played > 0
+              THEN ROUND((wins::numeric / games_played) * 100, 1)
+              ELSE 0
+            END AS win_rate,
+            CASE WHEN games_played > 0
+              THEN ROUND(total_claimed::numeric / games_played, 4)
+              ELSE 0
+            END AS claim_per_game
+          FROM stats
+          WHERE games_played > 0
+          ${config.where}
+        )
+        SELECT *
+        FROM ranked
+        ORDER BY ${config.orderBy}
+        LIMIT $1
+      `, [safeLimit]);
+
+      const leaderboard = result.rows.map((row, i) => ({
+        rank: i + 1,
+        walletAddress: row.wallet_address,
+        username: row.username || null,
+        avatar: row.avatar || null,
+        gamesPlayed: parseInt(row.games_played),
+        wins: parseInt(row.wins),
+        losses: parseInt(row.losses),
+        draws: parseInt(row.draws),
+        winRate: parseFloat(row.win_rate),
+        totalClaimed: parseFloat(row.total_claimed),
+        claimPerGame: parseFloat(row.claim_per_game),
+      }));
+
+      return { gameType: safeGameType, tab: safeTab, leaderboard };
+    } catch (error) {
+      console.error(`Error getting ${safeGameType} leaderboard:`, error);
+      return { gameType: safeGameType, tab: safeTab, leaderboard: [] };
+    }
+  }
+}
+
+module.exports = SocialService;
+