//! Decoding: reading protocol values from a byte stream.
use std::{
    collections::{BTreeMap, BTreeSet, BinaryHeap, HashMap, HashSet},
    hash::Hash,
    io::Read,
    sync::Arc,
};

use crate::{DEFAULT_BUFFER_LEN, codec::error::Result};
use crate::{codec::error::CodecError, context::Context};

macro_rules! impl_decode {
    (u8) => {
        impl<Data> Decode<Data> for u8 {
            fn decode(reader: &mut dyn Read, _: &Context<Data>) -> Result<Self>
            where
                Self: Sized,
            {
                let mut byte = [0u8; 1];
                reader.read_exact(&mut byte)?;
                Ok(byte[0])
            }

            fn decode_slice(reader: &mut dyn Read, _: &Context<Data>) -> Result<Vec<Self>>
            where
                Self: Sized,
            {
                let mut buf = Vec::new();
                reader.read_to_end(&mut buf)?;
                Ok(buf)
            }
        }
    };
    ($type: ty) => {
        impl<Data> Decode<Data> for $type {
            // decode number using big endian
            fn decode(reader: &mut dyn Read, _: &Context<Data>) -> Result<Self>
            where
                Self: Sized,
            {
                const BYTES: usize = (<$type>::BITS / 8) as usize;
                let mut bytes = [0; BYTES];
                reader.read_exact(&mut bytes)?;
                Ok(<$type>::from_be_bytes(bytes))
            }

            fn decode_slice(reader: &mut dyn Read, _: &Context<Data>) -> Result<Vec<Self>>
            where
                Self: Sized,
            {
                let mut buf = Vec::with_capacity(DEFAULT_BUFFER_LEN);
                reader.read_to_end(&mut buf);
                const BYTES: usize = <$type>::BITS as usize / 8;
                Ok(buf
                    .chunks(BYTES)
                    .map(|slice| {
                        let Some(bytes): Option<&[u8; BYTES]> = slice.as_array() else {
                            unreachable!()
                        };
                        <$type>::from_be_bytes(*bytes)
                    })
                    .collect())
            }
        }
    };
}

macro_rules! impl_decode_tuples {
    ($($generic: ident),+) => {
            impl<Data, $($generic),+> Decode<Data> for ($($generic,)+) where $($generic: Decode<Data>,)+  {
                #[allow(non_snake_case)]
                fn decode(reader: &mut dyn Read, ctx: &Context<Data>) -> Result<Self>
                where
                    Self: Sized {
                        $(
                            let $generic = $generic::decode(reader, ctx)?;
                        )+
                        Ok(($($generic,)+))
                }
            }
    };
}

/// Read a value from a byte stream
pub trait Decode<Data> {
    fn decode(reader: &mut dyn Read, ctx: &Context<Data>) -> Result<Self>
    where
        Self: Sized;

    // TODO : change for anything else than Vec
    /// assume reader contains only the slice to decode
    fn decode_slice(reader: &mut dyn Read, ctx: &Context<Data>) -> Result<Vec<Self>>
    where
        Self: Sized,
    {
        let mut buf = Vec::new();
        loop {
            match Self::decode(reader, ctx) {
                Ok(value) => buf.push(value),
                Err(CodecError::IoError(err))
                    if let std::io::ErrorKind::UnexpectedEof = err.kind() =>
                {
                    return Ok(buf);
                }
                Err(err) => return Err(err),
            }
        }
    }
}

// ~ Decode arrays

impl<Data, T: Decode<Data>> Decode<Data> for Vec<T> {
    fn decode(reader: &mut dyn Read, ctx: &Context<Data>) -> Result<Self>
    where
        Self: Sized,
    {
        let len = usize::decode(reader, ctx)?;
        let mut vec = Vec::with_capacity(len);
        for _ in 0..len {
            vec.push(T::decode(reader, ctx)?);
        }
        Ok(vec)
    }
}

impl<Data, T: Decode<Data>> Decode<Data> for Option<T> {
    /// Assume is always some
    fn decode(reader: &mut dyn Read, ctx: &Context<Data>) -> Result<Self>
    where
        Self: Sized,
    {
        T::decode(reader, ctx).map(Some)
    }
}

// ~ Decode slices

impl<Data, T, const S: usize> Decode<Data> for [T; S]
where
    T: Decode<Data> + Default + Copy,
{
    fn decode(reader: &mut dyn Read, ctx: &Context<Data>) -> Result<Self>
    where
        Self: Sized,
    {
        let slice = T::decode_slice(reader, ctx)?;
        let got = slice.len();
        slice
            .as_array()
            .cloned()
            .ok_or(CodecError::WrongSize { expected: S, got })
    }
}

impl<Data, T> Decode<Data> for &[T]
where
    T: Decode<Data> + Default + Copy,
{
    fn decode(_: &mut dyn Read, _: &Context<Data>) -> Result<Self>
    where
        Self: Sized,
    {
        unimplemented!()
    }
}

// ~ Decode set

