mod client;
mod publish;
mod server;
mod web;

use client::*;
use publish::*;
use server::*;
use web::*;

use clap::{Parser, Subcommand};
use std::path::PathBuf;
use std::time::Duration;
use url::Url;

#[derive(Parser, Clone)]
#[command(version = env!("VERSION"))]
pub struct Cli {
	#[command(flatten)]
	log: moq_native::Log,

	/// Iroh configuration
	#[command(flatten)]
	#[cfg(feature = "iroh")]
	iroh: moq_native::IrohEndpointConfig,

	/// Print import statistics to stderr at the given interval.
	#[arg(long, default_missing_value = "1", num_args = 0..=1, require_equals = true, value_name = "SECS")]
	stats: Option<f64>,

	#[command(subcommand)]
	command: Command,
}

#[derive(Subcommand, Clone)]
pub enum Command {
	Serve {
		#[command(flatten)]
		config: moq_native::ServerConfig,

		/// The name of the broadcast to serve.
		#[arg(long)]
		name: String,

		/// Optionally serve static files from the given directory.
		#[arg(long)]
		dir: Option<PathBuf>,

		/// The format of the input media.
		#[command(subcommand)]
		format: PublishFormat,
	},
	Publish {
		/// The MoQ client configuration.
		#[command(flatten)]
		config: moq_native::ClientConfig,

		/// The URL of the MoQ server.
		///
		/// The URL must start with `https://` or `http://`.
		/// - If `http` is used, a HTTP fetch to "/certificate.sha256" is first made to get the TLS certificiate fingerprint (insecure).
		/// - If `https` is used, then A WebTransport connection is made via QUIC to the provided host/port.
		///
		/// The `?jwt=` query parameter is used to provide a JWT token from moq-token-cli.
		/// Otherwise, the public path (if any) is used instead.
		///
		/// The path currently must be `/` or you'll get an error on connect.
		#[arg(long)]
		url: Url,

		/// The name of the broadcast to publish.
		#[arg(long)]
		name: String,

		/// The format of the input media.
		#[command(subcommand)]
		format: PublishFormat,
	},
}

#[tokio::main]
async fn main() -> anyhow::Result<()> {
	// TODO: It would be nice to remove this and rely on feature flags only.
	// However, some dependency is pulling in `ring` and I don't know why, so meh for now.
	rustls::crypto::aws_lc_rs::default_provider()
		.install_default()
		.expect("failed to install default crypto provider");

	let cli = Cli::parse();
	cli.log.init();

	let publish = Publish::new(match &cli.command {
		Command::Serve { format, .. } => format,
		Command::Publish { format, .. } => format,
	})?;

	let stats_interval = cli
		.stats
		.map(|secs| {
			anyhow::ensure!(
				secs.is_finite() && secs > 0.0,
				"--stats interval must be a positive number"
			);
			Ok(Duration::from_secs_f64(secs))
		})
		.transpose()?;

	#[cfg(feature = "iroh")]
	let iroh = cli.iroh.bind().await?;

	match cli.command {
		Command::Serve { config, dir, name, .. } => {
			let web_bind = config.bind.unwrap_or("[::]:443".parse().unwrap());

			let server = config.init()?;
			#[cfg(feature = "iroh")]
			let server = server.with_iroh(iroh);

			let web_tls = server.tls_info();

			tokio::select! {
				res = run_server(server, name, publish.consume()) => res,
				res = run_web(web_bind, web_tls, dir) => res,
				res = publish.run(stats_interval) => res,
			}
		}
		Command::Publish { config, url, name, .. } => {
			let client = config.init()?;

			#[cfg(feature = "iroh")]
			let client = client.with_iroh(iroh);

			run_client(client, url, name, publish, stats_interval).await
		}
	}
}
