#[macro_use]
extern crate anyhow;

use futures::TryFutureExt;
use std::net::SocketAddr;
use structopt::StructOpt;

mod cert;
mod cert_store;
mod consul;
mod http;
mod https;
mod proxy_config;
mod reverse_proxy;
mod tls_util;

use log::*;

#[derive(StructOpt, Debug)]
#[structopt(name = "tricot")]
struct Opt {
	/// Address of consul server
	#[structopt(
		long = "consul-addr",
		env = "TRICOT_CONSUL_HOST",
		default_value = "http://127.0.0.1:8500"
	)]
	pub consul_addr: String,

	/// Prefix of Tricot's entries in Consul KV space
	#[structopt(
		long = "consul-kv-prefix",
		env = "TRICOT_CONSUL_KV_PREFIX",
		default_value = "tricot/"
	)]
	pub consul_kv_prefix: String,

	/// Node name
	#[structopt(long = "node-name", env = "TRICOT_NODE_NAME", default_value = "<none>")]
	pub node_name: String,

	/// Bind address for HTTP server
	#[structopt(
		long = "http-bind-addr",
		env = "TRICOT_HTTP_BIND_ADDR",
		default_value = "0.0.0.0:80"
	)]
	pub http_bind_addr: SocketAddr,

	/// Bind address for HTTPS server
	#[structopt(
		long = "https-bind-addr",
		env = "TRICOT_HTTPS_BIND_ADDR",
		default_value = "0.0.0.0:443"
	)]
	pub https_bind_addr: SocketAddr,

	/// E-mail address for Let's Encrypt certificate requests
	#[structopt(long = "letsencrypt-email", env = "TRICOT_LETSENCRYPT_EMAIL")]
	pub letsencrypt_email: String,
}

#[tokio::main(flavor = "multi_thread", worker_threads = 10)]
async fn main() {
	if std::env::var("RUST_LOG").is_err() {
		std::env::set_var("RUST_LOG", "tricot=info")
	}
	pretty_env_logger::init();

	// Abort on panic (same behavior as in Go)
	std::panic::set_hook(Box::new(|panic_info| {
		error!("{}", panic_info.to_string());
		std::process::abort();
	}));

	let opt = Opt::from_args();

	info!("Starting Tricot");

	let consul = consul::Consul::new(&opt.consul_addr, &opt.consul_kv_prefix, &opt.node_name);
	let mut rx_proxy_config = proxy_config::spawn_proxy_config_task(consul.clone());

	let cert_store = cert_store::CertStore::new(
		consul.clone(),
		rx_proxy_config.clone(),
		opt.letsencrypt_email.clone(),
	);

	tokio::spawn(http::serve_http(opt.http_bind_addr, consul.clone()).map_err(exit_on_err));
	tokio::spawn(
		https::serve_https(
			opt.https_bind_addr,
			cert_store.clone(),
			rx_proxy_config.clone(),
		)
		.map_err(exit_on_err),
	);

	while rx_proxy_config.changed().await.is_ok() {
		info!("Proxy config:");
		for ent in rx_proxy_config.borrow().entries.iter() {
			info!("   {}", ent);
		}
	}
}

fn exit_on_err(e: anyhow::Error) {
	error!("{}", e);
	std::process::exit(1);
}