use num::bigint::BigInt;
use num::traits::cast::ToPrimitive;
use std::cmp::{Ordering};
use std::fmt::Debug;
use std::hash::{Hash,Hasher};
use std::ops::Index;
use std::ops::IndexMut;
use std::string::String;
use std::vec::Vec;

pub use std::collections::BTreeSet as Set;
pub use std::collections::BTreeMap as Map;

pub trait Domain: Sized + Debug + Clone + Eq + Hash + Ord {
    fn as_preserves(&self) -> Result<IOValue, std::io::Error> {
        Err(std::io::Error::new(std::io::ErrorKind::InvalidData,
                                format!("Cannot Preserves-encode domain-specific value {:?}",
                                        self)))
    }
}

pub trait NestedValue<D: Domain>: Sized + Debug + Clone + Eq + Hash + Ord {
    type BoxType: Sized + Debug + Clone + Eq + Hash + Ord;

    fn wrap(v: Value<Self, D>) -> Self;
    fn wrap_ann(anns: Vec<Self>, v: Value<Self, D>) -> Self;

    fn boxwrap(self) -> Self::BoxType;
    fn boxunwrap(b: &Self::BoxType) -> &Self;

    fn annotations(&self) -> &[Self];
    fn value(&self) -> &Value<Self, D>;
    fn value_owned(self) -> Value<Self, D>;

    fn debug_fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        for ann in self.annotations() {
            write!(f, "@{:?} ", ann)?;
        }
        self.value().fmt(f)
    }

    fn copy_via<M: NestedValue<E>, E: Domain, F>(&self, f: &F) -> M
    where
        F: Fn(&D) -> Value<M, E>
    {
        M::wrap_ann(self.annotations().iter().map(|a| a.copy_via(f)).collect(),
                    self.value().copy_via(f))
    }

    fn copy_via_id<M: NestedValue<D>>(&self) -> M {
        self.copy_via(&|d| Value::Domain(d.clone()))
    }

    fn to_io_value(&self) -> IOValue {
        self.copy_via(&|d| d.as_preserves().unwrap().value().clone())
    }

    fn from_io_value(v: &IOValue) -> Self {
        v.copy_via(&|_| unreachable!())
    }
}

/// The `Value`s from the specification.
#[derive(Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub enum Value<N, D> where N: NestedValue<D>, D: Domain {
    Boolean(bool),
    Float(Float),
    Double(Double),
    SignedInteger(BigInt),
    String(String),
    ByteString(Vec<u8>),
    Symbol(String),
    Record(Record<N, D>),
    Sequence(Vec<N>),
    Set(Set<N>),
    Dictionary(Map<N, N>),
    Domain(D),
}

/// Single-precision IEEE 754 Value
#[derive(Clone, Debug)]
pub struct Float(pub f32);

/// Double-precision IEEE 754 Value
#[derive(Clone, Debug)]
pub struct Double(pub f64);

/// A Record `Value`
pub type Record<N, D> = (<N as NestedValue<D>>::BoxType, Vec<N>);

impl From<f32> for Float {
    fn from(v: f32) -> Self {
        Float(v)
    }
}

impl From<Float> for f32 {
    fn from(v: Float) -> Self {
        v.0
    }
}

impl Hash for Float {
    fn hash<H: Hasher>(&self, state: &mut H) {
        self.0.to_bits().hash(state);
    }
}

impl PartialEq for Float {
    fn eq(&self, other: &Self) -> bool {
        self.0.to_bits() == other.0.to_bits()
    }
}

impl Ord for Float {
    fn cmp(&self, other: &Self) -> Ordering {
        let mut a: u32 = self.0.to_bits();
        let mut b: u32 = other.0.to_bits();
        if a & 0x8000_0000 != 0 { a ^= 0x7fff_ffff; }
        if b & 0x8000_0000 != 0 { b ^= 0x7fff_ffff; }
        (a as i32).cmp(&(b as i32))
    }
}

impl PartialOrd for Float {
    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
        Some(self.cmp(other))
    }
}

impl Eq for Float {}

