use std::net::{Shutdown, TcpListener, TcpStream};
use std::thread;

fn handle_client(mut stream: TcpStream) -> std::io::Result<()> {
    let mut streamout = match stream.try_clone() {
        Ok(s) => s,
        Err(e) => return Err(e),
    };
    let mut clientstream = match TcpStream::connect("127.0.0.1:22") {
        Ok(thestream) => {
            println!("Connected to the server!");
            thestream
        }
        Err(e) => {
            println!("Couldn't connect to server... {}", e);
            stream.shutdown(Shutdown::Both).unwrap();
            return Err(e);
        }
    };
    let mut clientout = clientstream.try_clone().expect("clone failed...");
    thread::spawn(move || {
        std::io::copy(&mut clientstream, &mut streamout);
        let v: Result<&str, ()> = Ok("a");
        v
    });
    std::io::copy(&mut stream, &mut clientout);
    Ok(())
}

fn main() {
    let listener = TcpListener::bind("0.0.0.0:3333").unwrap();
    // accept connections and process them, spawning a new thread for each one
    println!("Server listening on port 3333");
    for stream in listener.incoming() {
        match stream {
            Ok(stream) => {
                println!("New connection: {}", stream.peer_addr().unwrap());
                thread::spawn(move || {
                    // connection succeeded
                    handle_client(stream)
                });
            }
            Err(e) => {
                println!("Error: {}", e);
                /* connection failed */
            }
        }
    }
    // close the socket server
    drop(listener);
}