use serde::{Serialize, Deserialize};
use std::collections::{HashMap, BTreeMap};
use app_env::{appenv::AppEnv, AppStore};
use app_auth::{AuthStore};
use kloud::{defs::KloudStore, datacontext::DataContext};
use kloud::utils::load_from_module;

use std::sync::Arc;
use tokio::sync::Mutex;
use connectors::defs::{AppDataConn}; 

use clds::clouds::defs::{
	CloudEnv,
	Cloud,
  SrvcsHostInfOut,
	InfoStatus,
};
use kloud::kloud::Kloud;

#[derive(Clone,Default)]
pub struct CollsData {
  pub klouds: KloudStore<Kloud>,
}

impl CollsData {
  pub fn new(env: AppEnv,verbose: isize) -> Self {
    //  dbg!(&env.contexts);
    let (klouds_frmt, klouds_content) = load_from_module(env.to_owned(),"klouds");
    Self {
      klouds: KloudStore::new(
        Kloud::entries(&klouds_content,&klouds_frmt),
        "klouds".to_owned(),
        DataContext::default(),
				verbose
      ),
    }
  }
  pub async fn get_klouds_entries(coll_map: CollsData) -> BTreeMap<String,Kloud> {
    let mut result = BTreeMap::new(); 
    let cur = coll_map.klouds.entries.read();
    for (key,value) in cur.iter() {
      result.insert(key.to_owned(), value.to_owned());
    }
    result
  }
}

#[derive(Clone)]
pub struct AppDBs {
  pub colls: CollsData,
  pub app: AppStore,
}

#[derive(Clone)]
pub struct DataDBs {
  pub colls: CollsData,
  pub app: AppStore,
  pub auth: AuthStore,
	pub conns: Arc<Mutex<AppDataConn>>,
}

pub async fn load_cloud_env(cloud: &mut Cloud) {
	let force: u8 = "-f".as_bytes()[0];
  cloud.env = CloudEnv::new(force,load_key().await);
  cloud.providers = Cloud::load_providers().await;
}

pub const KEY_PATH: &str = ".k";
use key_of_life::get_key;

pub async fn load_key() -> String {
  let key_path = envmnt::get_or("KEY_PATH", KEY_PATH);
  let key = get_key(&key_path,None).await;
  if key.is_empty() {
    std::process::exit(0x0100);
  }
  key
}
pub type MapCheckInfo =	BTreeMap<String,Vec<SrvcsHostInfOut>>;

#[derive(Clone, Debug, Serialize,  Deserialize, Default)]
pub struct KldCheck {
	pub name: String,
	pub liveness: HashMap<String, MapCheckInfo>,
	pub apps: HashMap<String, MapCheckInfo>,
	pub infos: Vec<InfoStatus>,
}