impl<Data, T> Decode<Data> for HashSet<T>
where
    T: Decode<Data> + Eq + Hash,
{
    fn decode(reader: &mut dyn Read, ctx: &Context<Data>) -> Result<Self>
    where
        Self: Sized,
    {
        let slice = T::decode_slice(reader, ctx)?;
        Ok(slice.into_iter().collect())
    }
}

impl<Data, T> Decode<Data> for BTreeSet<T>
where
    T: Decode<Data> + Ord,
{
    fn decode(reader: &mut dyn Read, ctx: &Context<Data>) -> Result<Self>
    where
        Self: Sized,
    {
        let slice = T::decode_slice(reader, ctx)?;
        Ok(slice.into_iter().collect())
    }
}

// ~ Decode misc

impl<Data, T> Decode<Data> for BinaryHeap<T>
where
    T: Decode<Data> + Ord,
{
    fn decode(reader: &mut dyn Read, ctx: &Context<Data>) -> Result<Self>
    where
        Self: Sized,
    {
        let slice = T::decode_slice(reader, ctx)?;
        Ok(BinaryHeap::from_iter(slice))
    }
}

// ~ Decode maps

impl<Data, K, V> Decode<Data> for HashMap<K, V>
where
    K: Decode<Data> + Eq + Hash,
    V: Decode<Data>,
{
    fn decode(reader: &mut dyn Read, ctx: &Context<Data>) -> Result<Self>
    where
        Self: Sized,
    {
        let slice = <(K, V) as Decode<Data>>::decode_slice(reader, ctx)?;
        Ok(slice.into_iter().collect())
    }
}

impl<Data, K, V> Decode<Data> for BTreeMap<K, V>
where
    K: Decode<Data> + Ord,
    V: Decode<Data>,
{
    fn decode(reader: &mut dyn Read, ctx: &Context<Data>) -> Result<Self>
    where
        Self: Sized,
    {
        let slice = <(K, V) as Decode<Data>>::decode_slice(reader, ctx)?;
        Ok(slice.into_iter().collect())
    }
}

// ~ Decode string

impl<Data> Decode<Data> for &str {
    fn decode(_: &mut dyn Read, _: &Context<Data>) -> Result<Self>
    where
        Self: Sized,
    {
        unimplemented!()
    }
}

impl<Data> Decode<Data> for String {
    fn decode(reader: &mut dyn Read, _: &Context<Data>) -> Result<Self>
    where
        Self: Sized,
    {
        let mut bytes: Vec<u8> = Vec::new();
        reader.read_to_end(&mut bytes)?;
        Ok(String::from_utf8_lossy(&bytes).to_string())
    }
}

// ~ Decode primitive

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

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

impl<Data> Decode<Data> for f64 {
    fn decode(reader: &mut dyn Read, ctx: &Context<Data>) -> Result<Self>
    where
        Self: Sized,
    {
        let bits = u64::decode(reader, ctx)?;
        let value = f64::from_bits(bits);
        Ok(value)
    }
}

impl<Data> Decode<Data> for f32 {
    fn decode(reader: &mut dyn Read, ctx: &Context<Data>) -> Result<Self>
    where
        Self: Sized,
    {
        let bits = u32::decode(reader, ctx)?;
        let value = f32::from_bits(bits);
        Ok(value)
    }
}

impl<Data> Decode<Data> for bool {
    fn decode(reader: &mut dyn Read, _: &Context<Data>) -> Result<Self>
    where
        Self: Sized,
    {
        let mut byte = [0_u8];
        reader.read_exact(&mut byte)?;
        Ok(byte[0] != 0)
    }
}

// ~ Decode tuple

impl_decode_tuples!(A);
impl_decode_tuples!(A, B);
impl_decode_tuples!(A, B, C);
impl_decode_tuples!(A, B, C, D);
impl_decode_tuples!(A, B, C, D, E);
impl_decode_tuples!(A, B, C, D, E, F);
impl_decode_tuples!(A, B, C, D, E, F, G);
impl_decode_tuples!(A, B, C, D, E, F, G, H);
impl_decode_tuples!(A, B, C, D, E, F, G, H, I);
impl_decode_tuples!(A, B, C, D, E, F, G, H, I, J);
impl_decode_tuples!(A, B, C, D, E, F, G, H, I, J, K);
impl_decode_tuples!(A, B, C, D, E, F, G, H, I, J, K, L);
impl_decode_tuples!(A, B, C, D, E, F, G, H, I, J, K, L, M);
impl_decode_tuples!(A, B, C, D, E, F, G, H, I, J, K, L, M, N);
impl_decode_tuples!(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O);
impl_decode_tuples!(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P);
impl_decode_tuples!(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q);

// ~ Decode pointer

impl<Data, T> Decode<Data> for std::sync::Arc<T>
where
    T: Decode<Data>,
{
    fn decode(reader: &mut dyn Read, ctx: &Context<Data>) -> Result<Self> {
        T::decode(reader, ctx).map(Arc::new)
    }
}

impl<Data, T> Decode<Data> for Arc<[T]>
where
    T: Decode<Data>,
{
    fn decode(reader: &mut dyn Read, ctx: &Context<Data>) -> Result<Self>
    where
        Self: Sized,
    {
        let slice = T::decode_slice(reader, ctx)?;
        Ok(slice.into())
    }
}