tengri/]

use crate::*;
/// A collection of input bind.
///
/// Each contained layer defines a mapping from input event to command invocation
/// over a given state. Furthermore, each layer may have an associated cond,
/// so that only certain layers are active at a given time depending on state.
#[derive(Debug, Default)] pub struct InputMap<I, T: Dsl>(std::collections::BTreeMap<I, T>);
impl<I, T: Dsl> InputMap<I, T> {
    /// Create input layer collection from path to text file.
    pub fn from_path <P: Debug + AsRef<Path>> (path: P) -> Usually<Self> {
        if !exists(path.as_ref())? {
            return Err(format!("(e5) not found: {path:?}").into())
        }
        Self::from_source(read_and_leak(path)?)
    }
    /// Create input layer collection from string.
    pub fn from_source <S: AsRef<str>> (source: S) -> Usually<Self> {
        Self::from_dsl(CstIter::from(source.as_ref()))
    }
    /// Create input layer collection from DSL.
    pub fn from_dsl (dsl: impl Dsl) -> Usually<Self> {
        use DslVal::*;
        let mut input_map: Self = Self(Default::default());
        while let Exp(_, mut exp) = dsl.val() {
            match exp.nth(0).map(|x|x.val()) {
                Some(Str(path)) => {
                    let path = PathBuf::from(path.as_ref());
                    let module = InputMap::<I, T>::from_path(&path)?;
                    for (key, val) in module.0.into_iter() {
                    }
                },
                Some(Exp(_, expr)) if let Some(Sym(sym)) = expr.nth(0) => {
                    //input_map.unconditional.push(expr);
                    todo!("binding");
                },
                Some(Exp(_, expr)) if expr.nth(0).map(|x|x.val()) == Some(Key("if")) => {
                    todo!("conditional binding");
                },
                _ => return Result::Err("invalid token in keymap".into()),
            }
        }
        Ok(input_map)
    }
    /// Evaluate the active layers for a given state,
    /// returning the command to be executed, if any.
    pub fn handle <S, O> (&self, state: &mut S, input: I) -> Perhaps<O> where
        S: DslInto<bool> + DslInto<O>,
        O: Command<S>
    {
        todo!();
        //let layers = self.0.as_slice();
        //for InputLayer { cond, bind } in layers.iter() {
            //let mut matches = true;
            //if let Some(cond) = cond {
                //matches = state.dsl_into(cond, ||format!("input: no cond").into())?;
            //}
            //if matches
            //&& let Some(exp) = bind.val().exp_head()
            //&& input.dsl_into(exp, ||format!("InputMap: input.eval(binding) failed").into())?
            //&& let Some(command) = state.try_dsl_into(exp)? {
                //return Ok(Some(command))
            //}
        //}
        Ok(None)
    }
    /*
    /// Create an input map with a single non-condal layer.
    /// (Use [Default::default] to get an empty map.)
    pub fn new (layer: DslVal<T::Str, T::Exp>) -> Self {
        Self::default().layer(layer)
    }
    /// Add layer, return `Self`.
    pub fn layer (mut self, layer: DslVal<T::Str, T::Exp>) -> Self {
        self.add_layer(layer); self
    }
    /// Add condal layer, return `Self`.
    pub fn layer_if (mut self, cond: DslVal<T::Str, T::Exp>, layer: DslVal<T::Str, T::Exp>) -> Self {
        self.add_layer_if(Some(cond), layer); self
    }
    /// Add layer, return `&mut Self`.
    pub fn add_layer (&mut self, layer: DslVal<T::Str, T::Exp>) -> &mut Self {
        self.add_layer_if(None, layer.into()); self
    }
    /// Add condal layer, return `&mut Self`.
    pub fn add_layer_if (&mut self, cond: Option<DslVal<T::Str, T::Exp>>, bind: DslVal<T::Str, T::Exp>) -> &mut Self {
        self.0.push(InputLayer { cond, bind });
        self
    }
    */
}



        //let mut keys = iter.unwrap();
        //let mut map  = InputMap::default();
        //while let Some(token) = keys.next() {
            //if let Value::Exp(_, mut exp) = token.value {
                //let next = exp.next();
                //if let Some(Token { value: Value::Key(sym), .. }) = next {
                    //match sym {
                        //"layer" => {
                            //if let Some(Token { value: Value::Str(path), .. }) = exp.peek() {
                                //let path = base.as_ref().parent().unwrap().join(unquote(path));
                                //if !std::fs::exists(&path)? {
                                    //return Err(format!("(e5) not found: {path:?}").into())
                                //}
                                //map.add_layer(read_and_leak(path)?.into());
                                //print!("layer:\n  path: {:?}...", exp.0.0.trim());
                                //println!("ok");
                            //} else {
                                //return Err(format!("(e4) unexpected non-string {next:?}").into())
                            //}
                        //},

                        //"layer-if" => {
                            //let mut cond = None;

                            //if let Some(Token { value: Value::Sym(sym), .. }) = exp.next() {
                                //cond = Some(leak(sym));
                            //} else {
                                //return Err(format!("(e4) unexpected non-symbol {next:?}").into())
                            //};

                            //if let Some(Token { value: Value::Str(path), .. }) = exp.peek() {
                                //let path = base.as_ref().parent().unwrap().join(unquote(path));
                                //if !std::fs::exists(&path)? {
                                    //return Err(format!("(e5) not found: {path:?}").into())
                                //}
                                //print!("layer-if:\n  cond: {}\n  path: {path:?}...",
                                    //cond.unwrap_or_default());
                                //let keys = read_and_leak(path)?.into();
                                //let cond = cond.unwrap();
                                //println!("ok");
                                //map.add_layer_if(
                                    //Box::new(move |state: &App|Take::take_or_fail(
                                        //state, exp, ||"missing input layer conditional"
                                    //)), keys
                                //);
                            //} else {
                                //return Err(format!("(e4) unexpected non-symbol {next:?}").into())
                            //}
                        //},

                        //_ => return Err(format!("(e3) unexpected symbol {sym:?}").into())
                    //}
                //} else {
                    //return Err(format!("(e2) unexpected exp {:?}", next.map(|x|x.value)).into())
                //}
            //} else {
                //return Err(format!("(e1) unexpected token {token:?}").into())
            //}
        //}
        //Ok(map)
    //}
