// use std::convert::Infallible;
// use std::collections::HashMap;
use warp::{
  // http::{StatusCode},
  http::{method::Method, HeaderMap, HeaderValue},
  Reply, Rejection,
};
use reqenv::ReqEnv;
// use app_env::profile::Profile;
// use app_env::config::Config;
use kloud::{
  defs::{
		KloudQueryConfigFilters,
	},
};
use clds::clouds::defs::{Cloud};
use crate::defs::{DataDBs}; // ,CollsData};
use clds::clouds::on_clouds::{on_cloud_req,on_cloud_name_req};

pub async fn cloud_req(reqname: &str,cloud: &Cloud,reqenv: &ReqEnv,opts: &KloudQueryConfigFilters) -> String {
	let result: String;
  if opts.grp.is_empty() {
		result = on_cloud_req(&reqname,&cloud,&reqenv,&opts.tsksrvcs,&opts.srvrs,&opts.cld).await;
	} else if opts.name.is_empty() {
		let source = format!("{}/{}",&opts.cld,&opts.grp);
		result = on_cloud_name_req(&reqname,&cloud,&reqenv,&opts.tsksrvcs,&opts.srvrs,&source).await;
	} else {
		let source = format!("{}/{}/{}",&opts.cld,&opts.grp,&opts.name);
		result = on_cloud_name_req(&reqname,&cloud,&reqenv,&opts.tsksrvcs,&opts.srvrs,&source).await;
	}  
	match reqname { 
		"config" => {
			result.to_owned()
		},
		"status" => {
			result.to_owned()
		},
		"provision" => {
			result.to_owned()
		},
		"liveness" => {
			result.to_owned()
		},
		_ => {
			result.to_owned()
		}
	}
}
pub async fn config (
	opts: KloudQueryConfigFilters,
	header: HeaderMap<HeaderValue>,
	method: Method,
//  user: UserCtx, 
	db: DataDBs, 
	cloud: Cloud,
	prfx: String,
//  path: warp::path::FullPath, headers: warp::http::HeaderMap
) -> Result<impl Reply, Rejection> {
  //  dbg!("{:#?}",&db);
  // dbg!("{:#?}",&header);
  // dbg!("{:#?}",&opts);
	let reqenv = ReqEnv::new(db.app, db.auth, header, method, "/config", "config", &prfx);
  // get_pkgs_vers(&mut cloud).await?;

  // cloud.env.listhosts = String::from(listhosts);
	// if let Some(lang_str) = header.get("accept-language") {
	//   println!("{:?}",&lang_str);
	// }
//  println!("User: {} | {}",&user.user_id,&user.token);

	// println!("LANG: {}",language);
	// if prfx.as_str()  == "ta" {
	//   let cur = db.colls.ta.entries.read();
	// }
	// let allow_origin = reqenv.websrvr().allow_origin;
	// let result = cloud_req("config",&cloud,&reqenv,&opts).await;
	// println!("Result: {}",&result);
	// return Ok(warp::http::Response::builder()
	// .body(result.to_string())
	// .into_response())
	// ;
	match reqenv.user_authentication().await {
		Ok(_auth) => {
			// dbg!("auth: {}",&auth);
			match prfx.as_str() {
				"kloud" => {
					let result = cloud_req("config",&cloud,&reqenv,&opts).await;
					// println!("Result: {}",&result);
					Ok(warp::http::Response::builder()
					.body(result.to_string())
					.into_response())
				},
				"ta" => {
/*           let data = CollsData::get_ta_entries(db.colls.clone()).await; 
						let data_out: Vec<TopographicAnatomy> = data.iter().enumerate().filter(|(idx,(itm,_))|{
						let mut skip = false;
						if !opts.id.is_empty() && !itm.contains(&opts.id) { skip = true; }
						if opts.start > 0 && idx < &(opts.start as usize) { skip = true; }
						if opts.end > 0 && idx > &(opts.end as usize) { skip = true; }
						!skip
					}).map(|(_,(_,value))| value).cloned().collect();
*/
					let data_out: Vec<String> = Vec::new();
					let result = serde_json::to_string(&data_out).unwrap_or_else(|_| String::from(""));
					Ok(warp::http::Response::builder()
					.body(result.to_string())
					.into_response())
					/*
					Ok(warp::reply::with_header(
							// warp::reply::json(&CollsData::get_ta_entries(db.colls.clone()).await),
							warp::http::Response::new(result),
						//  warp::http::Response::new(body),
								"Access-Control-Allow-Origin",
							&allow_origin))
						// Ok(warp::reply::json(&result))
					*/
					},
				"tp" => { 
					// let result = CollsData::get_tp_entries(db.colls.clone()).await;
/*            let data = CollsData::get_tp_entries(db.colls.clone()).await; 
						let data_out: Vec<TrackingPoint> = data.iter().enumerate().filter(|(idx,(itm,_))|{
						let mut skip = false;
						if !opts.id.is_empty() && !itm.contains(&opts.id) { skip = true; }
						if opts.start > 0 && idx < &(opts.start as usize) { skip = true; }
						if opts.end > 0 && idx > &(opts.end as usize) { skip = true; }
						!skip
					}).map(|(_,(_,value))| value).cloned().collect();
*/
					let data_out: Vec<String> = Vec::new();
					let result = serde_json::to_string(&data_out).unwrap_or_else(|_| String::from(""));
					Ok(warp::http::Response::builder()
					.body(result.to_string())
					.into_response())
					/*
					Ok(warp::reply::with_header(
							// warp::reply::json(&CollsData::get_tp_entries(db.colls.clone()).await),
							warp::http::Response::new(result),
						//  warp::http::Response::new(body),
								"Access-Control-Allow-Origin",
								&allow_origin))
						// Ok(warp::reply::json(&result))
					*/
					},
				_ => {
					//let result="";
					let result = format!("list for '{}' undefined",&prfx);
					// (AuthError::UserNotFoundError.to_string())
					println!("{}",&result);
					Ok(warp::http::Response::builder()
					.body(result.to_string())
					.into_response())
					/*
					Ok(warp::reply::with_header(
						// warp::reply::json(&""),
						warp::http::Response::new(result),
				//  warp::http::Response::new(body),
						"Access-Control-Allow-Origin",
						&allow_origin))
					*/
					},
			}
		},
		Err(e) => {
			let result = format!("Error: no credentials found");
			println!("{}",e);
			Ok(warp::http::Response::builder()
			.body(result.to_string())
			.into_response())
			/*
			Ok(warp::reply::with_header(
				// warp::reply::json(&""),
				warp::http::Response::new(result),
				"Access-Control-Allow-Origin",
				&allow_origin))
			*/
		},
	}
}
pub async fn provision (
	opts: KloudQueryConfigFilters,
	header: HeaderMap<HeaderValue>,
	method: Method,
//  user: UserCtx, 
	db: DataDBs, 
	cloud: Cloud,
	prfx: String,
//  path: warp::path::FullPath, headers: warp::http::HeaderMap
) -> Result<impl Reply, Rejection> {
//  dbg!("{:#?}",&db);
//  dbg!("{:#?}",&header);
//  dbg!("{:#?}",&opts);
	let reqenv = ReqEnv::new(db.app, db.auth, header, method, "/provision", "provision", &prfx);
	// if let Some(lang_str) = header.get("accept-language") {
	//   println!("{:?}",&lang_str);
	// }
//  println!("User: {} | {}",&user.user_id,&user.token);

	// println!("LANG: {}",language);
	// if prfx.as_str()  == "ta" {
	//   let cur = db.colls.ta.entries.read();
	// }
	// let allow_origin = reqenv.websrvr().allow_origin;
// 	let test = true;
// if test == true {
	let result = cloud_req("provision",&cloud,&reqenv,&opts).await;
					println!("Result: {}",&result);
// return					Ok(warp::http::Response::builder()
// 					.body(result.to_string())
// 					.into_response());
// } else {
	match reqenv.user_authentication().await {
		Ok(_auth) => {
			// dbg!("auth: {}",&auth);
			match prfx.as_str() {
				"kloud" => {
					let result = cloud_req("provision",&cloud,&reqenv,&opts).await;
					println!("Result: {}",&result);
					Ok(warp::http::Response::builder()
					.body(result.to_string())
					.into_response())
				},
				"ta" => {
/*           let data = CollsData::get_ta_entries(db.colls.clone()).await; 
						let data_out: Vec<TopographicAnatomy> = data.iter().enumerate().filter(|(idx,(itm,_))|{
						let mut skip = false;
						if !opts.id.is_empty() && !itm.contains(&opts.id) { skip = true; }
						if opts.start > 0 && idx < &(opts.start as usize) { skip = true; }
						if opts.end > 0 && idx > &(opts.end as usize) { skip = true; }
						!skip
					}).map(|(_,(_,value))| value).cloned().collect();
*/
					let data_out: Vec<String> = Vec::new();
					let result = serde_json::to_string(&data_out).unwrap_or_else(|_| String::from(""));
					Ok(warp::http::Response::builder()
					.body(result.to_string())
					.into_response())
					/*
					Ok(warp::reply::with_header(
							// warp::reply::json(&CollsData::get_ta_entries(db.colls.clone()).await),
							warp::http::Response::new(result),
						//  warp::http::Response::new(body),
								"Access-Control-Allow-Origin",
							&allow_origin))
						// Ok(warp::reply::json(&result))
					*/
					},
				"tp" => { 
					// let result = CollsData::get_tp_entries(db.colls.clone()).await;
/*            let data = CollsData::get_tp_entries(db.colls.clone()).await; 
						let data_out: Vec<TrackingPoint> = data.iter().enumerate().filter(|(idx,(itm,_))|{
						let mut skip = false;
						if !opts.id.is_empty() && !itm.contains(&opts.id) { skip = true; }
						if opts.start > 0 && idx < &(opts.start as usize) { skip = true; }
						if opts.end > 0 && idx > &(opts.end as usize) { skip = true; }
						!skip
					}).map(|(_,(_,value))| value).cloned().collect();
*/
					let data_out: Vec<String> = Vec::new();
					let result = serde_json::to_string(&data_out).unwrap_or_else(|_| String::from(""));
					Ok(warp::http::Response::builder()
					.body(result.to_string())
					.into_response())
					/*
					Ok(warp::reply::with_header(
							// warp::reply::json(&CollsData::get_tp_entries(db.colls.clone()).await),
							warp::http::Response::new(result),
						//  warp::http::Response::new(body),
								"Access-Control-Allow-Origin",
								&allow_origin))
						// Ok(warp::reply::json(&result))
					*/
					},
				_ => {
					//let result="";
					let result = format!("list for '{}' undefined",&prfx);
					// (AuthError::UserNotFoundError.to_string())
					println!("{}",&result);
					Ok(warp::http::Response::builder()
					.body(result.to_string())
					.into_response())
					/*
					Ok(warp::reply::with_header(
						// warp::reply::json(&""),
						warp::http::Response::new(result),
				//  warp::http::Response::new(body),
						"Access-Control-Allow-Origin",
						&allow_origin))
					*/
					},
			}
		},
		Err(e) => {
			let result = format!("Error: no credentials found");
			println!("{}",e);
			Ok(warp::http::Response::builder()
			.body(result.to_string())
			.into_response())
			/*
			Ok(warp::reply::with_header(
				// warp::reply::json(&""),
				warp::http::Response::new(result),
				"Access-Control-Allow-Origin",
				&allow_origin))
			*/
		},
	}
	// }
}
pub async fn status (
	opts: KloudQueryConfigFilters,
	header: HeaderMap<HeaderValue>,
	method: Method,
//  user: UserCtx, 
	db: DataDBs, 
	cloud: Cloud,
	prfx: String,
//  path: warp::path::FullPath, headers: warp::http::HeaderMap
) -> Result<impl Reply, Rejection> {
//  dbg!("{:#?}",&db);
//  dbg!("{:#?}",&header);
//  dbg!("{:#?}",&opts);
	let reqenv = ReqEnv::new(db.app, db.auth, header, method, "/status", "status", &prfx);
	// if let Some(lang_str) = header.get("accept-language") {
	//   println!("{:?}",&lang_str);
	// }
//  println!("User: {} | {}",&user.user_id,&user.token);

	// println!("LANG: {}",language);
	// if prfx.as_str()  == "ta" {
	//   let cur = db.colls.ta.entries.read();
	// }
	// let allow_origin = reqenv.websrvr().allow_origin;
//	let result = cloud_req("status",&cloud,&reqenv,&opts).await;
// 					println!("Result: {}",&result);
// return					Ok(warp::http::Response::builder()
//					.body(result.to_string())
//					.into_response());
	match reqenv.user_authentication().await {
		Ok(_auth) => {
			// dbg!("auth: {}",&auth);
			match prfx.as_str() {
				"kloud" => {
					let result = cloud_req("status",&cloud,&reqenv,&opts).await;
					println!("Result: {}",&result);
					Ok(warp::http::Response::builder()
					.body(result.to_string())
					.into_response())
				},
				"ta" => {
/*           let data = CollsData::get_ta_entries(db.colls.clone()).await; 
						let data_out: Vec<TopographicAnatomy> = data.iter().enumerate().filter(|(idx,(itm,_))|{
						let mut skip = false;
						if !opts.id.is_empty() && !itm.contains(&opts.id) { skip = true; }
						if opts.start > 0 && idx < &(opts.start as usize) { skip = true; }
						if opts.end > 0 && idx > &(opts.end as usize) { skip = true; }
						!skip
					}).map(|(_,(_,value))| value).cloned().collect();
*/
					let data_out: Vec<String> = Vec::new();
					let result = serde_json::to_string(&data_out).unwrap_or_else(|_| String::from(""));
					Ok(warp::http::Response::builder()
					.body(result.to_string())
					.into_response())
					/*
					Ok(warp::reply::with_header(
							// warp::reply::json(&CollsData::get_ta_entries(db.colls.clone()).await),
							warp::http::Response::new(result),
						//  warp::http::Response::new(body),
								"Access-Control-Allow-Origin",
							&allow_origin))
						// Ok(warp::reply::json(&result))
					*/
					},
				"tp" => { 
					// let result = CollsData::get_tp_entries(db.colls.clone()).await;
/*            let data = CollsData::get_tp_entries(db.colls.clone()).await; 
						let data_out: Vec<TrackingPoint> = data.iter().enumerate().filter(|(idx,(itm,_))|{
						let mut skip = false;
						if !opts.id.is_empty() && !itm.contains(&opts.id) { skip = true; }
						if opts.start > 0 && idx < &(opts.start as usize) { skip = true; }
						if opts.end > 0 && idx > &(opts.end as usize) { skip = true; }
						!skip
					}).map(|(_,(_,value))| value).cloned().collect();
*/
					let data_out: Vec<String> = Vec::new();
					let result = serde_json::to_string(&data_out).unwrap_or_else(|_| String::from(""));
					Ok(warp::http::Response::builder()
					.body(result.to_string())
					.into_response())
					/*
					Ok(warp::reply::with_header(
							// warp::reply::json(&CollsData::get_tp_entries(db.colls.clone()).await),
							warp::http::Response::new(result),
						//  warp::http::Response::new(body),
								"Access-Control-Allow-Origin",
								&allow_origin))
						// Ok(warp::reply::json(&result))
					*/
					},
				_ => {
					//let result="";
					let result = format!("list for '{}' undefined",&prfx);
					// (AuthError::UserNotFoundError.to_string())
					println!("{}",&result);
					Ok(warp::http::Response::builder()
					.body(result.to_string())
					.into_response())
					/*
					Ok(warp::reply::with_header(
						// warp::reply::json(&""),
						warp::http::Response::new(result),
				//  warp::http::Response::new(body),
						"Access-Control-Allow-Origin",
						&allow_origin))
					*/
					},
			}
		},
		Err(e) => {
			let result = format!("Error: no credentials found");
			println!("{}",e);
			Ok(warp::http::Response::builder()
			.body(result.to_string())
			.into_response())
			/*
			Ok(warp::reply::with_header(
				// warp::reply::json(&""),
				warp::http::Response::new(result),
				"Access-Control-Allow-Origin",
				&allow_origin))
			*/
		},
	}
}
pub async fn liveness (
	opts: KloudQueryConfigFilters,
	header: HeaderMap<HeaderValue>,
	method: Method,
//  user: UserCtx, 
	db: DataDBs, 
	cloud: Cloud,
	prfx: String,
//  path: warp::path::FullPath, headers: warp::http::HeaderMap
) -> Result<impl Reply, Rejection> {
//  dbg!("{:#?}",&db);
//  dbg!("{:#?}",&header);
//  dbg!("{:#?}",&opts);
	let reqenv = ReqEnv::new(db.app, db.auth, header, method, "/liveness", "liveness", &prfx);
	// if let Some(lang_str) = header.get("accept-language") {
	//   println!("{:?}",&lang_str);
	// }
//  println!("User: {} | {}",&user.user_id,&user.token);

	// println!("LANG: {}",language);
	// if prfx.as_str()  == "ta" {
	//   let cur = db.colls.ta.entries.read();
	// }
	// let allow_origin = reqenv.websrvr().allow_origin;
// let test = true;
// if test == true {
// 	let result = cloud_req("liveness",&cloud,&reqenv,&opts).await;
// 					println!("Result: {}",&result);
// return					Ok(warp::http::Response::builder()
// 					.body(result.to_string())
// 					.into_response());
// } else {
	match reqenv.user_authentication().await {
		Ok(_auth) => {
			// dbg!("auth: {}",&auth);
			match prfx.as_str() {
				"kloud" => {
					let result = cloud_req("liveness",&cloud,&reqenv,&opts).await;
					println!("Result: {}",&result);
					Ok(warp::http::Response::builder()
					.body(result.to_string())
					.into_response())
				},
				"ta" => {
/*           let data = CollsData::get_ta_entries(db.colls.clone()).await; 
						let data_out: Vec<TopographicAnatomy> = data.iter().enumerate().filter(|(idx,(itm,_))|{
						let mut skip = false;
						if !opts.id.is_empty() && !itm.contains(&opts.id) { skip = true; }
						if opts.start > 0 && idx < &(opts.start as usize) { skip = true; }
						if opts.end > 0 && idx > &(opts.end as usize) { skip = true; }
						!skip
					}).map(|(_,(_,value))| value).cloned().collect();
*/
					let data_out: Vec<String> = Vec::new();
					let result = serde_json::to_string(&data_out).unwrap_or_else(|_| String::from(""));
					Ok(warp::http::Response::builder()
					.body(result.to_string())
					.into_response())
					/*
					Ok(warp::reply::with_header(
							// warp::reply::json(&CollsData::get_ta_entries(db.colls.clone()).await),
							warp::http::Response::new(result),
						//  warp::http::Response::new(body),
								"Access-Control-Allow-Origin",
							&allow_origin))
						// Ok(warp::reply::json(&result))
					*/
					},
				"tp" => { 
					// let result = CollsData::get_tp_entries(db.colls.clone()).await;
/*            let data = CollsData::get_tp_entries(db.colls.clone()).await; 
						let data_out: Vec<TrackingPoint> = data.iter().enumerate().filter(|(idx,(itm,_))|{
						let mut skip = false;
						if !opts.id.is_empty() && !itm.contains(&opts.id) { skip = true; }
						if opts.start > 0 && idx < &(opts.start as usize) { skip = true; }
						if opts.end > 0 && idx > &(opts.end as usize) { skip = true; }
						!skip
					}).map(|(_,(_,value))| value).cloned().collect();
*/
					let data_out: Vec<String> = Vec::new();
					let result = serde_json::to_string(&data_out).unwrap_or_else(|_| String::from(""));
					Ok(warp::http::Response::builder()
					.body(result.to_string())
					.into_response())
					/*
					Ok(warp::reply::with_header(
							// warp::reply::json(&CollsData::get_tp_entries(db.colls.clone()).await),
							warp::http::Response::new(result),
						//  warp::http::Response::new(body),
								"Access-Control-Allow-Origin",
								&allow_origin))
						// Ok(warp::reply::json(&result))
					*/
					},
				_ => {
					//let result="";
					let result = format!("list for '{}' undefined",&prfx);
					// (AuthError::UserNotFoundError.to_string())
					println!("{}",&result);
					Ok(warp::http::Response::builder()
					.body(result.to_string())
					.into_response())
					/*
					Ok(warp::reply::with_header(
						// warp::reply::json(&""),
						warp::http::Response::new(result),
				//  warp::http::Response::new(body),
						"Access-Control-Allow-Origin",
						&allow_origin))
					*/
					},
			}
		},
		Err(e) => {
			let result = format!("Error: no credentials found");
			println!("{}",e);
			Ok(warp::http::Response::builder()
			.body(result.to_string())
			.into_response())
			/*
			Ok(warp::reply::with_header(
				// warp::reply::json(&""),
				warp::http::Response::new(result),
				"Access-Control-Allow-Origin",
				&allow_origin))
			*/
		},
	}
	// }
}