sbor 1.3.1

use crate::rust::collections::*;
use crate::rust::hash::Hash;
use crate::rust::ptr::copy;
use crate::rust::vec::Vec;
use crate::value_kind::*;
use crate::*;

categorize_generic!(Vec<T>, <T>, ValueKind::Array);
categorize_generic!(BTreeSet<T>, <T>, ValueKind::Array);
categorize_generic!(HashSet<T>, <T>, ValueKind::Array);
categorize_generic!(IndexSet<T>, <T>, ValueKind::Array);

categorize_generic!(BTreeMap<K, V>, <K, V>, ValueKind::Map);
categorize_generic!(HashMap<K, V>, <K, V>, ValueKind::Map);
categorize_generic!(IndexMap<K, V>, <K, V>, ValueKind::Map);

impl<X: CustomValueKind, E: Encoder<X>, T: Encode<X, E> + Categorize<X>> Encode<X, E> for Vec<T> {
    #[inline]
    fn encode_value_kind(&self, encoder: &mut E) -> Result<(), EncodeError> {
        encoder.write_value_kind(Self::value_kind())
    }

    #[inline]
    fn encode_body(&self, encoder: &mut E) -> Result<(), EncodeError> {
        self.as_slice().encode_body(encoder)?;
        Ok(())
    }
}

impl<X: CustomValueKind, E: Encoder<X>, T: Encode<X, E> + Categorize<X>> Encode<X, E>
    for BTreeSet<T>
{
    #[inline]
    fn encode_value_kind(&self, encoder: &mut E) -> Result<(), EncodeError> {
        encoder.write_value_kind(Self::value_kind())
    }

    #[inline]
    fn encode_body(&self, encoder: &mut E) -> Result<(), EncodeError> {
        encoder.write_value_kind(T::value_kind())?;
        encoder.write_size(self.len())?;
        for v in self {
            encoder.encode_deeper_body(v)?;
        }
        Ok(())
    }
}

impl<X: CustomValueKind, E: Encoder<X>, T: Encode<X, E> + Categorize<X> + Ord + Hash> Encode<X, E>
    for HashSet<T>
{
    #[inline]
    fn encode_value_kind(&self, encoder: &mut E) -> Result<(), EncodeError> {
        encoder.write_value_kind(Self::value_kind())
    }

    #[inline]
    fn encode_body(&self, encoder: &mut E) -> Result<(), EncodeError> {
        encoder.write_value_kind(T::value_kind())?;
        encoder.write_size(self.len())?;
        let set: BTreeSet<&T> = self.iter().collect();
        for v in set {
            encoder.encode_deeper_body(v)?;
        }
        Ok(())
    }
}

impl<X: CustomValueKind, E: Encoder<X>, T: Encode<X, E> + Categorize<X> + Hash> Encode<X, E>
    for IndexSet<T>
{
    #[inline]
    fn encode_value_kind(&self, encoder: &mut E) -> Result<(), EncodeError> {
        encoder.write_value_kind(Self::value_kind())
    }

    #[inline]
    fn encode_body(&self, encoder: &mut E) -> Result<(), EncodeError> {
        encoder.write_value_kind(T::value_kind())?;
        encoder.write_size(self.len())?;
        for v in self {
            encoder.encode_deeper_body(v)?;
        }
        Ok(())
    }
}

impl<
        X: CustomValueKind,
        E: Encoder<X>,
        K: Encode<X, E> + Categorize<X>,
        V: Encode<X, E> + Categorize<X>,
    > Encode<X, E> for BTreeMap<K, V>
{
    #[inline]
    fn encode_value_kind(&self, encoder: &mut E) -> Result<(), EncodeError> {
        encoder.write_value_kind(Self::value_kind())
    }

    #[inline]
    fn encode_body(&self, encoder: &mut E) -> Result<(), EncodeError> {
        encoder.write_value_kind(K::value_kind())?;
        encoder.write_value_kind(V::value_kind())?;
        encoder.write_size(self.len())?;
        for (k, v) in self {
            encoder.encode_deeper_body(k)?;
            encoder.encode_deeper_body(v)?;
        }
        Ok(())
    }
}

impl<
        X: CustomValueKind,
        E: Encoder<X>,
        K: Encode<X, E> + Categorize<X> + Ord + Hash,
        V: Encode<X, E> + Categorize<X>,
    > Encode<X, E> for HashMap<K, V>
{
    #[inline]
    fn encode_value_kind(&self, encoder: &mut E) -> Result<(), EncodeError> {
        encoder.write_value_kind(Self::value_kind())
    }

    #[inline]
    fn encode_body(&self, encoder: &mut E) -> Result<(), EncodeError> {
        encoder.write_value_kind(K::value_kind())?;
        encoder.write_value_kind(V::value_kind())?;
        encoder.write_size(self.len())?;
        let mut keys: Vec<&K> = self.keys().collect();
        keys.sort();
        for key in keys {
            encoder.encode_deeper_body(key)?;
            encoder.encode_deeper_body(self.get(key).unwrap())?;
        }
        Ok(())
    }
}

