use std::collections::HashMap;

use crate::{Identifier,IdentifierValue};

pub type Context = HashMap<String,Value>;

pub trait MappedStructure {
    fn get_value(&self, id: &Identifier) -> Option<Value>;
}

impl MappedStructure for Context {
    fn get_value(&self, id: &Identifier) -> Option<Value> {
        if id.len() == 0 {
            return None;
        }
        let mut cur_val : Option<&Value> = if let IdentifierValue::Name(s) = &id[0] {
            self.get(s)
        } else {
            return None;
        };
        if cur_val.is_none() {
            return None;
        }

        for idx in 1..id.len() {
            if let IdentifierValue::Name(s) = &id[idx] &&
                let Some(Value::Dictionary(d)) = &cur_val {
                cur_val.replace( if let Some(v) = d.get(s) {
                    v
                } else {
                    return None;
                });
            }
        }

        return cur_val.cloned();
    }
}

#[derive(Debug,Clone)]
pub enum Value {
    Dictionary(Context),
    List(Vec<Value>),
    String(String),
    Int(i64),
    Float(f64),
    Bool(bool),
    Identifier(Identifier),
}

impl From<&str> for Value {
    fn from(val: &str ) -> Value {
        Value::String(val.into())
    }
}

impl From<String> for Value {
    fn from(val: String) -> Value {
        Value::String(val)
    }
}

impl From<i64> for Value {
    fn from(val: i64) -> Value {
        Value::Int(val)
    }
}

impl From<f64> for Value {
    fn from(val: f64) -> Value {
        Value::Float(val)
    }
}

impl From<bool> for Value {
    fn from(val: bool) -> Value {
        Value::Bool(val)
    }
}

impl From<Vec<Value>> for Value {
    fn from(val: Vec<Value>) -> Value {
        Value::List(val)
    }
}

impl From<&[Value]> for Value {
    fn from(val: &[Value]) -> Value {
        Value::List(Vec::from(val))
    }
}

impl From<Context> for Value {
    fn from(val: Context) -> Value {
        Value::Dictionary(val)
    }
}

impl<const N: usize> From<[(String,Value); N]> for Value {
    fn from(val: [(String,Value); N]) -> Value {
        Value::Dictionary(HashMap::from(val))
    }
}

/*
impl MappedStructure for Value {
    fn get_value(&self, id: &Identifier) -> Option<Value> {
        if id.len() == 0 {
            return Some(self);
        }
        match Value {
            Value::Dictionary(dict) => {
            }
        }
        let mut cur_val : Option<&Value> = Some(&self);

        for idx in 0..id.len() {
            if let IdentifierValue::Name(s) = &id[idx] &&
                let Some(Value::Dictionary(d)) = &cur_val {
                cur_val.replace( if let Some(v) = d.get(s) {
                    v
                } else {
                    return None;
                });
            }
        }

        return cur_val.cloned();
    }
}
*/
