use super::Value;

impl Value {
    pub fn class_name(&self) -> Option<&String> {
        if let Value::Object { class, .. } = self {
            Some(class)
        } else {
            None
        }
    }
    pub fn as_string(self) -> Option<String> {
        if let Value::String(s) = self {
            Some(s)
        } else {
            None
        }
    }
    pub fn as_i64(&self) -> Option<i64> {
        if let Value::I64(s) = self {
            Some(*s)
        } else {
            None
        }
    }
    pub fn as_i32(&self) -> Option<i32> {
        if let Value::I32(s) = self {
            Some(*s)
        } else {
            None
        }
    }
    pub fn as_u32(&self) -> Option<u32> {
        if let Value::U32(s) = self {
            Some(*s)
        } else {
            None
        }
    }
    pub fn as_u8(&self) -> Option<u8> {
        if let Value::U8(s) = self {
            Some(*s)
        } else {
            None
        }
    }
    pub fn as_u64(&self) -> Option<u64> {
        match self {
            Self::U64(x) => Some(*x),
            Self::U32(x) => Some(*x as u64),
            _ => None,
        }
    }
    pub fn as_f32(&self) -> Option<f32> {
        if let Value::F32(s) = self {
            Some(*s)
        } else {
            None
        }
    }
    pub fn as_u16(&self) -> Option<u16> {
        if let Value::U16(s) = self {
            Some(*s)
        } else {
            None
        }
    }
    pub fn as_bool(&self) -> Option<bool> {
        if let Value::Bool(s) = self {
            Some(*s)
        } else {
            None
        }
    }
    pub fn as_array(self) -> Option<Vec<Value>> {
        if let Value::Array(s) = self {
            Some(s)
        } else {
            None
        }
    }
    pub fn as_typeless(self) -> Option<Vec<u8>> {
        if let Value::Typeless(s) = self {
            Some(s)
        } else {
            None
        }
    }
    pub fn to_json(self) -> serde_json::Value {
        use serde_json::{Number, Value as V};
        match self {
            Value::Bool(x) => V::Bool(x),
            Value::U8(x) => V::Number(x.into()),
            Value::I8(x) => V::Number(x.into()),
            Value::U16(x) => V::Number(x.into()),
            Value::I16(x) => V::Number(x.into()),
            Value::U32(x) => V::Number(x.into()),
            Value::U64(x) => V::Number(x.into()),
            Value::I32(x) => V::Number(x.into()),
            Value::F32(x) => V::Number(Number::from_f64(x as f64).unwrap_or(0.into())),
            Value::I64(x) => V::Number(x.into()),
            Value::F64(x) => V::Number(Number::from_f64(x).unwrap()),
            Value::String(x) => V::String(x),
            Value::Typeless(values) => {
                V::Array(values.into_iter().map(|e| V::Number(e.into())).collect())
            }
            Value::Array(values) => V::Array(values.into_iter().map(Value::to_json).collect()),
            Value::Object { class, fields, .. } => V::Object(
                fields
                    .into_iter()
                    .map(|(k, v)| (k, v.to_json()))
                    .chain(Some(("@class".to_string(), V::String(class))))
                    .collect(),
            ),
        }
    }
}