use crate::codec::error::Error;
use std::{io::Write, sync::Arc};

macro_rules! impl_encode {
    ($t: ty) => {
        impl<Ctx> Encode<Ctx> for $t {
            fn encode(&self, buffer: &mut dyn Write, _: &mut Ctx) -> Result<usize, Error> {
                let size = buffer.write(&self.to_be_bytes())?;
                Ok(size)
            }
        }
    };
}

pub trait Encode<Ctx> {
    fn encode(&self, buffer: &mut dyn Write, ctx: &mut Ctx) -> Result<usize, Error>;
}

impl<Ctx> Encode<Ctx> for bool {
    fn encode(&self, buffer: &mut dyn Write, _: &mut Ctx) -> Result<usize, Error> {
        let size = buffer.write(&[*self as u8])?;
        Ok(size)
    }
}

impl<Ctx, T: Encode<Ctx>> Encode<Ctx> for Option<T> {
    fn encode(&self, buffer: &mut dyn Write, ctx: &mut Ctx) -> Result<usize, Error> {
        match self {
            Some(val) => {
                let mut size = 1u8.encode(buffer, ctx)?;
                size += val.encode(buffer, ctx)?;
                Ok(size)
            }
            None => 0u8.encode(buffer, ctx),
        }
    }
}

impl<Ctx, T: Encode<Ctx>> Encode<Ctx> for Vec<T> {
    fn encode(&self, buffer: &mut dyn Write, ctx: &mut Ctx) -> Result<usize, Error> {
        let mut size = self.len().encode(buffer, ctx)?;
        for item in self {
            size += item.encode(buffer, ctx)?;
        }
        Ok(size)
    }
}

impl<Ctx> Encode<Ctx> for String {
    fn encode(&self, buffer: &mut dyn Write, _: &mut Ctx) -> Result<usize, Error> {
        let utf8 = self.as_bytes();
        buffer.write_all(utf8)?;
        Ok(utf8.len())
    }
}

impl<Ctx> Encode<Ctx> for Arc<[u8]> {
    fn encode(&self, buffer: &mut dyn Write, _: &mut Ctx) -> Result<usize, Error> {
        let len = buffer.write(self)?;
        Ok(len)
    }
}

impl<Ctx, const S: usize> Encode<Ctx> for [u8; S] {
    fn encode(&self, buffer: &mut dyn Write, _ctx: &mut Ctx) -> Result<usize, Error> {
        let len = buffer.write(self)?;
        Ok(len)
    }
}

impl_encode!(u8);
impl_encode!(u16);
impl_encode!(u32);
impl_encode!(u64);
impl_encode!(u128);
impl_encode!(usize);

impl_encode!(i8);
impl_encode!(i16);
impl_encode!(i32);
impl_encode!(i64);
impl_encode!(i128);
impl_encode!(isize);

impl_encode!(f32);
impl_encode!(f64);