/*
[dependencies]
futurespreview = {version = "0.3.0-alpha.12", package = "futures-preview", features = ["compat"]}
tokio = {version = "0.1.14", features = ["async-await-preview"]}
structopt = "*"
*/

#![feature(futures_api, never_type, async_await, await_macro)]
use futurespreview::prelude::{FutureExt, TryFutureExt};
use structopt::StructOpt;
//use tokio::prelude::{Stream, StreamExt};
//use tokio::compat::Compat;
use tokio::prelude::*;
use std::error::Error;
use std::net::{IpAddr, SocketAddr};

use tokio::net::{TcpListener, TcpStream};

#[derive(Debug, StructOpt)]
#[structopt(name = "SimpleProxy", about = "A simple async proxy")]
struct Cli {
    #[structopt(long = "localhost", parse(try_from_str), default_value = "0.0.0.0")]
    localhost: IpAddr,

    #[structopt(short = "l", parse(try_from_str), default_value = "8080")]
    localport: u16,

    #[structopt(short = "r", long = "remhotehost", parse(try_from_str))]
    remotehost: IpAddr,

    #[structopt(short = "p", long = "remoteport", parse(try_from_str))]
    remoteport: u16,
}

async fn server(
    server_addr: SocketAddr,
    remote_addr: SocketAddr,
) -> Result<!, Box<dyn Error + 'static>> {
    let mut listener = TcpListener::bind(&server_addr)?;

    let mut stream = listener.incoming();

    while let Some(Ok(tcp)) = await!(stream.next()) {
        /*
        tokio::spawn_async(async move {
            let (server_reader, server_writer) = tcp.split();

            let remote_connection = await!(TcpStream::connect(&remote_addr))?;
            let (remote_reader, remote_writer) = remote_connection.split();

            Ok(())
        });
        */
    }

    loop {}
}

fn main() {
    let app = Cli::from_args();

    let server_addr = SocketAddr::new(app.localhost, app.localport);
    let host_addr = SocketAddr::new(app.remotehost, app.remoteport);

    tokio::spawn_async(server(server_addr, host_addr).map(|_| {}).map_err(|e| {
        eprintln!("{}", e.description());
    })
}