Creating ws and normal tcp using tcp in one listener

help
1 
    let listener = TcpListener::bind("127.0.0.1:7878").unwrap();
    println!("🚀 Server running on port 7878");

    for stream in listener.incoming() {
        match stream {
            Ok(stream) => {
                std::thread::spawn(move || {
                    handle_connection(stream);
                });
            }
            Err(e) => eprintln!("❌ Connection failed: {}", e),
        }
    }
    // }

    fn handle_connection(mut stream: TcpStream) {
        let mut buffer = [0; 1024];

        // Read full request
        match stream.peek(&mut buffer) {
            Ok(n) if n > 0 => {
                let request = String::from_utf8_lossy(&buffer[..n]);
                println!("📨 Received:\n{}", request);

                // WebSocket handshake detection
                if request.contains("Upgrade: websocket") {
                    stream.read(&mut buffer);
                    println!("🔄 Upgrading to WebSocket...");
                    // let mut cloned_stream = stream; // Clone stream for WebSocket
                    // cloned_stream.read(&mut buffer);
                    if let Ok(ws) = accept(stream) {
                        handle_websocket(ws);
                    }
                    return;
                } else {
                    stream.read(&mut buffer);
                    // Handle normal HTTP request
                    let response_body = "billionairegreathari";
                    let response = format!(
                        "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\nContent-Length: {}\r\nConnection: keep-alive\r\n\r\n{}",
                        response_body.len(),
                        response_body
                    );
                    stream.write_all(response.as_bytes()).unwrap();
                    stream.flush().unwrap();
                    println!("✅ Sent HTTP response");
                }
            }
            _ => println!("❌ Failed to read request"),
        }
    }

    fn handle_websocket(mut ws: tungstenite::WebSocket<TcpStream>) {
        loop {
            match ws.read() {
                Ok(Message::Text(text)) => {
                    println!("📨 Received WebSocket message: {}", text);
                    ws.send(Message::Text(format!("Echo: {}", text).into()))
                        .unwrap();
                }
                Ok(Message::Binary(data)) => {
                    println!("📨 Received Binary Data: {:?}", data);
                }
                Ok(Message::Close(_)) => {
                    println!("❌ WebSocket Closed");
                    break;
                }
                Err(err) => {
                    println!("⚠️ WebSocket error: {}", err);
                    break;
                }
                _ => {}
            }
        }
    }

but not returning body while using read in stream