impl From<f64> for Double {
    fn from(v: f64) -> Self {
        Double(v)
    }
}

impl From<Double> for f64 {
    fn from(v: Double) -> Self {
        v.0
    }
}

impl Hash for Double {
    fn hash<H: Hasher>(&self, state: &mut H) {
        self.0.to_bits().hash(state);
    }
}

impl PartialEq for Double {
    fn eq(&self, other: &Self) -> bool {
        self.0.to_bits() == other.0.to_bits()
    }
}

impl Ord for Double {
    fn cmp(&self, other: &Self) -> Ordering {
        let mut a: u64 = self.0.to_bits();
        let mut b: u64 = other.0.to_bits();
        if a & 0x8000_0000_0000_0000 != 0 { a ^= 0x7fff_ffff_ffff_ffff; }
        if b & 0x8000_0000_0000_0000 != 0 { b ^= 0x7fff_ffff_ffff_ffff; }
        (a as i64).cmp(&(b as i64))
    }
}

impl PartialOrd for Double {
    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
        Some(self.cmp(other))
    }
}

impl Eq for Double {}

impl<N: NestedValue<D>, D: Domain> From<bool> for Value<N, D> { fn from(v: bool) -> Self { Value::Boolean(v) } }

impl<N: NestedValue<D>, D: Domain> From<f32> for Value<N, D> { fn from(v: f32) -> Self { Value::Float(Float::from(v)) } }
impl<N: NestedValue<D>, D: Domain> From<f64> for Value<N, D> { fn from(v: f64) -> Self { Value::Double(Double::from(v)) } }

impl<N: NestedValue<D>, D: Domain> From<u8> for Value<N, D> { fn from(v: u8) -> Self { Value::from(i128::from(v)) } }
impl<N: NestedValue<D>, D: Domain> From<i8> for Value<N, D> { fn from(v: i8) -> Self { Value::from(i128::from(v)) } }
impl<N: NestedValue<D>, D: Domain> From<u16> for Value<N, D> { fn from(v: u16) -> Self { Value::from(i128::from(v)) } }
impl<N: NestedValue<D>, D: Domain> From<i16> for Value<N, D> { fn from(v: i16) -> Self { Value::from(i128::from(v)) } }
impl<N: NestedValue<D>, D: Domain> From<u32> for Value<N, D> { fn from(v: u32) -> Self { Value::from(i128::from(v)) } }
impl<N: NestedValue<D>, D: Domain> From<i32> for Value<N, D> { fn from(v: i32) -> Self { Value::from(i128::from(v)) } }
impl<N: NestedValue<D>, D: Domain> From<u64> for Value<N, D> { fn from(v: u64) -> Self { Value::from(i128::from(v)) } }
impl<N: NestedValue<D>, D: Domain> From<i64> for Value<N, D> { fn from(v: i64) -> Self { Value::from(i128::from(v)) } }
impl<N: NestedValue<D>, D: Domain> From<u128> for Value<N, D> { fn from(v: u128) -> Self { Value::SignedInteger(BigInt::from(v)) } }
impl<N: NestedValue<D>, D: Domain> From<i128> for Value<N, D> { fn from(v: i128) -> Self { Value::SignedInteger(BigInt::from(v)) } }
impl<N: NestedValue<D>, D: Domain> From<BigInt> for Value<N, D> { fn from(v: BigInt) -> Self { Value::SignedInteger(v) } }

impl<N: NestedValue<D>, D: Domain> From<&str> for Value<N, D> { fn from(v: &str) -> Self { Value::String(String::from(v)) } }
impl<N: NestedValue<D>, D: Domain> From<String> for Value<N, D> { fn from(v: String) -> Self { Value::String(v) } }

impl<N: NestedValue<D>, D: Domain> From<&[u8]> for Value<N, D> { fn from(v: &[u8]) -> Self { Value::ByteString(Vec::from(v)) } }
// impl<N: NestedValue<D>, D: Domain> From<Vec<u8>> for Value<N, D> { fn from(v: Vec<u8>) -> Self { Value::ByteString(v) } }

