💬 Real-time Chat System

┌─────────────────────────────────────────────────────┐
│                   Nginx (Reverse Proxy)              │
│   https://khonggianai.com                           │
│   ┌──────────────┐    ┌───────────────────┐         │
│   │  HTTP /*     │    │  WebSocket /ws/*  │         │
│   └──────┬───────┘    └────────┬──────────┘         │
└──────────┼─────────────────────┼────────────────────┘
           │                     │
     ┌─────▼──────┐      ┌──────▼──────┐
     │ WordPress  │      │ Chat Server │
     │ PHP :8083  │◄────►│ Node :3030  │
     │            │ REST │ Socket.IO   │
     └─────┬──────┘ API  └──────┬──────┘
           │                     │
     ┌─────▼─────────────────────▼──────┐
     │         Docker Network           │
     │  ┌──────────┐  ┌──────────────┐  │
     │  │ MySQL 8  │  │ Redis Alpine │  │
     │  │ :3306    │  │ Pub/Sub +    │  │
     │  │          │  │ Sessions     │  │
     │  └──────────┘  └──────────────┘  │
     └──────────────────────────────────┘

CREATE TABLE wp_kgai_chat_rooms (
    id BIGINT AUTO_INCREMENT PRIMARY KEY,
    slug VARCHAR(100) UNIQUE NOT NULL,
    name VARCHAR(200) NOT NULL,
    description TEXT,
    type ENUM('community','private','random') DEFAULT 'community',
    icon VARCHAR(50) DEFAULT '💬',
    max_members INT DEFAULT 0,     -- 0 = unlimited
    is_active TINYINT(1) DEFAULT 1,
    created_at DATETIME DEFAULT CURRENT_TIMESTAMP
) ENGINE=InnoDB;

CREATE TABLE wp_kgai_chat_messages (
    id BIGINT AUTO_INCREMENT PRIMARY KEY,
    room_id BIGINT NOT NULL,
    user_id BIGINT NOT NULL,
    message TEXT NOT NULL,
    message_type ENUM('text','image','link','system') DEFAULT 'text',
    reply_to BIGINT DEFAULT NULL,
    is_deleted TINYINT(1) DEFAULT 0,
    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
    INDEX idx_room_created (room_id, created_at),
    INDEX idx_user (user_id),
    FOREIGN KEY (room_id) REFERENCES wp_kgai_chat_rooms(id)
) ENGINE=InnoDB;

CREATE TABLE wp_kgai_chat_members (
    id BIGINT AUTO_INCREMENT PRIMARY KEY,
    room_id BIGINT NOT NULL,
    user_id BIGINT NOT NULL,
    role ENUM('member','admin','moderator') DEFAULT 'member',
    last_read_at DATETIME DEFAULT NULL,
    joined_at DATETIME DEFAULT CURRENT_TIMESTAMP,
    UNIQUE KEY uk_room_user (room_id, user_id),
    FOREIGN KEY (room_id) REFERENCES wp_kgai_chat_rooms(id)
) ENGINE=InnoDB;

CREATE TABLE wp_kgai_chat_random (
    id BIGINT AUTO_INCREMENT PRIMARY KEY,
    user_1 BIGINT NOT NULL,
    user_2 BIGINT NOT NULL,
    room_id BIGINT NOT NULL,
    status ENUM('active','ended','reported') DEFAULT 'active',
    started_at DATETIME DEFAULT CURRENT_TIMESTAMP,
    ended_at DATETIME DEFAULT NULL,
    FOREIGN KEY (room_id) REFERENCES wp_kgai_chat_rooms(id)
) ENGINE=InnoDB;

Browser               WordPress              Chat Server           Redis
   │                      │                       │                    │
   │── Login ────────────►│                       │                    │
   │◄── wp_cookie ────────│                       │                    │
   │                      │                       │                    │
   │── GET /chat-token ──►│                       │                    │
   │◄── JWT token ────────│                       │                    │
   │                      │                       │                    │
   │── Connect WS + JWT ──────────────────────────►│                    │
   │                      │◄── verify-token ──────│                    │
   │                      │── { user_id, name } ──►│                    │
   │                      │                       │── store session ──►│
   │◄────────────────── Connected  ─────────────│                    │

// Generate JWT cho authenticated user
register_rest_route('kgai/v1', '/chat-token', [
    'methods'  => 'GET',
    'callback' => function() {
        $user = wp_get_current_user();
        $payload = [
            'user_id'    => $user->ID,
            'name'       => $user->display_name,
            'avatar'     => get_avatar_url($user->ID, ['size' => 80]),
            'membership' => kgai_get_member($user->ID),
            'exp'        => time() + 86400 // 24h
        ];
        return ['token' => kgai_jwt_encode($payload)];
    },
    'permission_callback' => 'is_user_logged_in'
]);

// Join room
socket.emit('room:join', { roomSlug: 'general' });

// Send message
socket.emit('message:send', {
    roomId: 1,
    message: 'Hello mọi người!',
    type: 'text'
});

// Listen for new messages
socket.on('message:new', (data) => {
    // { id, user: { id, name, avatar }, message, type, created_at }
    renderMessage(data);
});

// Online users in room
socket.on('room:users', (users) => {
    // [{ id, name, avatar }]
    updateOnlineList(users);
});

// Typing indicator
socket.emit('typing:start', { roomId: 1 });
socket.on('typing:show', ({ user }) => showTyping(user));

// Start private conversation
socket.emit('private:start', { targetUserId: 42 });
socket.on('private:room', ({ roomId }) => {
    // Navigate to private chat room
    openPrivateChat(roomId);
});

// Get inbox (list of private conversations)
socket.emit('inbox:list');
socket.on('inbox:data', (conversations) => {
    // [{ roomId, user: {...}, lastMessage, unreadCount, updatedAt }]
    renderInbox(conversations);
});

┌─────────────┐     ┌──────────────────┐     ┌─────────────┐
│   User A    │────►│  Redis Queue     │◄────│   User B    │
│  "Tìm"     │     │  FIFO matching   │     │  "Tìm"      │
└─────────────┘     └────────┬─────────┘     └─────────────┘
                             │
                    ┌────────▼─────────┐
                    │  Match Found!    │
                    │  Create room     │
                    │  Notify both     │
                    └──────────────────┘

Flow:
1. User A clicks "Tìm người" → RPUSH chat:random:queue userA
2. User B clicks "Tìm người" → LPOP chat:random:queue → gets userA
3. Server creates temporary room (type: random)
4. Both users auto-join room → start chatting
5. Either user clicks "Kết thúc" → room destroyed
6. Click "Tìm tiếp" → back to step 1

// services/matching.js
async function findMatch(userId) {
    const redis = getRedis();
    const queueKey = 'chat:random:queue';

    // Try to find someone waiting
    const matchedUser = await redis.lpop(queueKey);

    if (matchedUser && matchedUser !== String(userId)) {
        // Match found! Create room
        const room = await createRoom({
            slug: `random-${Date.now()}`,
            type: 'random',
            name: 'Random Chat'
        });
        return { matched: true, roomId: room.id, partnerId: matchedUser };
    }

    // No match, add to queue with 30s TTL
    await redis.rpush(queueKey, String(userId));
    await redis.expire(queueKey, 30);
    return { matched: false, waiting: true };
}

// middleware/ratelimit.js
const rateLimits = new Map();

function checkRateLimit(userId) {
    const key = `rate:${userId}`;
    const now = Date.now();
    const windowMs = 60000; // 1 minute
    const maxMessages = 30;

    if (!rateLimits.has(key)) {
        rateLimits.set(key, []);
    }

    const timestamps = rateLimits.get(key)
        .filter(t => now - t < windowMs);

    if (timestamps.length >= maxMessages) {
        return false; // Rate limited
    }

    timestamps.push(now);
    rateLimits.set(key, timestamps);
    return true;
}

FROM node:20-alpine
WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production
COPY src/ ./src/
EXPOSE 3030
CMD ["node", "src/index.js"]

  chat:
    build:
      context: ./chat-server
      dockerfile: Dockerfile
    container_name: kgai_chat
    restart: always
    depends_on:
      - db
      - redis
    environment:
      NODE_ENV: production
      REDIS_URL: redis://redis:6379
      MYSQL_HOST: db
      MYSQL_USER: ${MYSQL_USER:-wordpress}
      MYSQL_PASSWORD: ${MYSQL_PASSWORD:-wordpress}
      MYSQL_DATABASE: ${MYSQL_DATABASE:-wordpress}
      WP_API_URL: http://wordpress/wp-json/kgai/v1
      JWT_SECRET: ${JWT_SECRET}
    ports:
      - "3030:3030"
    networks:
      - kgai_network

# WebSocket proxy cho Chat Server
location /ws/ {
    proxy_pass http://127.0.0.1:3030/;
    proxy_http_version 1.1;
    proxy_set_header Upgrade $http_upgrade;
    proxy_set_header Connection "upgrade";
    proxy_set_header Host $host;
    proxy_set_header X-Real-IP $remote_addr;
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    proxy_read_timeout 86400;  # 24h keep-alive
}

script: |
    cd /var/www/html/wp-kgai
    git fetch origin main
    git reset --hard origin/main

    # Build & restart ALL services (including chat)
    docker compose -f docker-compose.prod.yml down
    docker compose -f docker-compose.prod.yml up -d --build

    # Run chat DB migrations
    docker exec kgai_chat node src/migrate.js 2>/dev/null || true

    docker image prune -f