# 客户端请求（HTTP Upgrade）
GET /chat HTTP/1.1
Host: example.com
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==
Sec-WebSocket-Version: 13
Origin: https://example.com

# 服务器响应
HTTP/1.1 101 Switching Protocols
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=

const http = require('http');
const crypto = require('crypto');

const MAGIC_STRING = '258EAFA5-E914-47DA-95CA-C5AB0DC85B11';

const server = http.createServer();

server.on('upgrade', (req, socket, head) => {
    const key = req.headers['sec-websocket-key'];
    const acceptKey = crypto
        .createHash('sha1')
        .update(key + MAGIC_STRING)
        .digest('base64');
    
    socket.write(
        'HTTP/1.1 101 Switching Protocols\r\n' +
        'Upgrade: websocket\r\n' +
        'Connection: Upgrade\r\n' +
        `Sec-WebSocket-Accept: ${acceptKey}\r\n` +
        '\r\n'
    );
    
    // 握手完成，可以开始 WebSocket 通信
    console.log('WebSocket 连接已建立');
});

server.listen(3000);

const WebSocket = require('ws');
const http = require('http');

const server = http.createServer();
const wss = new WebSocket.Server({ server });

wss.on('connection', (ws, req) => {
    console.log('新连接:', req.socket.remoteAddress);
    
    // 接收消息
    ws.on('message', (data, isBinary) => {
        if (isBinary) {
            console.log('收到二进制数据:', data.length, '字节');
        } else {
            const message = data.toString();
            console.log('收到消息:', message);
            
            // 广播给所有客户端
            wss.clients.forEach(client => {
                if (client.readyState === WebSocket.OPEN) {
                    client.send(message);
                }
            });
        }
    });
    
    // 发送欢迎消息
    ws.send(JSON.stringify({
        type: 'welcome',
        message: '连接成功',
        timestamp: Date.now()
    }));
    
    // 连接关闭
    ws.on('close', (code, reason) => {
        console.log('连接关闭:', code, reason.toString());
    });
    
    // 错误处理
    ws.on('error', (error) => {
        console.error('WebSocket 错误:', error);
    });
});

server.listen(3000, () => {
    console.log('WebSocket 服务器运行在 ws://localhost:3000');
});

// 浏览器端
const ws = new WebSocket('ws://localhost:3000');

// 连接打开
ws.onopen = () => {
    console.log('连接已建立');
    ws.send(JSON.stringify({ type: 'greeting', data: '你好' }));
};

// 接收消息
ws.onmessage = (event) => {
    const data = JSON.parse(event.data);
    console.log('收到:', data);
};

// 连接关闭
ws.onclose = (event) => {
    console.log('连接关闭:', event.code, event.reason);
};

// 错误处理
ws.onerror = (error) => {
    console.error('WebSocket 错误:', error);
};

// 发送消息
ws.send('Hello WebSocket');
ws.send(JSON.stringify({ type: 'message', content: '你好' }));
ws.send(arrayBuffer);  // 发送二进制数据

// 服务端心跳
class HeartbeatManager {
    constructor(wss, interval = 30000) {
        this.wss = wss;
        this.interval = interval;
        this.start();
    }
    
    start() {
        this.timer = setInterval(() => {
            this.wss.clients.forEach(ws => {
                if (ws.isAlive === false) {
                    console.log('连接超时，断开');
                    return ws.terminate();
                }
                
                ws.isAlive = false;
                ws.ping();  // 发送 Ping
            });
        }, this.interval);
    }
    
    stop() {
        clearInterval(this.timer);
    }
}

// 使用
const wss = new WebSocket.Server({ server });

wss.on('connection', (ws) => {
    ws.isAlive = true;
    
    ws.on('pong', () => {
        ws.isAlive = true;  // 收到 Pong，连接正常
    });
});

const heartbeat = new HeartbeatManager(wss, 30000);

// 应用层心跳（兼容性更好）
class AppHeartbeat {
    constructor(ws, interval = 25000) {
        this.ws = ws;
        this.interval = interval;
        this.timeout = null;
        this.start();
    }
    
    start() {
        // 定期发送 ping
        this.pingTimer = setInterval(() => {
            if (this.ws.readyState === WebSocket.OPEN) {
                this.ws.send(JSON.stringify({ type: 'ping', ts: Date.now() }));
            }
        }, this.interval);
        
        // 等待 pong 响应
        this.ws.on('message', (data) => {
            const msg = JSON.parse(data.toString());
            if (msg.type === 'pong') {
                clearTimeout(this.timeout);
            }
        });
    }
    
    stop() {
        clearInterval(this.pingTimer);
        clearTimeout(this.timeout);
    }
}

class ReconnectingWebSocket {
    constructor(url, options = {}) {
        this.url = url;
        this.maxRetries = options.maxRetries || 10;
        this.baseDelay = options.baseDelay || 1000;
        this.maxDelay = options.maxDelay || 30000;
        this.retryCount = 0;
        
        this.connect();
    }
    
