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

use clds::clouds::defs::{
	CloudEnv,
	Cloud,
};
use librecloud_kloud::Kloud;
//use topographic_anatomy::TopographicAnatomy;
//use tracking_point::TrackingPoint;

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

impl CollsData {
  pub fn new(env: AppEnv) -> Self {
    //  dbg!(&env.contexts);
    let (klouds_frmt, klouds_content) = load_from_module(env.to_owned(),"klouds");
    // let (ta_frmt, ta_content) = load_from_module(env.to_owned(),"ta");
    // let (tp_frmt, tp_content) = load_from_module(env.to_owned(),"tp");
    Self {
      klouds: KloudStore::new(
        Kloud::entries(&klouds_content,&klouds_frmt),
        "klouds".to_owned(),
        DataContext::default()
      ),
/*
      ta: KloudStore::new(
        TopographicAnatomy::entries(&ta_content,&ta_frmt),
        "ta".to_owned(),
        DataContext::default()
      ),
      tp: KloudStore::new(
        TrackingPoint::entries(&tp_content,&tp_frmt),
        "tp".to_owned(), DataContext::default())
*/
    }
  }
  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
  }
/*
  pub async fn get_ta_entries(coll_map: CollsData) -> BTreeMap<String,TopographicAnatomy> {
    let mut result = BTreeMap::new(); 
    let cur = coll_map.ta.entries.read();
    for (key,value) in cur.iter() {
      result.insert(key.to_owned(), value.to_owned());
    }
    result
  }
  pub async fn get_tp_entries(coll_map: CollsData) -> BTreeMap<String,TrackingPoint> {
    let mut result = BTreeMap::new(); 
    let cur = coll_map.tp.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 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
}