impl<
        X: CustomValueKind,
        E: Encoder<X>,
        K: Encode<X, E> + Categorize<X> + Hash + Eq + PartialEq,
        V: Encode<X, E> + Categorize<X>,
    > Encode<X, E> for IndexMap<K, V>
{
    #[inline]
    fn encode_value_kind(&self, encoder: &mut E) -> Result<(), EncodeError> {
        encoder.write_value_kind(Self::value_kind())
    }

    #[inline]
    fn encode_body(&self, encoder: &mut E) -> Result<(), EncodeError> {
        encoder.write_value_kind(K::value_kind())?;
        encoder.write_value_kind(V::value_kind())?;
        encoder.write_size(self.len())?;
        for (key, value) in self.iter() {
            encoder.encode_deeper_body(key)?;
            encoder.encode_deeper_body(value)?;
        }
        Ok(())
    }
}

impl<X: CustomValueKind, D: Decoder<X>, T: Decode<X, D> + Categorize<X>> Decode<X, D> for Vec<T> {
    #[inline]
    fn decode_body_with_value_kind(
        decoder: &mut D,
        value_kind: ValueKind<X>,
    ) -> Result<Self, DecodeError> {
        decoder.check_preloaded_value_kind(value_kind, Self::value_kind())?;
        let element_value_kind = decoder.read_and_check_value_kind(T::value_kind())?;
        let len = decoder.read_size()?;

        if T::value_kind() == ValueKind::U8 || T::value_kind() == ValueKind::I8 {
            let slice = decoder.read_slice(len)?; // length is checked here
            let mut result = Vec::<T>::with_capacity(len);
            unsafe {
                copy(slice.as_ptr(), result.as_mut_ptr() as *mut u8, slice.len());
                result.set_len(slice.len());
            }
            Ok(result)
        } else {
            let mut result = Vec::<T>::with_capacity(if len <= 1024 { len } else { 1024 });
            for _ in 0..len {
                result.push(decoder.decode_deeper_body_with_value_kind(element_value_kind)?);
            }
            Ok(result)
        }
    }
}

impl<X: CustomValueKind, D: Decoder<X>, T: Decode<X, D> + Categorize<X> + Ord> Decode<X, D>
    for BTreeSet<T>
{
    #[inline]
    fn decode_body_with_value_kind(
        decoder: &mut D,
        value_kind: ValueKind<X>,
    ) -> Result<Self, DecodeError> {
        decoder.check_preloaded_value_kind(value_kind, Self::value_kind())?;
        let element_value_kind = decoder.read_and_check_value_kind(T::value_kind())?;
        let len = decoder.read_size()?;
        let mut result = BTreeSet::new();
        for _ in 0..len {
            if !result.insert(decoder.decode_deeper_body_with_value_kind(element_value_kind)?) {
                return Err(DecodeError::DuplicateKey);
            }
        }
        Ok(result)
    }
}

impl<X: CustomValueKind, D: Decoder<X>, T: Decode<X, D> + Categorize<X> + Hash + Eq> Decode<X, D>
    for HashSet<T>
{
    #[inline]
    fn decode_body_with_value_kind(
        decoder: &mut D,
        value_kind: ValueKind<X>,
    ) -> Result<Self, DecodeError> {
        decoder.check_preloaded_value_kind(value_kind, Self::value_kind())?;
        let element_value_kind = decoder.read_and_check_value_kind(T::value_kind())?;
        let len = decoder.read_size()?;
        let mut result = hash_set_with_capacity(if len <= 1024 { len } else { 1024 });
        for _ in 0..len {
            if !result.insert(decoder.decode_deeper_body_with_value_kind(element_value_kind)?) {
                return Err(DecodeError::DuplicateKey);
            }
        }
        Ok(result)
    }
}

impl<X: CustomValueKind, D: Decoder<X>, T: Decode<X, D> + Categorize<X> + Hash + Eq> Decode<X, D>
    for IndexSet<T>
{
    #[inline]
    fn decode_body_with_value_kind(
        decoder: &mut D,
        value_kind: ValueKind<X>,
    ) -> Result<Self, DecodeError> {
        decoder.check_preloaded_value_kind(value_kind, Self::value_kind())?;
        let element_value_kind = decoder.read_and_check_value_kind(T::value_kind())?;
        let len = decoder.read_size()?;
        let mut result = index_set_with_capacity(if len <= 1024 { len } else { 1024 });
        for _ in 0..len {
            if !result.insert(decoder.decode_deeper_body_with_value_kind(element_value_kind)?) {
                return Err(DecodeError::DuplicateKey);
            }
        }
        Ok(result)
    }
}

