use std::future::Future;

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

type MainActionFunction = Box<dyn Future<Output=std::io::Result<()>>>;

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

#[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 = vec![
         Action {
             name: "serve".to_string(),
             description: "Start the Comunic Server (default action)".to_string(),
             arguments: vec![],
             function: Box::new(serve),
         }
     ];

     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.len() != args.len() - 2 {
         eprintln!("Invalid number of arguments!");
         std::process::exit(-2);
     }

     let func =  (selected_action.function)();
     func.await*/
    serve()
}

/// 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(())
}