use serde::{Deserialize, Serialize};
use std::cmp::Ordering;

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum Value {
    Int32(i32),
    Int64(i64),
    Float(f64),
    Boolean(bool),
    String(String),
    Ref(usize), // Heap reference
    Null,
}

impl PartialEq for Value {
    fn eq(&self, other: &Self) -> bool {
        match (self, other) {
            (Value::Int32(a), Value::Int32(b)) => a == b,
            (Value::Int64(a), Value::Int64(b)) => a == b,
            (Value::Int32(a), Value::Int64(b)) => *a as i64 == *b,
            (Value::Int64(a), Value::Int32(b)) => *a == *b as i64,
            (Value::Float(a), Value::Float(b)) => a == b,
            (Value::Int32(a), Value::Float(b)) => *a as f64 == *b,
            (Value::Float(a), Value::Int32(b)) => *a == *b as f64,
            (Value::Int64(a), Value::Float(b)) => *a as f64 == *b,
            (Value::Float(a), Value::Int64(b)) => *a == *b as f64,
            (Value::Boolean(a), Value::Boolean(b)) => a == b,
            (Value::String(a), Value::String(b)) => a == b,
            (Value::Ref(a), Value::Ref(b)) => a == b,
            (Value::Null, Value::Null) => true,
            _ => false,
        }
    }
}

impl PartialOrd for Value {
    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
        match (self, other) {
            (Value::Int32(a), Value::Int32(b)) => a.partial_cmp(b),
            (Value::Int64(a), Value::Int64(b)) => a.partial_cmp(b),
            (Value::Int32(a), Value::Int64(b)) => (*a as i64).partial_cmp(b),
            (Value::Int64(a), Value::Int32(b)) => a.partial_cmp(&(*b as i64)),
            (Value::Float(a), Value::Float(b)) => a.partial_cmp(b),
            (Value::Int32(a), Value::Float(b)) => (*a as f64).partial_cmp(b),
            (Value::Float(a), Value::Int32(b)) => a.partial_cmp(&(*b as f64)),
            (Value::Int64(a), Value::Float(b)) => (*a as f64).partial_cmp(b),
            (Value::Float(a), Value::Int64(b)) => a.partial_cmp(&(*b as f64)),
            (Value::Boolean(a), Value::Boolean(b)) => a.partial_cmp(b),
            (Value::String(a), Value::String(b)) => a.partial_cmp(b),
            _ => None,
        }
    }
}

impl Value {
    pub fn as_float(&self) -> Option<f64> {
        match self {
            Value::Int32(i) => Some(*i as f64),
            Value::Int64(i) => Some(*i as f64),
            Value::Float(f) => Some(*f),
            _ => None,
        }
    }

    pub fn as_integer(&self) -> Option<i64> {
        match self {
            Value::Int32(i) => Some(*i as i64),
            Value::Int64(i) => Some(*i),
            Value::Float(f) => Some(*f as i64),
            _ => None,
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_value_equality() {
        assert_eq!(Value::Int32(10), Value::Int32(10));
        assert_eq!(Value::Int64(10), Value::Int64(10));
        assert_eq!(Value::Int32(10), Value::Int64(10));
        assert_eq!(Value::Int64(10), Value::Int32(10));
        assert_eq!(Value::Float(10.5), Value::Float(10.5));
        assert_eq!(Value::Int32(10), Value::Float(10.0));
        assert_eq!(Value::Float(10.0), Value::Int32(10));
        assert_eq!(Value::Int64(10), Value::Float(10.0));
        assert_eq!(Value::Float(10.0), Value::Int64(10));
        assert_ne!(Value::Int32(10), Value::Int32(11));
        assert_ne!(Value::Int64(10), Value::Int64(11));
        assert_ne!(Value::Int32(10), Value::Int64(11));
        assert_ne!(Value::Int32(10), Value::Float(10.1));
        assert_eq!(Value::Boolean(true), Value::Boolean(true));
        assert_ne!(Value::Boolean(true), Value::Boolean(false));
        assert_eq!(Value::String("oi".into()), Value::String("oi".into()));
        assert_eq!(Value::Null, Value::Null);
    }

    #[test]
    fn test_value_conversions() {
        let v_int32 = Value::Int32(42);
        assert_eq!(v_int32.as_float(), Some(42.0));
        assert_eq!(v_int32.as_integer(), Some(42));

        let v_int64 = Value::Int64(42);
        assert_eq!(v_int64.as_float(), Some(42.0));
        assert_eq!(v_int64.as_integer(), Some(42));

        let v_float = Value::Float(42.7);
        assert_eq!(v_float.as_float(), Some(42.7));
        assert_eq!(v_float.as_integer(), Some(42));

        let v_bool = Value::Boolean(true);
        assert_eq!(v_bool.as_float(), None);
        assert_eq!(v_bool.as_integer(), None);
    }
}