impl<N: NestedValue<D>, D: Domain> From<Vec<N>> for Value<N, D> { fn from(v: Vec<N>) -> Self { Value::Sequence(v) } }
impl<N: NestedValue<D>, D: Domain> From<Set<N>> for Value<N, D> { fn from(v: Set<N>) -> Self { Value::Set(v) } }
impl<N: NestedValue<D>, D: Domain> From<Map<N, N>> for Value<N, D> { fn from(v: Map<N, N>) -> Self { Value::Dictionary(v) } }

impl<N: NestedValue<D>, D: Domain> Debug for Value<N, D> {
    // Not *quite* a formatter for the Preserves text syntax, since it
    // doesn't escape strings/symbols properly.
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Value::Boolean(false) => f.write_str("#false"),
            Value::Boolean(true) => f.write_str("#true"),
            Value::Float(Float(v)) => write!(f, "{:?}f", v),
            Value::Double(Double(v)) => write!(f, "{:?}", v),
            Value::SignedInteger(v) => write!(f, "{}", v),
            Value::String(ref v) => write!(f, "{:?}", v), // TODO: proper escaping!
            Value::ByteString(ref v) => {
                f.write_str("#hex{")?;
                for b in v { write!(f, "{:02x}", b)? }
                f.write_str("}")
            }
            Value::Symbol(ref v) => {
                // TODO: proper escaping!
                if v.is_empty() {
                    f.write_str("||")
                } else {
                    write!(f, "{}", v)
                }
            }
            Value::Record((ref l, ref fs)) => {
                f.write_str("<")?;
                l.fmt(f)?;
                for v in fs {
                    f.write_str(" ")?;
                    v.fmt(f)?;
                }
                f.write_str(">")
            }
            Value::Sequence(ref v) => v.fmt(f),
            Value::Set(ref v) => {
                f.write_str("#set")?;
                f.debug_set().entries(v.iter()).finish()
            }
            Value::Dictionary(ref v) => f.debug_map().entries(v.iter()).finish(),
            Value::Domain(ref d) => write!(f, "{:?}", d),
        }
    }
}

//---------------------------------------------------------------------------

impl<N: NestedValue<D>, D: Domain> Value<N, D> {
    pub fn wrap(self) -> N {
        N::wrap(self)
    }

    pub fn is_boolean(&self) -> bool {
        self.as_boolean().is_some()
    }

    pub fn as_boolean(&self) -> Option<bool> {
        if let Value::Boolean(b) = *self {
            Some(b)
        } else {
            None
        }
    }

    pub fn as_boolean_mut(&mut self) -> Option<&mut bool> {
        if let Value::Boolean(ref mut b) = *self {
            Some(b)
        } else {
            None
        }
    }

    pub fn is_float(&self) -> bool {
        self.as_float().is_some()
    }

    pub fn as_float(&self) -> Option<f32> {
        if let Value::Float(Float(f)) = *self {
            Some(f)
        } else {
            None
        }
    }

    pub fn as_float_mut(&mut self) -> Option<&mut f32> {
        if let Value::Float(Float(ref mut f)) = *self {
            Some(f)
        } else {
            None
        }
    }

    pub fn is_double(&self) -> bool {
        self.as_double().is_some()
    }

    pub fn as_double(&self) -> Option<f64> {
        if let Value::Double(Double(f)) = *self {
            Some(f)
        } else {
            None
        }
    }

    pub fn as_double_mut(&mut self) -> Option<&mut f64> {
        if let Value::Double(Double(ref mut f)) = *self {
            Some(f)
        } else {
            None
        }
    }

    pub fn is_signedinteger(&self) -> bool {
        self.as_signedinteger().is_some()
    }

    pub fn as_signedinteger(&self) -> Option<&BigInt> {
        if let Value::SignedInteger(ref i) = *self {
            Some(i)
        } else {
            None
        }
    }

    pub fn as_signedinteger_mut(&mut self) -> Option<&mut BigInt> {
        if let Value::SignedInteger(ref mut i) = *self {
            Some(i)
        } else {
            None
        }
    }

