pub mod http_serde;

// It's easier if the server can stream its response body
// back to the relay un-changed inside its request body
// So we wrap the server's actual response head
// (status code, headers, etc.) in this one header field.

pub const PTTH_MAGIC_HEADER: &str = "X-PTTH-2LJYXWC4";

// Basically binaries, but in the lib we can do experimental
// test stuff like spawn them both in the same process

pub mod relay;
pub mod server;

pub fn prefix_match <'a> (hay: &'a str, needle: &str) -> Option <&'a str>
{
	if hay.starts_with (needle) {
		Some (&hay [needle.len ()..])
	}
	else {
		None
	}
}


#[cfg (test)]
mod tests {
	use std::{
		sync::Arc,
	};
	
	use tokio::{
		runtime::Runtime,
		spawn,
	};
	
	use super::{
		relay,
		server,
	};
	
	#[test]
	fn end_to_end () {
		use maplit::*;
		use reqwest::Client;
		
		let mut rt = Runtime::new ().unwrap ();
		
		// Spawn the root task
		rt.block_on (async {
			let server_name = "alien_wildlands";
			let api_key = "AnacondaHardcoverGrannyUnlatchLankinessMutate";
			let tripcode = base64::encode (blake3::hash (api_key.as_bytes ()).as_bytes ());
			println! ("Relay is expecting tripcode {}", tripcode);
			let config_file = relay::ConfigFile {
				port: None,
				server_tripcodes: hashmap! {
					server_name.into () => tripcode,
				},
			};
			
			let relay_state = Arc::new (relay::RelayState::from (&config_file));
			
			let relay_state_2 = relay_state.clone ();
			spawn (async move {
				relay::run_relay (relay_state_2).await.unwrap ();
			});
			
			assert! (relay_state.list_servers ().await.is_empty ());
			
			let relay_url = "http://127.0.0.1:4000";
			let relay_url_2 = relay_url.into ();
			
			let config_file = server::ConfigFile {
				name: server_name.into (),
				api_key: api_key.into (), 
			};
			spawn (async move {
				let opt = server::Opt {
					relay_url: relay_url_2,
					file_server_root: "./".into (),
				};
				
				server::main (config_file, opt).await.unwrap ();
			});
			
			tokio::time::delay_for (std::time::Duration::from_millis (500)).await;
			
			assert_eq! (relay_state.list_servers ().await, vec! [
				server_name.to_string (),
			]);
			
			let client = Client::builder ()
			.timeout (std::time::Duration::from_secs (2))
			.build ().unwrap ();
			
			let resp = client.get (&format! ("{}/relay_up_check", relay_url))
			.send ().await.unwrap ().bytes ().await.unwrap ();
			
			assert_eq! (resp, "Relay is up\n");
			
			let resp = client.get (&format! ("{}/servers/{}/files/COPYING", relay_url, server_name))
			.send ().await.unwrap ().bytes ().await.unwrap ();
			
			if blake3::hash (&resp) != blake3::Hash::from ([
				0xca, 0x02, 0x92, 0x78,
				0x9c, 0x0a, 0x0e, 0xcb,
				0xa7, 0x06, 0xf4, 0xb3,
				0xf3, 0x49, 0x30, 0x07,
				
				0xa9, 0x95, 0x17, 0x31,
				0xc1, 0xd4, 0x32, 0xc5,
				0x2c, 0x4a, 0xac, 0x1f,
				0x1a, 0xbb, 0xa8, 0xef,
			]) {
				panic! ("{}", String::from_utf8 (resp.to_vec ()).unwrap ());
			}
		});
	}
}