use serde::de::{Error, SeqAccess, Visitor};
use serde::{Deserialize, Deserializer, Serialize, Serializer};

use crate::types::*;

impl<const LENGTH: usize> Serialize for StackByteArray<LENGTH> {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        serializer.serialize_bytes(self.as_slice())
    }
}

impl<'de, const LENGTH: usize> Deserialize<'de> for StackByteArray<LENGTH> {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        struct ByteArrayVisitor<const LENGTH: usize>;

        impl<'de, const LENGTH: usize> Visitor<'de> for ByteArrayVisitor<LENGTH> {
            type Value = StackByteArray<LENGTH>;

            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                write!(formatter, "bytes")
            }

            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
            where
                A: SeqAccess<'de>,
            {
                let mut arr = StackByteArray::<LENGTH>::new();
                let mut idx: usize = 0;

                while let Some(elem) = seq.next_element()? {
                    if idx < LENGTH {
                        arr[idx] = elem;
                        idx += 1;
                    } else {
                        break;
                    }
                }

                Ok(arr)
            }

            fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
            where
                E: Error,
            {
                if v.len() != LENGTH {
                    return Err(Error::invalid_length(v.len(), &stringify!(LENGTH)));
                }
                let mut arr = StackByteArray::<LENGTH>::new();
                arr.copy_from_slice(v);
                Ok(arr)
            }
        }

        deserializer.deserialize_bytes(ByteArrayVisitor::<LENGTH>)
    }
}

#[cfg(any(feature = "nightly", all(doc, not(doctest))))]
mod protected {
    use super::*;
    use crate::protected::*;

    impl<const LENGTH: usize> Serialize for HeapByteArray<LENGTH> {
        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
        where
            S: Serializer,
        {
            serializer.serialize_bytes(self.as_slice())
        }
    }

    impl<const LENGTH: usize> Serialize for Locked<HeapByteArray<LENGTH>> {
        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
        where
            S: Serializer,
        {
            serializer.serialize_bytes(self.as_slice())
        }
    }

    impl Serialize for HeapBytes {
        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
        where
            S: Serializer,
        {
            serializer.serialize_bytes(self.as_slice())
        }
    }

    impl Serialize for LockedBytes {
        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
        where
            S: Serializer,
        {
            serializer.serialize_bytes(self.as_slice())
        }
    }

    impl Serialize for LockedRO<HeapBytes> {
        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
        where
            S: Serializer,
        {
            serializer.serialize_bytes(self.as_slice())
        }
    }

    impl<'de> Deserialize<'de> for HeapBytes {
        fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
        where
            D: Deserializer<'de>,
        {
            struct BytesVisitor;

            impl<'de> Visitor<'de> for BytesVisitor {
                type Value = HeapBytes;

                fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                    write!(formatter, "bytes")
                }

                fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
                where
                    A: SeqAccess<'de>,
                {
                    let mut arr = HeapBytes::default();
                    let mut idx: usize = 0;
                    let size_hint = seq.size_hint().unwrap_or(1);
                    arr.resize(size_hint, 0);

                    while let Some(elem) = seq.next_element()? {
                        if idx > arr.len() {
                            arr.resize(idx, 0);
                        }
                        arr[idx] = elem;
                        idx += 1;
                    }

                    Ok(arr)
                }

                fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
                where
                    E: Error,
                {
                    Ok(HeapBytes::from(v))
                }
            }

            deserializer.deserialize_bytes(BytesVisitor)
        }
    }

    impl<'de> Deserialize<'de> for LockedBytes {
        fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
        where
            D: Deserializer<'de>,
        {
            struct BytesVisitor;

            impl<'de> Visitor<'de> for BytesVisitor {
                type Value = LockedBytes;

                fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                    write!(formatter, "bytes")
                }

                fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
                where
                    A: SeqAccess<'de>,
                {
                    let mut arr = HeapBytes::gen_locked().expect("couldn't create locked bytes");
                    let mut idx: usize = 0;
                    let size_hint = seq.size_hint().unwrap_or(1);
                    arr.resize(size_hint, 0);

                    while let Some(elem) = seq.next_element()? {
                        if idx > arr.len() {
                            arr.resize(idx, 0);
                        }
                        arr[idx] = elem;
                        idx += 1;
                    }

                    Ok(arr)
                }

                fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
                where
                    E: Error,
                {
                    Ok(HeapBytes::from_slice_into_locked(v)
                        .expect("couldn't copy slice into locked bytes"))
                }
            }

            deserializer.deserialize_bytes(BytesVisitor)
        }
    }

    impl<'de, const LENGTH: usize> Deserialize<'de> for Locked<HeapByteArray<LENGTH>> {
        fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
        where
            D: Deserializer<'de>,
        {
            struct BytesVisitor<const LENGTH: usize>;

            impl<'de, const LENGTH: usize> Visitor<'de> for BytesVisitor<LENGTH> {
                type Value = Locked<HeapByteArray<LENGTH>>;

                fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                    write!(formatter, "bytes")
                }

                fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
                where
                    A: SeqAccess<'de>,
                {
                    let mut arr = HeapByteArray::<LENGTH>::gen_locked()
                        .expect("couldn't create locked bytes");
                    let mut idx: usize = 0;
                    let size_hint = seq.size_hint().unwrap_or(0);
                    if size_hint != LENGTH {
                        Err(Error::invalid_length(size_hint, &stringify!(LENGTH)))
                    } else {
                        while let Some(elem) = seq.next_element()? {
                            arr[idx] = elem;
                            idx += 1;
                        }

                        Ok(arr)
                    }
                }

                fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
                where
                    E: Error,
                {
                    if v.len() != LENGTH {
                        Err(Error::invalid_length(v.len(), &stringify!(LENGTH)))
                    } else {
                        Ok(HeapByteArray::<LENGTH>::from_slice_into_locked(v)
                            .expect("couldn't copy slice into locked bytes"))
                    }
                }
            }

            deserializer.deserialize_bytes(BytesVisitor)
        }
    }
}

#[cfg(any(feature = "nightly", all(doc, not(doctest))))]
pub use protected::*;