    pub fn as_u8(&self) -> Option<u8> { self.as_signedinteger().and_then(|i| i.to_u8()) }
    pub fn as_i8(&self) -> Option<i8> { self.as_signedinteger().and_then(|i| i.to_i8()) }
    pub fn as_u16(&self) -> Option<u16> { self.as_signedinteger().and_then(|i| i.to_u16()) }
    pub fn as_i16(&self) -> Option<i16> { self.as_signedinteger().and_then(|i| i.to_i16()) }
    pub fn as_u32(&self) -> Option<u32> { self.as_signedinteger().and_then(|i| i.to_u32()) }
    pub fn as_i32(&self) -> Option<i32> { self.as_signedinteger().and_then(|i| i.to_i32()) }
    pub fn as_u64(&self) -> Option<u64> { self.as_signedinteger().and_then(|i| i.to_u64()) }
    pub fn as_i64(&self) -> Option<i64> { self.as_signedinteger().and_then(|i| i.to_i64()) }

    pub fn is_string(&self) -> bool {
        self.as_string().is_some()
    }

    pub fn as_string(&self) -> Option<&String> {
        if let Value::String(ref s) = *self {
            Some(s)
        } else {
            None
        }
    }

    pub fn as_string_mut(&mut self) -> Option<&mut String> {
        if let Value::String(ref mut s) = *self {
            Some(s)
        } else {
            None
        }
    }

    pub fn is_bytestring(&self) -> bool {
        self.as_bytestring().is_some()
    }

    pub fn as_bytestring(&self) -> Option<&Vec<u8>> {
        if let Value::ByteString(ref s) = *self {
            Some(s)
        } else {
            None
        }
    }

    pub fn as_bytestring_mut(&mut self) -> Option<&mut Vec<u8>> {
        if let Value::ByteString(ref mut s) = *self {
            Some(s)
        } else {
            None
        }
    }

    pub fn symbol(s: &str) -> Value<N, D> {
        Value::Symbol(s.to_string())
    }

    pub fn is_symbol(&self) -> bool {
        self.as_symbol().is_some()
    }

    pub fn as_symbol(&self) -> Option<&String> {
        if let Value::Symbol(ref s) = *self {
            Some(s)
        } else {
            None
        }
    }

    pub fn as_symbol_mut(&mut self) -> Option<&mut String> {
        if let Value::Symbol(ref mut s) = *self {
            Some(s)
        } else {
            None
        }
    }

    pub fn record(label: N, fields: Vec<N>) -> Value<N, D> {
        Value::Record((label.boxwrap(), fields))
    }

    pub fn is_record(&self) -> bool {
        self.as_record(None).is_some()
    }

    pub fn as_record(&self, arity: Option<usize>) -> Option<&Record<N, D>> {
        if let Value::Record(ref r) = *self {
            match arity {
                Some(expected) if r.1.len() == expected => Some(r),
                Some(_other) => None,
                None => Some(r)
            }
        } else {
            None
        }
    }

    pub fn as_record_mut(&mut self, arity: Option<usize>) -> Option<&mut Record<N, D>> {
        if let Value::Record(ref mut r) = *self {
            match arity {
                Some(expected) if r.1.len() == expected => Some(r),
                Some(_other) => None,
                None => Some(r)
            }
        } else {
            None
        }
    }

    pub fn simple_record(label: &str, fields: Vec<N>) -> Value<N, D> {
        Value::record(Value::symbol(label).wrap(), fields)
    }

    pub fn is_simple_record(&self, label: &str, arity: Option<usize>) -> bool {
        self.as_simple_record(label, arity).is_some()
    }

    pub fn as_simple_record(&self, label: &str, arity: Option<usize>) -> Option<&Vec<N>> {
        self.as_record(arity).and_then(|(lp,fs)| {
            match N::boxunwrap(lp).value() {
                Value::Symbol(ref s) if s == label => Some(fs),
                _ => None
            }
        })
    }