impl<
        X: CustomValueKind,
        D: Decoder<X>,
        K: Decode<X, D> + Categorize<X> + Ord,
        V: Decode<X, D> + Categorize<X>,
    > Decode<X, D> for BTreeMap<K, V>
{
    #[inline]
    fn decode_body_with_value_kind(
        decoder: &mut D,
        value_kind: ValueKind<X>,
    ) -> Result<Self, DecodeError> {
        decoder.check_preloaded_value_kind(value_kind, Self::value_kind())?;
        let key_value_kind = decoder.read_and_check_value_kind(K::value_kind())?;
        let value_value_kind = decoder.read_and_check_value_kind(V::value_kind())?;
        let len = decoder.read_size()?;
        let mut result = BTreeMap::new();
        for _ in 0..len {
            if result
                .insert(
                    decoder.decode_deeper_body_with_value_kind(key_value_kind)?,
                    decoder.decode_deeper_body_with_value_kind(value_value_kind)?,
                )
                .is_some()
            {
                return Err(DecodeError::DuplicateKey);
            }
        }
        Ok(result)
    }
}

impl<
        X: CustomValueKind,
        D: Decoder<X>,
        K: Decode<X, D> + Categorize<X> + Hash + Eq,
        V: Decode<X, D> + Categorize<X>,
    > Decode<X, D> for HashMap<K, V>
{
    #[inline]
    fn decode_body_with_value_kind(
        decoder: &mut D,
        value_kind: ValueKind<X>,
    ) -> Result<Self, DecodeError> {
        decoder.check_preloaded_value_kind(value_kind, Self::value_kind())?;
        let key_value_kind = decoder.read_and_check_value_kind(K::value_kind())?;
        let value_value_kind = decoder.read_and_check_value_kind(V::value_kind())?;
        let len = decoder.read_size()?;
        let mut result = hash_map_with_capacity(if len <= 1024 { len } else { 1024 });
        for _ in 0..len {
            if result
                .insert(
                    decoder.decode_deeper_body_with_value_kind(key_value_kind)?,
                    decoder.decode_deeper_body_with_value_kind(value_value_kind)?,
                )
                .is_some()
            {
                return Err(DecodeError::DuplicateKey);
            }
        }
        Ok(result)
    }
}

impl<
        X: CustomValueKind,
        D: Decoder<X>,
        K: Decode<X, D> + Categorize<X> + Hash + Eq,
        V: Decode<X, D> + Categorize<X>,
    > Decode<X, D> for IndexMap<K, V>
{
    #[inline]
    fn decode_body_with_value_kind(
        decoder: &mut D,
        value_kind: ValueKind<X>,
    ) -> Result<Self, DecodeError> {
        decoder.check_preloaded_value_kind(value_kind, Self::value_kind())?;
        let key_value_kind = decoder.read_and_check_value_kind(K::value_kind())?;
        let value_value_kind = decoder.read_and_check_value_kind(V::value_kind())?;
        let len = decoder.read_size()?;
        let mut result = index_map_with_capacity(if len <= 1024 { len } else { 1024 });
        for _ in 0..len {
            if result
                .insert(
                    decoder.decode_deeper_body_with_value_kind(key_value_kind)?,
                    decoder.decode_deeper_body_with_value_kind(value_value_kind)?,
                )
                .is_some()
            {
                return Err(DecodeError::DuplicateKey);
            }
        }
        Ok(result)
    }
}

wrapped_generic_describe!(T, Vec<T>, [T]);

impl<C: CustomTypeKind<RustTypeId>, T: Describe<C>> Describe<C> for BTreeSet<T> {
    const TYPE_ID: RustTypeId = RustTypeId::novel("Set", &[T::TYPE_ID]);

    fn type_data() -> TypeData<C, RustTypeId> {
        TypeData::new(
            TypeKind::Array {
                element_type: T::TYPE_ID,
            },
            TypeMetadata::unnamed(),
        )
    }

    fn add_all_dependencies(aggregator: &mut TypeAggregator<C>) {
        aggregator.add_child_type_and_descendents::<T>();
    }
}

wrapped_generic_describe!(T, HashSet<T>, BTreeSet<T>);
wrapped_generic_describe!(T, IndexSet<T>, BTreeSet<T>);

impl<C: CustomTypeKind<RustTypeId>, K: Describe<C>, V: Describe<C>> Describe<C> for BTreeMap<K, V> {
    const TYPE_ID: RustTypeId = RustTypeId::novel("Map", &[K::TYPE_ID, V::TYPE_ID]);

    fn type_data() -> TypeData<C, RustTypeId> {
        TypeData::new(
            TypeKind::Map {
                key_type: K::TYPE_ID,
                value_type: V::TYPE_ID,
            },
            TypeMetadata::unnamed(),
        )
    }

    fn add_all_dependencies(aggregator: &mut TypeAggregator<C>) {
        aggregator.add_child_type_and_descendents::<K>();
        aggregator.add_child_type_and_descendents::<V>();
    }
}

wrapped_double_generic_describe!(K, V, HashMap<K, V>, BTreeMap<K, V>);
wrapped_double_generic_describe!(K, V, IndexMap<K, V>, BTreeMap<K, V>);