pub use lazy_static::lazy_static;

use preserves::value::ArcValue;
use preserves::value::Domain;
use preserves::value::Embeddable;
use preserves::value::IOValue;
use preserves::value::NestedValue;
use preserves::value::NoEmbeddedDomainCodec;
use preserves::value::Value;

use std::convert::From;
use std::convert::TryFrom;
use std::io;
use std::sync::Arc;

pub fn decode_lit<D: Embeddable, N: NestedValue<D>>(bs: &[u8]) -> io::Result<N> {
    preserves::value::packed::from_bytes(bs, NoEmbeddedDomainCodec)
}

pub fn decode_embedded<D: Domain>(
    v: &IOValue,
) -> Result<ArcValue<Arc<D>>, ParseError>
where
    for<'a> D: TryFrom<&'a IOValue, Error = ParseError>
{
    v.copy_via(&mut |d| Ok(Value::Embedded(Arc::new(D::try_from(d)?))))
}

pub fn encode_embedded<D: Domain>(
    v: &ArcValue<Arc<D>>,
) -> IOValue
where
    for<'a> IOValue: From<&'a D>
{
    v.copy_via::<_, _, _, std::convert::Infallible>(
        &mut |d| Ok(Value::Embedded(IOValue::from(d)))).unwrap()
}

#[derive(Debug)]
pub enum ParseError {
    ConformanceError,
    IO(io::Error),
    Preserves(preserves::error::Error),
}

const INPUT_NOT_CONFORMANT: &str = "Input not conformant with Schema";

impl std::fmt::Display for ParseError {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
        match self {
            ParseError::ConformanceError => write!(f, "{}", INPUT_NOT_CONFORMANT),
            ParseError::IO(e) => e.fmt(f),
            ParseError::Preserves(e) => e.fmt(f),
        }
    }
}

impl std::error::Error for ParseError {}

impl From<io::Error> for ParseError {
    fn from(v: io::Error) -> Self {
        ParseError::IO(v)
    }
}

impl From<preserves::error::Error> for ParseError {
    fn from(v: preserves::error::Error) -> Self {
        ParseError::Preserves(v)
    }
}

impl From<ParseError> for io::Error {
    fn from(v: ParseError) -> Self {
        match v {
            ParseError::ConformanceError =>
                io::Error::new(io::ErrorKind::InvalidData, INPUT_NOT_CONFORMANT),
            ParseError::IO(e) => e,
            ParseError::Preserves(e) => e.into(),
        }
    }
}