use sysf::registry::{DependencyTree, Registry};
use sysf::unit::UnitState;
use std::collections::HashMap;
use sysf::config::loader::Loader;
use async_std::sync::{Arc, Mutex, MutexGuard};
use sysf::bus::{BusServer, BusClient, Request, MessageHandler, IncomingMessage};

#[derive(Clone, Debug)]
pub struct Manager {
    state: Arc<Mutex<ManagerState>>,
    bus_server: BusServer,
}

#[derive(Clone, Default, Debug)]
pub struct ManagerState {
    dependency_tree: DependencyTree,
    unit_status: HashMap<String, UnitState>,
    registry: Registry,
}

impl Manager {
    pub fn new(loader: Loader) -> Manager {
        let bus_server = BusServer::new();

        Manager {
            state: Arc::new(Mutex::new(ManagerState {
                dependency_tree: DependencyTree::default(),
                unit_status: HashMap::new(),
                registry: Registry::with_loader(loader),
            })),
            bus_server,
        }
    }

    #[allow(dead_code)]
    pub async fn with<F>(&mut self, block: F)
        where F: FnOnce(MutexGuard<ManagerState>)
    {
        block(self.state.lock().await)
    }

    pub async fn target(&mut self, _target: &str) {
        self.get_client().send(Request).await;
    }

    pub async fn run(&mut self) {
        self.bus_server.attach_process_receiver().await;
        self.bus_server.run(self.clone()).await;
    }



    async fn _update_target(&self, target: String) {
        let mut me = self.state.lock().await;
        let tree = me.registry.get_dependency_tree(&target).await;
        me.dependency_tree = tree;
    }

    fn get_client(&self) -> BusClient {
        self.bus_server.get_process_client()
    }
}

#[async_trait]
impl MessageHandler for Manager {
    async fn handle_message(&mut self, mut message: IncomingMessage, _server: BusServer) {
        message.ack().await;
    }
}