use comunic_server::{cleanup_thread, server};
use comunic_server::data::config::{conf, Config};
use comunic_server::helpers::database;
use comunic_server::utils::date_utils::current_year;

type MainActionFunction = std::io::Result<()>;

struct Action {
    name: String,
    description: String,
    arguments: Vec<String>,
    function: Box<dyn Fn() -> MainActionFunction>,
}

fn get_actions() -> Vec<Action> {
    vec![
        // Start server
        Action {
            name: "serve".to_string(),
            description: "Start the Comunic Server (default action)".to_string(),
            arguments: vec![],
            function: Box::new(serve),
        },

        // Show help
        Action {
            name: "help".to_string(),
            description: "Show this help".to_string(),
            arguments: vec![],
            function: Box::new(help),
        }
    ]
}

#[actix_rt::main]
async fn main() -> std::io::Result<()> {
    let args: Vec<String> = std::env::args().collect();
    let conf_file = match args.get(1) {
        Some(el) => el.to_string(),
        None => "config.yaml".to_string(),
    };

    // Load configuration
    Config::load(&conf_file).expect("Could not load configuration!");

    // Connect to the database
    database::connect(&conf().database).expect("Could not connect to database!");

    // Get selected action
    let action = args
        .get(2)
        .map(|a| a.as_str())
        .unwrap_or("serve")
        .to_string();

    let actions = get_actions();

    let selected_action = actions
        .iter()
        .filter(|p| p.name.eq(&action))
        .next();

    let selected_action = match selected_action {
        None => {
            eprintln!("Action {} invalid! For more information try 'help'!", action);
            std::process::exit(-1);
        }
        Some(a) => a
    };

    if !selected_action.arguments.is_empty() && selected_action.arguments.len() + 2 > args.len() {
        eprintln!("Invalid number of arguments!");
        std::process::exit(-2);
    }

    (selected_action.function)()?;
    Ok(())
}

/// Start Comunic Server (main action)
fn serve() -> std::io::Result<()> {
    let t = std::thread::spawn(|| {
        let sys = actix::System::new("sys");

        let promise = async {
            // Start cleanup thread
            cleanup_thread::start().expect("Failed to start cleanup thread!");

            // Start the server
            server::start_server(conf()).await
        };

        tokio::runtime::Runtime::new().unwrap().block_on(promise)
            .expect("Failed to start server!");

        let _ = sys.run();
    });

    t.join().unwrap();
    Ok(())
}

fn help() -> std::io::Result<()> {
    println!("Comunic API v3 Server - (c) Pierre HUBERT 2012 - {}", current_year());

    println!("Available actions:");
    for action in get_actions() {
        println!("\t{}\t{} - {}",
                 action.name,
                 action.arguments.iter().map(|s| format!("[{}]", s)).collect::<Vec<String>>().join(" "),
                 action.description
        );
    }

    Ok(())
}