    connect() {
        this.ws = new WebSocket(this.url);
        
        this.ws.onopen = () => {
            console.log('连接成功');
            this.retryCount = 0;  // 重置重试计数
            this.onopen?.();
        };
        
        this.ws.onmessage = (event) => {
            this.onmessage?.(event);
        };
        
        this.ws.onclose = (event) => {
            console.log('连接关闭:', event.code);
            this.onclose?.(event);
            
            if (!event.wasClean && this.retryCount < this.maxRetries) {
                this.scheduleReconnect();
            }
        };
        
        this.ws.onerror = (error) => {
            console.error('连接错误:', error);
            this.onerror?.(error);
        };
    }
    
    scheduleReconnect() {
        this.retryCount++;
        
        // 指数退避 + 随机抖动
        const delay = Math.min(
            this.baseDelay * Math.pow(2, this.retryCount - 1) + Math.random() * 1000,
            this.maxDelay
        );
        
        console.log(`将在 ${delay}ms 后重连 (第 ${this.retryCount} 次)`);
        
        setTimeout(() => this.connect(), delay);
    }
    
    send(data) {
        if (this.ws.readyState === WebSocket.OPEN) {
            this.ws.send(data);
        } else {
            console.warn('连接未就绪，消息未发送');
        }
    }
    
    close() {
        this.maxRetries = 0;  // 禁止自动重连
        this.ws.close();
    }
}

// 使用
const ws = new ReconnectingWebSocket('ws://localhost:3000');
ws.onmessage = (event) => console.log('收到:', event.data);
ws.send('Hello');

// 多房间聊天室
const WebSocket = require('ws');

class ChatServer {
    constructor(server) {
        this.wss = new WebSocket.Server({ server });
        this.rooms = new Map();  // room -> Set<ws>
        this.clients = new Map(); // ws -> { rooms: Set, username: string }
        
        this.wss.on('connection', (ws) => this.handleConnection(ws));
    }
    
    handleConnection(ws) {
        this.clients.set(ws, { rooms: new Set(), username: null });
        
        ws.on('message', (data) => {
            const msg = JSON.parse(data.toString());
            this.handleMessage(ws, msg);
        });
        
        ws.on('close', () => {
            const client = this.clients.get(ws);
            client.rooms.forEach(room => this.leaveRoom(ws, room));
            this.clients.delete(ws);
        });
    }
    
    handleMessage(ws, msg) {
        switch (msg.type) {
            case 'join':
                this.joinRoom(ws, msg.room);
                break;
            case 'leave':
                this.leaveRoom(ws, msg.room);
                break;
            case 'message':
                this.broadcastToRoom(msg.room, {
                    type: 'message',
                    from: this.clients.get(ws).username,
                    content: msg.content,
                    timestamp: Date.now()
                }, ws);
                break;
            case 'set_username':
                this.clients.get(ws).username = msg.username;
                break;
        }
    }
    
    joinRoom(ws, room) {
        if (!this.rooms.has(room)) {
            this.rooms.set(room, new Set());
        }
        this.rooms.get(room).add(ws);
        this.clients.get(ws).rooms.add(room);
        
        this.broadcastToRoom(room, {
            type: 'system',
            message: `${this.clients.get(ws).username} 加入了房间`
        });
    }
    
    leaveRoom(ws, room) {
        this.rooms.get(room)?.delete(ws);
        this.clients.get(ws).rooms.delete(room);
        
        this.broadcastToRoom(room, {
            type: 'system',
            message: `${this.clients.get(ws).username} 离开了房间`
        });
    }
    
    broadcastToRoom(room, message, excludeWs = null) {
        const clients = this.rooms.get(room);
        if (!clients) return;
        
        const data = JSON.stringify(message);
        clients.forEach(client => {
            if (client !== excludeWs && client.readyState === WebSocket.OPEN) {
                client.send(data);
            }
        });
    }
}

module.exports = ChatServer;

# WebSocket 代理配置
location /ws/ {
    proxy_pass http://backend;
    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_read_timeout 3600s;
    proxy_send_timeout 3600s;
}

// 认证中间件
wss.on('connection', (ws, req) => {
    // 验证 Origin
    const origin = req.headers.origin;
    if (!allowedOrigins.includes(origin)) {
        ws.close(1008, '不允许的来源');
        return;
    }
    
    // 验证 Token
    const token = new URL(req.url, 'http://localhost').searchParams.get('token');
    try {
        const payload = jwt.verify(token, SECRET);
        ws.user = payload;
    } catch (err) {
        ws.close(1008, '认证失败');
        return;
    }
    
    // 限流
    ws.messageCount = 0;
    ws.lastMessageTime = Date.now();
});