use harmony::instrumentation::{self, HarmonyEvent};
use indicatif::{MultiProgress, ProgressBar};
use indicatif_log_bridge::LogWrapper;
use std::{
    collections::{HashMap, hash_map},
    sync::{Arc, Mutex},
};

pub fn init() -> tokio::task::JoinHandle<()> {
    configure_logger();
    let handle = tokio::spawn(handle_events());

    loop {
        if instrumentation::instrument(HarmonyEvent::HarmonyStarted).is_ok() {
            break;
        }
    }

    handle
}

fn configure_logger() {
    let logger =
        env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("info")).build();
    let level = logger.filter();
    let multi = MultiProgress::new();
    LogWrapper::new(multi.clone(), logger).try_init().unwrap();
    log::set_max_level(level);
}

async fn handle_events() {
    instrumentation::subscribe("Harmony CLI Logger", {
        let progresses: Arc<Mutex<HashMap<String, MultiProgress>>> =
            Arc::new(Mutex::new(HashMap::new()));
        let topology_prepare_progress = Arc::new(Mutex::new(None::<ProgressBar>));

        move |event| {
            let progresses_clone = Arc::clone(&progresses);
            let topology_prepare_progress_clone = Arc::clone(&topology_prepare_progress);

            async move {
                let mut progresses = progresses_clone.lock().unwrap();
                let mut topology_prepare_progress = topology_prepare_progress_clone.lock().unwrap();

                match event {
                    HarmonyEvent::HarmonyStarted => {}
                    HarmonyEvent::PrepareTopologyStarted { name } => {
                        let multi_progress = crate::progress::new_section(format!(
                            "{} Preparing environment: {name}...",
                            crate::theme::EMOJI_TOPOLOGY,
                        ));
                        (*progresses).insert(name, multi_progress);
                    }
                    HarmonyEvent::TopologyPrepared { name, status } => match status {
                        harmony::interpret::InterpretStatus::SUCCESS => todo!(),
                        harmony::interpret::InterpretStatus::FAILURE => todo!(),
                        harmony::interpret::InterpretStatus::RUNNING => todo!(),
                        harmony::interpret::InterpretStatus::QUEUED => todo!(),
                        harmony::interpret::InterpretStatus::BLOCKED => todo!(),
                        harmony::interpret::InterpretStatus::NOOP => todo!(),
                    },
                }
                true
            }
        }
    })
    .await;
}