use structopt::StructOpt;
use tokio::net::TcpListener;

use quic_demo::prelude::*;
use protocol::PeerId;

#[derive (Debug, StructOpt)]
struct Opt {
	#[structopt (long)]
	relay_addr: Option <String>,
	#[structopt (long)]
	client_id: Option <PeerId>,
	#[structopt (long)]
	server_id: Option <PeerId>,
	#[structopt (long)]
	client_tcp_port: Option <u16>,
	#[structopt (long)]
	server_tcp_port: Option <u16>,
}

#[tokio::main]
async fn main () -> anyhow::Result <()> {
	tracing_subscriber::fmt::init ();
	
	let opt = Opt::from_args ();
	
	let server_cert = tokio::fs::read ("quic_server.crt").await?;
	let relay_addr = opt.relay_addr.unwrap_or_else (|| String::from ("127.0.0.1:30380")).parse ()?;
	let endpoint = make_client_endpoint ("0.0.0.0:0".parse ()?, &[&server_cert])?;
	
	debug! ("Connecting to relay server");
	
	let client_id = opt.client_id.unwrap_or_else (|| "bogus_client".to_string ());
	
	let quinn::NewConnection {
		connection,
		..
	} = protocol::p2_connect_to_p3 (&endpoint, &relay_addr, &client_id).await?;
	
	// End of per-client stuff
	// Beginning of per-port stuff
	
	let server_id = opt.server_id.unwrap_or_else (|| "bogus_server".to_string ());
	
	let client_tcp_port = opt.client_tcp_port.unwrap_or (30381);
	let server_tcp_port = opt.server_tcp_port.unwrap_or (30382);
	let listener = TcpListener::bind (("127.0.0.1", client_tcp_port)).await?;
	
	// End of per-port stuff
	// Beginning of per-connection stuff
	
	let task_tcp_server = tokio::spawn (async move {
		loop {
			let (tcp_socket, _) = listener.accept ().await?;
			let connection = connection.clone ();
			let server_id = server_id.clone ();
			
			tokio::spawn (async move {
				let (local_recv, local_send) = tcp_socket.into_split ();
				
				debug! ("Starting PTTH connection");
				
				let (relay_send, relay_recv) = protocol::p2_connect_to_p5 (&connection, &server_id, server_tcp_port).await?;
				
				trace! ("Relaying bytes...");
				
				let ptth_conn = quic_demo::connection::NewConnection {
					local_send,
					local_recv,
					relay_send,
					relay_recv,
				}.build ();
				
				ptth_conn.wait_for_close ().await?;
				
				debug! ("Ended PTTH connection");
				
				Ok::<_, anyhow::Error> (())
			});
		}
		
		Ok::<_, anyhow::Error> (())
	});
	
	debug! ("Accepting local TCP connections from P1");
	
	task_tcp_server.await??;
	
	Ok (())
}