// 完整的 VLESS over WebSocket 服务器 - 单文件版本
const http = require('http');
const net = require('net');
const crypto = require('crypto');

// 配置
const PORT = process.argv[2] || 1080;
const UUID = '11112222-3333-4444-aaaa-bbbbccccdddd';
const WS_PATH = '/ws';

// 简化的 WebSocket 实现
class SimpleWebSocket {
    constructor(req, socket) {
        this.socket = socket;
        this.established = false;
        this.handleHandshake(req);
    }

    handleHandshake(req) {
        const key = req.headers['sec-websocket-key'];
        const accept = crypto.createHash('sha1')
            .update(key + '258EAFA5-E914-47DA-95CA-C5AB0DC85B11')
            .digest('base64');
        
        const response = [
            'HTTP/1.1 101 Switching Protocols',
            'Upgrade: websocket',
            'Connection: Upgrade',
            `Sec-WebSocket-Accept: ${accept}`,
            '\r\n'
        ].join('\r\n');
        
        this.socket.write(response);
        this.established = true;
    }

    send(data) {
        if (!this.established) return;
        const header = Buffer.alloc(2);
        header[0] = 0x82; // FIN + binary frame
        header[1] = data.length;
        this.socket.write(Buffer.concat([header, data]));
    }

    onMessage(callback) {
        let buffer = Buffer.alloc(0);
        
        this.socket.on('data', (data) => {
            if (!this.established) return;
            
            buffer = Buffer.concat([buffer, data]);
            
            while (buffer.length >= 2) {
                const opcode = buffer[0] & 0x0F;
                const payloadLength = buffer[1] & 0x7F;
                let headerLength = 2;
                
                if (payloadLength === 126) {
                    if (buffer.length < 4) break;
                    headerLength = 4;
                } else if (payloadLength === 127) {
                    if (buffer.length < 10) break;
                    headerLength = 10;
                }
                
                const totalLength = headerLength + payloadLength;
                if (buffer.length < totalLength) break;
                
                const payload = buffer.slice(headerLength, totalLength);
                buffer = buffer.slice(totalLength);
                
                if (opcode === 0x02) { // binary frame
                    callback(payload);
                }
            }
        });
    }
}

// VLESS 协议处理
function parseVLessHeader(data) {
    try {
        if (data.length < 16) return null;
        
        // 验证 UUID
        const receivedUUID = data.slice(0, 16).toString('hex');
        const expectedUUID = UUID.replace(/-/g, '');
        if (receivedUUID !== expectedUUID) {
            console.log('UUID 验证失败');
            return null;
        }
        
        let offset = 16;
        if (data.length < offset + 3) return null;
        
        const additionalId = data.readUInt8(offset); offset += 1;
        const command = data.readUInt8(offset); offset += 1;
        
        if (command !== 0x01) {
            console.log('只支持 TCP 命令');
            return null;
        }
        
        const addressType = data.readUInt8(offset); offset += 1;
        let remoteHost = '';
        
        switch (addressType) {
            case 0x01: // IPv4
                if (data.length < offset + 4) return null;
                remoteHost = Array.from(data.slice(offset, offset + 4)).join('.');
                offset += 4;
                break;
                
            case 0x03: // 域名
                if (data.length < offset + 1) return null;
                const domainLength = data.readUInt8(offset); offset += 1;
                if (data.length < offset + domainLength) return null;
                remoteHost = data.slice(offset, offset + domainLength).toString();
                offset += domainLength;
                break;
                
            case 0x04: // IPv6
                if (data.length < offset + 16) return null;
                remoteHost = data.slice(offset, offset + 16).toString('hex')
                    .match(/.{1,4}/g).join(':');
                offset += 16;
                break;
                
            default:
                console.log('不支持的地址类型:', addressType);
                return null;
        }
        
        if (data.length < offset + 2) return null;
        const remotePort = data.readUInt16BE(offset); offset += 2;
        
        return {
            remoteHost,
            remotePort,
            remainingData: data.slice(offset)
        };
        
    } catch (error) {
        console.error('解析 VLESS 头部错误:', error);
        return null;
    }
}

// 创建服务器
const server = http.createServer((req, res) => {
    if (req.url === '/health' || req.url === '/status') {
        res.writeHead(200, { 'Content-Type': 'application/json' });
        res.end(JSON.stringify({ 
            status: 'ok', 
            service: 'vless-ws',
            timestamp: Date.now(),
            port: PORT 
        }));
        return;
    }
    
    res.writeHead(404);
    res.end('Not Found');
});

server.on('upgrade', (req, socket) => {
    if (req.url === WS_PATH) {
        console.log(`📡 新的 WebSocket 连接: ${socket.remoteAddress}`);
        
        const ws = new SimpleWebSocket(req, socket);
        let remoteSocket = null;
        
        ws.onMessage((data) => {
            if (!remoteSocket) {
                const headerInfo = parseVLessHeader(data);
                if (!headerInfo) {
                    socket.destroy();
                    return;
                }
                
                console.log(`🔗 连接目标: ${headerInfo.remoteHost}:${headerInfo.remotePort}`);
                
                remoteSocket = net.connect(headerInfo.remotePort, headerInfo.remoteHost, () => {
                    if (headerInfo.remainingData.length > 0) {
                        remoteSocket.write(headerInfo.remainingData);
                    }
                });
                
                remoteSocket.on('data', (chunk) => {
                    ws.send(chunk);
                });
                
                remoteSocket.on('error', (err) => {
                    console.error('远程连接错误:', err.message);
                    socket.destroy();
                });
                
                remoteSocket.on('close', () => {
                    socket.destroy();
                });
                
            } else {
                remoteSocket.write(data);
            }
        });
        
        socket.on('error', (err) => {
            console.error('Socket 错误:', err.message);
            if (remoteSocket) remoteSocket.destroy();
        });
        
        socket.on('close', () => {
            if (remoteSocket) remoteSocket.destroy();
        });
        
    } else {
        socket.destroy();
    }
});

// 启动服务器
server.listen(PORT, '0.0.0.0', () => {
    console.log('🚀 VLESS over WebSocket 服务器启动成功');
    console.log(`📍 端口: ${PORT}`);
    console.log(`🔑 UUID: ${UUID}`);
    console.log(`🛣️  路径: ${WS_PATH}`);
    console.log('✅ 服务已就绪，可通过 CDN 访问');
});

// 错误处理
server.on('error', (err) => {
    console.error('服务器错误:', err.message);
});

process.on('SIGINT', () => {
    console.log('\n🛑 关闭服务器...');
    server.close();
});