    pub fn is_sequence(&self) -> bool {
        self.as_sequence().is_some()
    }

    pub fn as_sequence(&self) -> Option<&Vec<N>> {
        if let Value::Sequence(ref s) = *self {
            Some(s)
        } else {
            None
        }
    }

    pub fn as_sequence_mut(&mut self) -> Option<&mut Vec<N>> {
        if let Value::Sequence(ref mut s) = *self {
            Some(s)
        } else {
            None
        }
    }

    pub fn is_set(&self) -> bool {
        self.as_set().is_some()
    }

    pub fn as_set(&self) -> Option<&Set<N>> {
        if let Value::Set(ref s) = *self {
            Some(s)
        } else {
            None
        }
    }

    pub fn as_set_mut(&mut self) -> Option<&mut Set<N>> {
        if let Value::Set(ref mut s) = *self {
            Some(s)
        } else {
            None
        }
    }

    pub fn is_dictionary(&self) -> bool {
        self.as_dictionary().is_some()
    }

    pub fn as_dictionary(&self) -> Option<&Map<N, N>> {
        if let Value::Dictionary(ref s) = *self {
            Some(s)
        } else {
            None
        }
    }

    pub fn as_dictionary_mut(&mut self) -> Option<&mut Map<N, N>> {
        if let Value::Dictionary(ref mut s) = *self {
            Some(s)
        } else {
            None
        }
    }

    pub fn copy_via<M: NestedValue<E>, E: Domain, F>(&self, f: &F) -> Value<M, E>
    where
        F: Fn(&D) -> Value<M, E>
    {
        match self {
            Value::Boolean(b) => Value::Boolean(*b),
            Value::Float(f) => Value::Float(f.clone()),
            Value::Double(d) => Value::Double(d.clone()),
            Value::SignedInteger(i) => Value::SignedInteger(i.clone()),
            Value::String(ref s) => Value::String(s.clone()),
            Value::ByteString(ref v) => Value::ByteString(v.clone()),
            Value::Symbol(ref v) => Value::Symbol(v.clone()),
            Value::Record((ref l, ref fs)) =>
                Value::Record((N::boxunwrap(l).copy_via::<M,E,F>(f).boxwrap(),
                               fs.iter().map(|a| a.copy_via(f)).collect())),
            Value::Sequence(ref v) => Value::Sequence(v.iter().map(|a| a.copy_via(f)).collect()),
            Value::Set(ref v) => Value::Set(v.iter().map(|a| a.copy_via(f)).collect()),
            Value::Dictionary(ref v) =>
                Value::Dictionary(v.iter().map(|(a,b)| (a.copy_via(f), b.copy_via(f))).collect()),
            Value::Domain(d) => f(d),
        }
    }
}

impl<N: NestedValue<D>, D: Domain> Index<usize> for Value<N, D> {
    type Output = N;

    fn index(&self, i: usize) -> &Self::Output {
        &self.as_sequence().unwrap()[i]
    }
}

impl<N: NestedValue<D>, D: Domain> IndexMut<usize> for Value<N, D> {
    fn index_mut(&mut self, i: usize) -> &mut Self::Output {
        &mut self.as_sequence_mut().unwrap()[i]
    }
}

impl<N: NestedValue<D>, D: Domain> Index<&N> for Value<N, D> {
    type Output = N;

    fn index(&self, i: &N) -> &Self::Output {
        &(*self.as_dictionary().unwrap())[i]
    }
}

//---------------------------------------------------------------------------
// This part is a terrible hack

impl serde::Serialize for UnwrappedIOValue {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: serde::Serializer {
        super::magic::output_value(serializer, self.clone().wrap())
    }
}

impl<'de> serde::Deserialize<'de> for UnwrappedIOValue {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: serde::Deserializer<'de> {
        Ok(super::magic::input_value::<'de, D>(deserializer)?.value_owned())
    }
}

pub fn serialize_nested_value<S, N, D: Domain>(v: &N, serializer: S) ->
    Result<S::Ok, S::Error> where S: serde::Serializer, N: NestedValue<D> + serde::Serialize
{
    super::magic::output_value(serializer, v.to_io_value())
}

