#![allow(unused_must_use)]
#[macro_use]
extern crate rocket;

#[macro_use]
extern crate serde_with;

pub mod empty;
pub mod garbage;
pub mod get_ip;
pub mod haversine;
pub mod serialized_ip_info;
pub mod util;

use std::error::Error;

use clap::{arg, Command, value_parser};
use rocket::fs::FileServer;

use empty::*;
use garbage::*;
use get_ip::*;
use util::Config;

#[rocket::main]
async fn main() -> Result<(), Box<dyn Error>> {

    let args = Command::new("speedtest-rs")
        .version("1.0.0")
        .author("Emmanuel Garette <egarette@silique.fr>")
        .about("Alternative implemention of the Librespeed server API")
        .arg(arg!(-i --ip <VALUE>).default_value("127.0.0.1"))
        .arg(arg!(-p --port <VALUE>).value_parser(value_parser!(u16)).default_value("8000"))
        .arg(arg!(-a --assets <VALUE>).default_value("assets"))
        .arg(arg!(-t --ipinfo_token <VALUE>).default_value(""))
        .arg(arg!(-l --latitude <VALUE>).value_parser(value_parser!(f64)).default_value("0.0"))
        .arg(arg!(-o --longitude <VALUE>).value_parser(value_parser!(f64)).default_value("0.0"))
        .arg(arg!(--cert <VALUE>).default_value(""))
        .arg(arg!(--key <VALUE>).default_value(""))
        .arg(arg!(--ca_cert <VALUE>).default_value(""))
        .get_matches();

    let routes = routes![get_ip::get_ip, get_backend_ip_php];

    let garbage_routes = routes![
        garbage::garbage,
        garbage_php,
        backend_garbage,
        backend_garbage_php
    ];

    let empty_routes = routes![
        empty::empty,
        backend_empty,
        get_empty,
        empty_php,
        backend_empty_php,
        get_backend_empty_php
    ];

    let routes = vec![routes, garbage_routes, empty_routes].concat();
    let config = Config {
        ip: args.get_one::<String>("ip").expect("required").to_string(),
        port: *args.get_one::<u16>("port").expect("required"),
        assets: args.get_one::<String>("assets").expect("required").to_string(),
        ipinfo_token: args.get_one::<String>("ipinfo_token").expect("required").to_string(),
        latitude: *args.get_one::<f64>("latitude").expect("required"),
        longitude: *args.get_one::<f64>("longitude").expect("required"),
        tls_cert: args.get_one::<String>("cert").expect("required").to_string(),
        tls_key: args.get_one::<String>("key").expect("required").to_string(),
        tls_ca_cert: args.get_one::<String>("ca_cert").expect("required").to_string(),
    };
    let mut figment = rocket::Config::figment()
        .merge(("address", &config.ip))
        .merge(("port", &config.port));
    if !config.tls_cert.is_empty() && !config.tls_key.is_empty() {
        figment = figment.merge(("tls.certs", &config.tls_cert))
                         .merge(("tls.key", &config.tls_key));
    }
    if !config.tls_ca_cert.is_empty() {
        figment = figment.merge(("tls.mutual.ca_certs", &config.tls_ca_cert))
                         .merge(("tls.mutual.mandatory", true));
    }
    let asset_path = std::env::current_dir().unwrap().join(args.get_one::<String>("assets").expect("required"));
    rocket::custom(figment).mount("/", routes)
        .manage(config)
        .mount("/", FileServer::from(asset_path))
        .launch().await?;

    Ok(())
}