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 {
        match self {
            Value::Bool(x) => serde_json::Value::Bool(x),
            Value::U8(x) => serde_json::Value::Number(x.into()),
            Value::I8(x) => serde_json::Value::Number(x.into()),
            Value::U16(x) => serde_json::Value::Number(x.into()),
            Value::I16(x) => serde_json::Value::Number(x.into()),
            Value::U32(x) => serde_json::Value::Number(x.into()),
            Value::U64(x) => serde_json::Value::Number(x.into()),
            Value::I32(x) => serde_json::Value::Number(x.into()),
            Value::F32(x) => serde_json::Value::Number(
                serde_json::Number::from_f64(x as f64).unwrap_or(0.into()),
            ),
            Value::I64(x) => serde_json::Value::Number(x.into()),
            Value::F64(x) => serde_json::Value::Number(serde_json::Number::from_f64(x).unwrap()),
            Value::String(x) => serde_json::Value::String(x),
            Value::Typeless(values) => serde_json::Value::Array(
                values
                    .into_iter()
                    .map(|e| serde_json::Value::Number(e.into()))
                    .collect(),
            ),
            Value::Array(values) => {
                serde_json::Value::Array(values.into_iter().map(Value::to_json).collect())
            }
            Value::Object { class, fields } => serde_json::Value::Object(
                fields
                    .into_iter()
                    .map(|(k, v)| (k, v.to_json()))
                    .chain(Some((
                        "@class".to_string(),
                        serde_json::Value::String(class),
                    )))
                    .collect(),
            ),
        }
    }
}