pub fn deserialize_nested_value<'de, D, N, Dom: Domain>(deserializer: D) ->
    Result<N, D::Error> where D: serde::Deserializer<'de>, N: NestedValue<Dom> + serde::Deserialize<'de>
{
    Ok(N::from_io_value(&super::magic::input_value(deserializer)?))
}

//---------------------------------------------------------------------------

/// An possibly-annotated Value, with annotations (themselves
/// possibly-annotated) in order of appearance.
#[derive(Clone)]
pub struct AnnotatedValue<N: NestedValue<D>, D: Domain>(pub Vec<N>, pub Value<N, D>);

impl<N: NestedValue<D>, D: Domain> PartialEq for AnnotatedValue<N, D> {
    fn eq(&self, other: &Self) -> bool {
        self.1.eq(&other.1)
    }
}

impl<N: NestedValue<D>, D: Domain> Eq for AnnotatedValue<N, D> {}

impl<N: NestedValue<D>, D: Domain> Hash for AnnotatedValue<N, D> {
    fn hash<H: Hasher>(&self, state: &mut H) {
        self.1.hash(state);
    }
}

impl<N: NestedValue<D>, D: Domain> PartialOrd for AnnotatedValue<N, D> {
    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
        Some(self.cmp(other))
    }
}

impl<N: NestedValue<D>, D: Domain> Ord for AnnotatedValue<N, D> {
    fn cmp(&self, other: &Self) -> Ordering {
        self.1.cmp(&other.1)
    }
}

//---------------------------------------------------------------------------

#[derive(Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct PlainValue<D: Domain>(AnnotatedValue<PlainValue<D>, D>);

impl<D: Domain> PlainValue<D> {
    pub fn annotations_mut(&mut self) -> &mut Vec<Self> {
        &mut (self.0).0
    }

    pub fn value_mut(&mut self) -> &mut Value<Self, D> {
        &mut (self.0).1
    }
}

impl<D: Domain> NestedValue<D> for PlainValue<D> {
    type BoxType = Box<Self>;

    fn wrap(v: Value<Self, D>) -> Self {
        Self::wrap_ann(Vec::new(), v)
    }

    fn wrap_ann(anns: Vec<Self>, v: Value<Self, D>) -> Self {
        PlainValue(AnnotatedValue(anns, v))
    }

    fn boxwrap(self) -> Self::BoxType {
        Box::new(self)
    }

    fn boxunwrap(b: &Self::BoxType) -> &Self {
        &**b
    }

    fn annotations(&self) -> &[Self] {
        &(self.0).0
    }

    fn value(&self) -> &Value<Self, D> {
        &(self.0).1
    }

    fn value_owned(self) -> Value<Self, D> {
        (self.0).1
    }
}

impl<D: Domain> Debug for PlainValue<D> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        self.debug_fmt(f)
    }
}

impl<D: Domain> serde::Serialize for PlainValue<D> {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: serde::Serializer {
        serialize_nested_value(self, serializer)
    }
}

impl<'de, Dom: Domain> serde::Deserialize<'de> for PlainValue<Dom> {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: serde::Deserializer<'de> {
        deserialize_nested_value(deserializer)
    }
}

//---------------------------------------------------------------------------

use std::rc::Rc;

#[derive(Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct RcValue<D: Domain>(Rc<AnnotatedValue<RcValue<D>, D>>);

impl<D: Domain> NestedValue<D> for RcValue<D> {
    type BoxType = Self;

    fn wrap(v: Value<Self, D>) -> Self {
        Self::wrap_ann(Vec::new(), v)
    }

    fn wrap_ann(anns: Vec<Self>, v: Value<Self, D>) -> Self {
        RcValue(Rc::new(AnnotatedValue(anns, v)))
    }

    fn boxwrap(self) -> Self::BoxType {
        self
    }

    fn boxunwrap(b: &Self::BoxType) -> &Self {
        b
    }

    fn annotations(&self) -> &[Self] {
        &(self.0).0
    }