//{
//}
    //fn from (source: &'s str) -> Self {
        //// this should be for single layer:
        //use DslVal::*;
        //let mut layers = vec![];
        //let mut source = CstIter::from(source);
        //while let Some(Exp(_, mut iter)) = source.next().map(|x|x.value) {
            //let mut iter = iter.clone();
            //layers.push(match iter.next().map(|x|x.value) {
                //Some(Sym(sym)) if sym.starts_with("@") => InputLayer {
                    //cond: None,
                    //bind: vec![[
                        //dsl_val(source.nth(1).unwrap()),
                        //dsl_val(source.nth(2).unwrap()),
                    //]],
                //},
                //Some(Str(layer)) => InputLayer {
                    //cond: None,
                    //bind: dsl_val(source.nth(1).unwrap()),
                //},
                //Some(Key("if")) => InputLayer {
                    //cond: Some(dsl_val(source.nth(1).unwrap())),
                    //bind: dsl_val(source.nth(2).unwrap()),
                //},
                //_ => panic!("invalid token in keymap"),
            //})
        //}
        //Self(layers)
    //}
//}

fn unquote (x: &str) -> &str {
    let mut chars = x.chars();
    chars.next();
    //chars.next_back();
    chars.as_str()
}

fn read_and_leak (path: impl AsRef<Path>) -> Usually<&'static str> {
    Ok(leak(String::from_utf8(std::fs::read(path.as_ref())?)?))
}

fn leak (x: impl AsRef<str>) -> &'static str {
    Box::leak(x.as_ref().into())
}