use std::any::Any;
use std::collections::HashMap;
use std::marker::PhantomData;
use std::io::{self, Read, Write};

pub type CerealResult<T> = ::std::result::Result<T, CerealError>;

pub unsafe trait CerealData: 'static+Sized {
    fn write(&self, &mut Write) -> CerealResult<()>;
    fn read(&mut Read) -> CerealResult<Self>;
}

#[derive(Debug)]
pub enum CerealError {
    Io(io::Error),
    Msg(String),
    Any(Box<Any>),
}

#[macro_export]
macro_rules! __priv_read_ignore {
    {
        $read:expr, $e:expr
    } => {
        $crate::CerealData::read($read)
    }
}

#[macro_export]
macro_rules! impl_cereal_data {
    {
        $Struct:ident
    } => {
        __priv_data_empty!($Struct, $Struct);
    };
    {
        $Struct:ident(), $($field:ident),+
    } => {
        unsafe impl $crate::CerealData for $Struct {
            fn write(&self, write: &mut ::std::io::Write) -> $crate::CerealResult<()> {
                match *self {
                    $Struct($(ref $field),+) => {
                        $(try!($crate::CerealData::write($field, write)));+
                    },
                }
                Ok(())
            }

            fn read(read: &mut ::std::io::Read) -> $crate::CerealResult<$Struct> {
                Ok($Struct(
                    $(
                        try!(__priv_read_ignore!(read, $field))
                    ),+
                ))
            }
        }
    };
    {
        $Struct:ident, $($field:ident),+
    } => {
        unsafe impl $crate::CerealData for $Struct {
            fn write(&self, write: &mut ::std::io::Write) -> $crate::CerealResult<()> {
                $(
                    try!($crate::CerealData::write(&self.$field, write))
                );+;
                Ok(())
            }

            fn read(read: &mut ::std::io::Read) -> $crate::CerealResult<$Struct> {
                Ok($Struct {
                    $(
                        $field: try!($crate::CerealData::read(read))
                    ),+
                })
            }
        }
    };
}

macro_rules! data_primitive {
    {
        $Type:ty, $N:expr
    } => {
        unsafe impl $crate::CerealData for $Type {
            fn write(&self, write: &mut ::std::io::Write) -> $crate::CerealResult<()> {
                let bytes: &[u8; $N] = unsafe {
                    ::std::mem::transmute(self)
                };
                write.write_all(bytes).map_err(|e| CerealError::Io(e))
            }

            fn read(read: &mut ::std::io::Read) -> $crate::CerealResult<$Type> {
                let mut bytes = [0u8; $N];
                try!(read.read_exact(&mut bytes).map_err(|err| $crate::CerealError::Io(err)));
                unsafe {
                    Ok(::std::mem::transmute::<_, $Type>(bytes))
                }
            }
        }
    }
}

#[macro_export]
macro_rules! __priv_data_empty {
    {
        $Type:ty, $Expr:expr
    } => {
        unsafe impl $crate::CerealData for $Type {
            fn write(&self, _: &mut ::std::io::Write) -> $crate::CerealResult<()> { Ok(()) }
            fn read(_: &mut ::std::io::Read) -> $crate::CerealResult<$Type> { Ok($Expr) }
        }
    }
}

data_primitive!(u8, 1);
data_primitive!(i8, 1);
data_primitive!(u16, 2);
data_primitive!(i16, 2);
data_primitive!(u32, 4);
data_primitive!(i32, 4);
data_primitive!(f32, 4);
data_primitive!(u64, 8);
data_primitive!(i64, 8);
data_primitive!(f64, 8);

unsafe impl CerealData for bool { // We can't really write 1 bit by itself
    fn write(&self, write: &mut Write) -> CerealResult<()> {
        (if *self { 1u8 } else { 0u8 }).write(write)
    }

    fn read(read: &mut Read) -> CerealResult<bool> {
        <u8>::read(read).map(|u| u != 0)
    }
}

unsafe impl<T:CerealData> CerealData for Vec<T> {
    fn write(&self, write: &mut Write) -> CerealResult<()> {
        write_slice(write, self)
    }

    fn read(read: &mut Read) -> CerealResult<Vec<T>> {
        let len = try!(u64::read(read)) as usize;
        let mut vec = Vec::with_capacity(len);
        for _ in 0..len {
            vec.push(try!(CerealData::read(read)));
        }
        Ok(vec)
    }
}

unsafe impl<T:CerealData> CerealData for Box<T> {
    fn write(&self, write: &mut Write) -> CerealResult<()> {
        CerealData::write(&**self, write)
    }

    fn read(read: &mut Read) -> CerealResult<Box<T>> {
        CerealData::read(read).map(|o| Box::new(o))
    }
}

unsafe impl CerealData for String {
    fn write(&self, write: &mut Write) -> CerealResult<()> {
        write_slice(write, self.as_bytes())
    }

    fn read(read: &mut Read) -> CerealResult<String> {
        Vec::read(read).and_then(|vec| String::from_utf8(vec).map_err(|err| CerealError::Any(Box::new(err) as Box<Any>)))
    }
}

pub fn write_slice<T: CerealData>(write: &mut Write, slice: &[T]) -> CerealResult<()> {
    try!((slice.len() as u64).write(write));
    for data in slice {
        try!(data.write(write));
    }
    Ok(())
}

unsafe impl<K:Eq+::std::hash::Hash+CerealData, V:CerealData> CerealData for HashMap<K, V> {
    fn write(&self, write: &mut Write) -> CerealResult<()> {
        try!((self.len() as u64).write(write));
        for (k, v) in self {
            try!(k.write(write));
            try!(v.write(write));
        }
        Ok(())
    }

    fn read(read: &mut Read) -> CerealResult<HashMap<K, V>> {
        let len = try!(u64::read(read)) as usize;
        let mut map = HashMap::with_capacity(len);
        for _ in 0..len {
            map.insert(try!(CerealData::read(read)), try!(CerealData::read(read)));
        }
        Ok(map)
    }
}

unsafe impl<T: CerealData> CerealData for PhantomData<T> {
    fn write(&self, _: &mut Write) -> CerealResult<()> { Ok(()) }
    fn read(_: &mut Read) -> CerealResult<PhantomData<T>> { Ok(PhantomData) }
}

__priv_data_empty!((), ());