hpl-toolkit 0.0.5

use std::ops::{Index, IndexMut};

use super::Inner;
use anchor_lang::prelude::*;

#[cfg(feature = "compression")]
use crate::compression::*;

#[cfg(feature = "schema")]
use crate::schema::*;

#[cfg_attr(feature = "debug", derive(Debug))]
#[derive(Clone, Eq, PartialEq)]
pub struct ShortVec<T: Inner>(Vec<T>);

impl<T: Inner> ShortVec<T> {
    pub fn new() -> Self {
        Self(Vec::new())
    }

    pub fn new_from_vec(vec: Vec<T>) -> std::io::Result<Self> {
        if vec.len() > 255 {
            return Err(std::io::Error::new(
                std::io::ErrorKind::InvalidInput,
                "Short string length shall not exceed 255",
            ));
        }
        Ok(Self(vec))
    }

    pub fn new_from_vec_unchecked(vec: Vec<T>) -> Self {
        Self::new_from_vec(vec).expect("Short Vec length shall not exceed 255")
    }

    pub unsafe fn new_from_vec_unsafe(vec: Vec<T>) -> Self {
        Self::new_from_vec_unchecked(vec)
    }

    pub fn inner(&self) -> &Vec<T> {
        &self.0
    }

    pub fn inner_mut(&mut self) -> &mut Vec<T> {
        &mut self.0
    }

    pub fn as_vec(&self) -> Vec<T> {
        self.0.clone()
    }

    pub fn as_slice(&self) -> &[T] {
        self.0.as_slice()
    }

    pub fn into_vec(self) -> Vec<T> {
        self.0
    }

    pub fn push(&mut self, item: T) {
        self.0.push(item)
    }

    pub fn pop(&mut self) -> Option<T> {
        self.0.pop()
    }

    pub fn remove(&mut self, index: usize) -> T {
        self.0.remove(index)
    }

    pub fn len(&self) -> usize {
        self.0.len()
    }
}

impl<T: Inner + PartialEq> ShortVec<T> {
    pub fn contains(&self, item: &T) -> bool {
        self.0.contains(item)
    }
}

impl<T: Inner> Into<Vec<T>> for ShortVec<T> {
    fn into(self) -> Vec<T> {
        self.0
    }
}

impl<T: Inner> From<Vec<T>> for ShortVec<T> {
    fn from(value: Vec<T>) -> Self {
        Self::new_from_vec_unchecked(value)
    }
}

impl<T: Inner> From<&Vec<T>> for ShortVec<T> {
    fn from(value: &Vec<T>) -> Self {
        Self::new_from_vec_unchecked(value.to_vec())
    }
}

impl<T: Inner + PartialEq> PartialEq<Vec<T>> for ShortVec<T> {
    fn eq(&self, other: &Vec<T>) -> bool {
        self.0 == *other
    }
}

impl<T: Inner> AnchorSerialize for ShortVec<T> {
    fn serialize<W: std::io::Write>(&self, writer: &mut W) -> std::io::Result<()> {
        let length = self.0.len() as u8;
        length.serialize(writer)?;
        self.0.iter().try_for_each(|item| item.serialize(writer))?;
        Ok(())
    }
}

impl<T: Inner> AnchorDeserialize for ShortVec<T> {
    fn deserialize_reader<R: std::io::Read>(reader: &mut R) -> std::io::Result<Self> {
        let mut buf: [u8; 1] = [0; 1];
        let limit = reader.read(&mut buf)?;
        if limit != 1 {
            #[cfg(feature = "log")]
            crate::logger::debug!("limit: {}, Buf: {:?}", limit, buf);
            return Err(std::io::Error::new(
                std::io::ErrorKind::InvalidInput,
                "Unexpected length of input",
            ));
        }

        let mut vec = Vec::<T>::new();

        for _ in 0..buf[0] {
            vec.push(T::deserialize_reader(reader)?);
        }

        Ok(Self(vec))
    }
}

#[cfg(feature = "idl-build")]
impl<T: Inner> anchor_lang::IdlBuild for ShortVec<T> {
    /// Returns the full module path of the type.
    fn get_full_path() -> String {
        format!("{0}::{1}", "hpl_toolkit::utils::short_vec", "ShortVec",)
    }
}

#[cfg(feature = "compression")]
impl<T: Inner + ToNode> ToNode for ShortVec<T> {
    fn to_node(&self) -> [u8; 32] {
        self.0.to_node()
    }
}

#[cfg(feature = "schema")]
impl<T: Inner + ToNode + ToSchema> ToSchema for ShortVec<T> {
    fn schema() -> Schema {
        Vec::<T>::schema()
    }

    fn schema_value(&self) -> SchemaValue {
        self.0.schema_value()
    }
}

pub struct ShortVecIter<T: Inner>(std::vec::IntoIter<T>);

impl<T: Inner> Iterator for ShortVecIter<T> {
    type Item = T;

    fn next(&mut self) -> Option<Self::Item> {
        self.0.next()
    }
}

impl<T: Inner> FromIterator<T> for ShortVec<T> {
    fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
        let mut short_vec: ShortVec<T> = ShortVec::new_from_vec_unchecked(vec![]);
        for t in iter {
            short_vec.0.push(t);
        }
        short_vec
    }
}

impl<T: Inner> IntoIterator for ShortVec<T> {
    type Item = T;
    type IntoIter = ShortVecIter<T>;

    fn into_iter(self) -> Self::IntoIter {
        ShortVecIter(self.0.into_iter())
    }
}

impl<T: Inner> Index<usize> for ShortVec<T> {
    type Output = T;
    fn index(&self, i: usize) -> &T {
        &self.0[i]
    }
}

impl<T: Inner> IndexMut<usize> for ShortVec<T> {
    fn index_mut(&mut self, i: usize) -> &mut T {
        &mut self.0[i]
    }
}