use std::collections::HashMap;
use std::fmt;

use crate::{Identifier,IdentifierValue};

pub type Context = HashMap<String,Value>;

pub trait MappedStructure<'a> {
    fn get_value(&'a self, id: &str) -> Option<MappedValue<'a>>;
}

impl<'a> MappedStructure<'a> for Context {
    fn get_value(&'a self, _id: &str) -> Option<MappedValue<'a>> {
        /*
        if id.len() == 0 {
            return None;
        }
        let mut cur_val : Option<&MappedValue> = 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(MappedValue::Dictionary(d)) = &cur_val {
                cur_val.replace( if let Some(v) = d.get(s) {
                    v
                } else {
                    return None;
                });
            }
        }

        return cur_val.cloned();
        */

        None
    }
}

pub trait MappedList<'a> {
    fn get_index(&'a self, id: usize) -> Option<MappedValue<'a>>;
}

pub enum MappedValue<'a> {
    Struct(&'a dyn MappedStructure<'a>),
    List(&'a dyn MappedList<'a>),
    
    Str(&'a str),
    String(&'a String),
    Int8(i8),
    Int16(i16),
    Int32(i32),
    Int64(i64),
    UInt8(u8),
    UInt16(u16),
    UInt32(u32),
    UInt64(u64),
    Float32(f32),
    Float64(f64),
    Bool(bool),
}

impl<'a> fmt::Debug for MappedValue<'a> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            MappedValue::<'a>::Struct(_) => write!(f, "MappedValue"),
            MappedValue::<'a>::List(_) => write!(f, "MappedList"),
            MappedValue::<'a>::Str(v) => write!(f, "{:?}", v), 
            MappedValue::<'a>::String(v) => write!(f, "{:?}", v),
            MappedValue::<'a>::Int8(v) => write!(f, "{:?}", v),
            MappedValue::<'a>::Int16(v) => write!(f, "{:?}", v),
            MappedValue::<'a>::Int32(v) => write!(f, "{:?}", v),
            MappedValue::<'a>::Int64(v) => write!(f, "{:?}", v),
            MappedValue::<'a>::UInt8(v) => write!(f, "{:?}", v),
            MappedValue::<'a>::UInt16(v) => write!(f, "{:?}", v),
            MappedValue::<'a>::UInt32(v) => write!(f, "{:?}", v),
            MappedValue::<'a>::UInt64(v) => write!(f, "{:?}", v),
            MappedValue::<'a>::Float32(v) => write!(f, "{:?}", v),
            MappedValue::<'a>::Float64(v) => write!(f, "{:?}", v),
            MappedValue::<'a>::Bool(v) => write!(f, "{:?}", v),
        }
    }
    
}

pub struct StatefulContext<'a, T: MappedStructure<'a>> {
    root: &'a T,
    local: &'a T,
}

impl<'a, T: MappedStructure<'a>> StatefulContext<'a, T> {
    pub fn root( root: &'a T ) -> Self {
        Self {
            root, local: root,
        }
    }

    pub fn local(&self, local: &'a T ) -> Self {
        Self {
            root: self.root,
            local
        }
    }

    pub fn full( root: &'a T, local: &'a T ) -> Self {
        Self {
            root, local
        }
    }

    pub fn get_value(&self, id: &[IdentifierValue]) -> Option<MappedValue<'a>> {
        let mut value : Option<MappedValue> = Some(MappedValue::Struct(self.root));
        for idpart in id {
            match idpart {
                IdentifierValue::Root => {
                    return None
                }
                IdentifierValue::Name(name) => {
                    if let Some(MappedValue::Struct(s)) = value &&
                        let Some(nv) = s.get_value( &name ) {
                        value.replace( nv );
                    } else {
                        return None;
                    }
                }
                IdentifierValue::Index(_) => {
                    return None;
                }
            }
        }
        value
    }
}

#[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();
    }
}
*/