use super::{
    NullDomain,
    value::{
        ArcValue,
        NestedValue,
        Domain,
    },
};

pub static MAGIC: &str = "$____Preserves_Serde_Magic";

pub type IOValue = ArcValue<NullDomain>;

struct IOValueVisitor;
impl<'de> serde::de::Visitor<'de> for IOValueVisitor {
    type Value = IOValue;
    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
        write!(formatter, "a magic encoding of an embedded Preserves Value")
    }
    fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E> where E: serde::de::Error {
        let b = unsafe { Box::from_raw(v as *mut IOValue) };
        Ok(*b)
    }
}

pub fn output_value<S: serde::Serializer>(serializer: S, v: IOValue) ->
    Result<S::Ok, S::Error>
{
    serializer.serialize_newtype_struct(MAGIC, &(Box::into_raw(Box::new(v)) as u64))
}

pub fn input_value<'de, D: serde::Deserializer<'de>>(deserializer: D) ->
    Result<IOValue, D::Error>
{
    deserializer.deserialize_newtype_struct(MAGIC, IOValueVisitor)
}

pub fn input_value_via<'de, D: serde::Deserializer<'de>, N: NestedValue<Dom>, Dom: Domain>(deserializer: D) ->
    Result<N, D::Error>
{
    Ok(input_value(deserializer)?.copy_via(&|_| unreachable!()))
}

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

pub fn receive_output_value<T: ?Sized>(name: &'static str, magic_value: &T) -> Option<IOValue> {
    if name == MAGIC {
        let b = unsafe { Box::from_raw(*((magic_value as *const T) as *const u64) as *mut IOValue) };
        let v: IOValue = *b;
        Some(v)
    } else {
        None
    }
}

pub fn transmit_input_value<F>(name: &'static str, f: F) -> Option<u64>
where F: FnOnce() -> IOValue
{
    if name == MAGIC {
        let b: Box<IOValue> = Box::new(f());
        Some(Box::into_raw(b) as u64)
    } else {
        None
    }
}