mod config;
mod net;
mod logger;
mod json;
mod export;
mod monitoring;
mod jitter;

use anyhow::Result;
use integr_structs::api::v3::Config;
use logger::setup_logger;
use config::{pull_local_config, init_config_grub_mechanism};
use net::init_api_grub_mechanism;
use tokio::sync::mpsc;
use tracing::{error, info, warn};
// ENODE_MONITORING_IP
use monitoring::get_metrics_from_monitoring;
// VINTEO_API_KEY
use jitter::init_grubbing_jitter;

#[tokio::main(flavor = "multi_thread")]
async fn main() -> Result<()>{
    dotenv::dotenv().ok();
    setup_logger().await?;
    let config = get_config().await;
    // config update channel
    let (tx, mut rx) = mpsc::channel::<Config>(1);

    let event_config = tokio::spawn(async move {
        match init_config_grub_mechanism(&tx).await {
            Ok(_) => {
                info!("Config task deinitialized");
            },
            Err(er) => {
                error!("Config task returned an error : {}", er);
            },
        }
    });
    let event_grub = tokio::spawn(async move {
        // GRAB USING eNODE.MONITORING API GATEWAY
        if std::env::var("ENODE_MONITORING_IP").is_ok() {
            match get_metrics_from_monitoring(0, 5).await {
                Ok(_) => info!("Grabing (eNODE.Monitoring) task de-initialized"),
                Err(er) => error!("Grabing task returned an error : {}", er),
            }
        // JITTER NATIVE GRAB TASK
        } else if std::env::var("VINTEO_API_KEY").is_ok() {
            match init_grubbing_jitter().await { 
                Ok(_) => info!("Grabing (Vinteo - Jitter native) task de-initialized"),
                Err(er) => error!("Jitter grabing mechanism crushed : {}", er),
            }
        // NATIVE GRAB TASK USING `config_api.json`
        } else {
            match init_api_grub_mechanism(config, &mut rx).await {
                Ok(_) => info!("Grabing task de-initialized"),
                Err(er) => error!("Grabing task returned an error : {}", er),
            }
        }
    });
    let events_handler = vec![event_config, event_grub];
    for event in events_handler {
        let _ = event.await;
    }
    
    Ok(())
}

async fn get_config() -> Config {
    return match pull_local_config().await {
        Ok(conf) => {
            info!("Local config was loaded");
            conf
        },
        Err(er) => {
            warn!("Cannot get local config due to {}", er);
            Config::default()
        }
    }
}