mod structs;
mod config;
mod files;
mod prcs;
mod utils;
mod services;
mod logger;

use tokio::sync::mpsc;
use std::sync::Arc;
use log::error;
use structs::*;
use config::*;
use utils::*;
use logger::setup_logger;


#[tokio::main(flavor = "multi_thread")]
async fn main() {
    let _ = setup_logger();

    log::info!("Runner is configurating...");

    // setting up redis connection \
    // then conf checks to choose the most actual \
    let processes: Processes = get_actual_config().unwrap_or_else(|| {
        error!("No actual configuration for runner. Stopping...");
        std::process::exit(101);
    });

    log::info!("Current runner configuration: {}", &processes.date_of_creation);
    log::info!("Runner is ready. Initializing...");

    if processes.processes.len() == 0 {
        error!("Processes list is null, runner-rs initialization is stopped");
        return;
    }
    let mut handler: Vec<tokio::task::JoinHandle<()>> = vec![];

    for proc in processes.processes.iter() {
        log::info!("Process '{}' on stage: {}. Depends on {} file(s), {} service(s)",
            proc.name,
            proc.path,
            proc.dependencies.files.len(),
            proc.dependencies.services.len()
        );

        // creating msg channel
        // can or should be executed in new thread
        let (tx, mut rx) = mpsc::channel::<u8>(1);

        let proc = Arc::new(proc.clone());
        let tx = Arc::new(tx.clone());
        let event = tokio::spawn(async move {
            run_daemons(proc.clone(), tx.clone(), &mut rx).await;
        });
        handler.push(event);
    }
    for i in handler {
        i.await.unwrap();
    }
    return;
}