    fn value(&self) -> &Value<Self, D> {
        &(self.0).1
    }

    fn value_owned(self) -> Value<Self, D> {
        Rc::try_unwrap(self.0).unwrap_or_else(|_| panic!("value_owned on RcValue with refcount greater than one")).1
    }
}

impl<D: Domain> Debug for RcValue<D> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        self.debug_fmt(f)
    }
}

impl<D: Domain> serde::Serialize for RcValue<D> {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: serde::Serializer {
        serialize_nested_value(self, serializer)
    }
}

impl<'de, Dom: Domain> serde::Deserialize<'de> for RcValue<Dom> {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: serde::Deserializer<'de> {
        deserialize_nested_value(deserializer)
    }
}

//---------------------------------------------------------------------------

use std::sync::Arc;

#[derive(Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct ArcValue<D: Domain>(Arc<AnnotatedValue<ArcValue<D>, D>>);

impl<D: Domain> NestedValue<D> for ArcValue<D> {
    type BoxType = Self;

    fn wrap(v: Value<Self, D>) -> Self {
        Self::wrap_ann(Vec::new(), v)
    }

    fn wrap_ann(anns: Vec<Self>, v: Value<Self, D>) -> Self {
        ArcValue(Arc::new(AnnotatedValue(anns, v)))
    }

    fn boxwrap(self) -> Self::BoxType {
        self
    }

    fn boxunwrap(b: &Self::BoxType) -> &Self {
        b
    }

    fn annotations(&self) -> &[Self] {
        &(self.0).0
    }

    fn value(&self) -> &Value<Self, D> {
        &(self.0).1
    }

    fn value_owned(self) -> Value<Self, D> {
        Arc::try_unwrap(self.0).unwrap_or_else(|_| panic!("value_owned on ArcValue with refcount greater than one")).1
    }
}

impl<D: Domain> Debug for ArcValue<D> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        self.debug_fmt(f)
    }
}

impl<D: Domain> serde::Serialize for ArcValue<D> {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: serde::Serializer {
        serialize_nested_value(self, serializer)
    }
}

impl<'de, Dom: Domain> serde::Deserialize<'de> for ArcValue<Dom> {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: serde::Deserializer<'de> {
        deserialize_nested_value(deserializer)
    }
}

//---------------------------------------------------------------------------

#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub enum NullDomain {}
impl Domain for NullDomain {}

#[derive(Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct IOValue(Arc<AnnotatedValue<IOValue, NullDomain>>);
pub type UnwrappedIOValue = Value<IOValue, NullDomain>;

impl NestedValue<NullDomain> for IOValue {
    type BoxType = Self;

    fn wrap(v: Value<Self, NullDomain>) -> Self {
        Self::wrap_ann(Vec::new(), v)
    }

    fn wrap_ann(anns: Vec<Self>, v: Value<Self, NullDomain>) -> Self {
        IOValue(Arc::new(AnnotatedValue(anns, v)))
    }

    fn boxwrap(self) -> Self::BoxType {
        self
    }

    fn boxunwrap(b: &Self::BoxType) -> &Self {
        b
    }

    fn annotations(&self) -> &[Self] {
        &(self.0).0
    }

    fn value(&self) -> &Value<Self, NullDomain> {
        &(self.0).1
    }

    fn value_owned(self) -> Value<Self, NullDomain> {
        match Arc::try_unwrap(self.0) {
            Ok(AnnotatedValue(_anns, v)) => v,
            Err(r) => r.1.clone(),
        }
    }

    fn to_io_value(&self) -> IOValue {
        self.clone()
    }

    fn from_io_value(v: &IOValue) -> Self {
        v.clone()
    }
}

impl Debug for IOValue {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        self.debug_fmt(f)
    }
}

impl serde::Serialize for IOValue {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: serde::Serializer {
        serialize_nested_value(self, serializer)
    }
}

impl<'de> serde::Deserialize<'de> for IOValue {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: serde::Deserializer<'de> {
        deserialize_nested_value(deserializer)
    }
}