use crate::*;
use alloc::borrow::Cow;
use alloc::vec::Vec;
use core::convert::TryFrom;

mod btreeset;
mod hashset;
mod iterator;
mod set_of;

pub use btreeset::*;
#[cfg(feature = "std")]
pub use hashset::*;
pub use iterator::*;
pub use set_of::*;

/// The `SET` object is an unordered list of heteregeneous types.
///
/// Sets can usually be of 2 types:
/// - a list of different objects (`SET`, usually parsed as a `struct`)
/// - a list of similar objects (`SET OF`, usually parsed as a `BTreeSet<T>` or `HashSet<T>`)
///
/// The current object covers the former. For the latter, see the [`SetOf`] documentation.
///
/// The `Set` object contains the (*unparsed*) encoded representation of its content. It provides
/// methods to parse and iterate contained objects, or convert the sequence to other types.
///
/// # Building a Set
///
/// To build a DER set:
/// - if the set is composed of objects of the same type, the [`Set::from_iter_to_der`] method can be used
/// - otherwise, the [`ToDer`] trait can be used to create content incrementally
///
/// ```
/// use asn1_rs::{Integer, Set, SerializeResult, ToDer};
///
/// fn build_set<'a>() -> SerializeResult<Set<'a>> {
///     let mut v = Vec::new();
///     // add an Integer object (construct type):
///     let i = Integer::from_u32(4);
///     let _ = i.write_der(&mut v)?;
///     // some primitive objects also implement `ToDer`. A string will be mapped as `Utf8String`:
///     let _ = "abcd".write_der(&mut v)?;
///     // return the set built from the DER content
///     Ok(Set::new(v.into()))
/// }
///
/// let seq = build_set().unwrap();
///
/// ```
///
/// # Examples
///
/// ```
/// use asn1_rs::{Error, Set};
///
/// // build set
/// let it = [2, 3, 4].iter();
/// let set = Set::from_iter_to_der(it).unwrap();
///
/// // `set` now contains the serialized DER representation of the array
///
/// // iterate objects
/// let mut sum = 0;
/// for item in set.der_iter::<u32, Error>() {
///     // item has type `Result<u32>`, since parsing the serialized bytes could fail
///     sum += item.expect("parsing list item failed");
/// }
/// assert_eq!(sum, 9);
///
/// ```
///
/// Note: the above example encodes a `SET OF INTEGER` object, the [`SetOf`] object could
/// be used to provide a simpler API.
///
#[derive(Clone, Debug)]
pub struct Set<'a> {
    /// Serialized DER representation of the set content
    pub content: Cow<'a, [u8]>,
}

impl<'a> Set<'a> {
    /// Build a set, given the provided content
    pub const fn new(content: Cow<'a, [u8]>) -> Self {
        Set { content }
    }

    /// Consume the set and return the content
    #[inline]
    pub fn into_content(self) -> Cow<'a, [u8]> {
        self.content
    }

    /// Apply the parsing function to the set content, consuming the set
    ///
    /// Note: this function expects the caller to take ownership of content.
    /// In some cases, handling the lifetime of objects is not easy (when keeping only references on
    /// data). Other methods are provided (depending on the use case):
    /// - [`Set::parse`] takes a reference on the set data, but does not consume it,
    /// - [`Set::from_der_and_then`] does the parsing of the set and applying the function
    ///   in one step, ensuring there are only references (and dropping the temporary set).
    pub fn and_then<U, F, E>(self, op: F) -> ParseResult<'a, U, E>
    where
        F: FnOnce(Cow<'a, [u8]>) -> ParseResult<U, E>,
    {
        op(self.content)
    }

    /// Same as [`Set::from_der_and_then`], but using BER encoding (no constraints).
    pub fn from_ber_and_then<U, F, E>(bytes: &'a [u8], op: F) -> ParseResult<'a, U, E>
    where
        F: FnOnce(&'a [u8]) -> ParseResult<U, E>,
        E: From<Error>,
    {
        let (rem, seq) = Set::from_ber(bytes).map_err(Err::convert)?;
        let data = match seq.content {
            Cow::Borrowed(b) => b,
            // Since 'any' is built from 'bytes', it is borrowed by construction
            Cow::Owned(_) => unreachable!(),
        };
        let (_, res) = op(data)?;
        Ok((rem, res))
    }

    /// Parse a DER set and apply the provided parsing function to content
    ///
    /// After parsing, the set object and header are discarded.
    ///
    /// ```
    /// use asn1_rs::{FromDer, ParseResult, Set};
    ///
    /// // Parse a SET {
    /// //      a INTEGER (0..255),
    /// //      b INTEGER (0..4294967296)
    /// // }
    /// // and return only `(a,b)
    /// fn parser(i: &[u8]) -> ParseResult<(u8, u32)> {
    ///     Set::from_der_and_then(i, |i| {
    ///             let (i, a) = u8::from_der(i)?;
    ///             let (i, b) = u32::from_der(i)?;
    ///             Ok((i, (a, b)))
    ///         }
    ///     )
    /// }
    /// ```
    pub fn from_der_and_then<U, F, E>(bytes: &'a [u8], op: F) -> ParseResult<'a, U, E>
    where
        F: FnOnce(&'a [u8]) -> ParseResult<U, E>,
        E: From<Error>,
    {
        let (rem, seq) = Set::from_der(bytes).map_err(Err::convert)?;
        let data = match seq.content {
            Cow::Borrowed(b) => b,
            // Since 'any' is built from 'bytes', it is borrowed by construction
            Cow::Owned(_) => unreachable!(),
        };
        let (_, res) = op(data)?;
        Ok((rem, res))
    }

    /// Apply the parsing function to the set content (non-consuming version)
    pub fn parse<F, T, E>(&'a self, mut f: F) -> ParseResult<'a, T, E>
    where
        F: FnMut(&'a [u8]) -> ParseResult<'a, T, E>,
    {
        let input: &[u8] = &self.content;
        f(input)
    }

    /// Apply the parsing function to the set content (consuming version)
    ///
    /// Note: to parse and apply a parsing function in one step, use the
    /// [`Set::from_der_and_then`] method.
    ///
    /// # Limitations
    ///
    /// This function fails if the set contains `Owned` data, because the parsing function
    /// takes a reference on data (which is dropped).
    pub fn parse_into<F, T, E>(self, mut f: F) -> ParseResult<'a, T, E>
    where
        F: FnMut(&'a [u8]) -> ParseResult<'a, T, E>,
        E: From<Error>,
    {
        match self.content {
            Cow::Borrowed(b) => f(b),
            _ => Err(nom::Err::Error(Error::LifetimeError.into())),
        }
    }

    /// Return an iterator over the set content, attempting to decode objects as BER
    ///
    /// This method can be used when all objects from the set have the same type.
    pub fn ber_iter<T, E>(&'a self) -> SetIterator<'a, T, BerParser, E>
    where
        T: FromBer<'a, E>,
    {
        SetIterator::new(&self.content)
    }

    /// Return an iterator over the set content, attempting to decode objects as DER
    ///
    /// This method can be used when all objects from the set have the same type.
    pub fn der_iter<T, E>(&'a self) -> SetIterator<'a, T, DerParser, E>
    where
        T: FromDer<'a, E>,
    {
        SetIterator::new(&self.content)
    }

    /// Attempt to parse the set as a `SET OF` items (BER), and return the parsed items as a `Vec`.
    pub fn ber_set_of<T, E>(&'a self) -> Result<Vec<T>, E>
    where
        T: FromBer<'a, E>,
        E: From<Error>,
    {
        self.ber_iter().collect()
    }

    /// Attempt to parse the set as a `SET OF` items (DER), and return the parsed items as a `Vec`.
    pub fn der_set_of<T, E>(&'a self) -> Result<Vec<T>, E>
    where
        T: FromDer<'a, E>,
        E: From<Error>,
    {
        self.der_iter().collect()
    }

    /// Attempt to parse the set as a `SET OF` items (BER) (consuming input),
    /// and return the parsed items as a `Vec`.
    ///
    /// Note: if `Self` is an `Owned` object, the data will be duplicated (causing allocations) into separate objects.
    pub fn into_ber_set_of<T, E>(self) -> Result<Vec<T>, E>
    where
        for<'b> T: FromBer<'b, E>,
        E: From<Error>,
        T: ToStatic<Owned = T>,
    {
        match self.content {
            Cow::Borrowed(bytes) => SetIterator::<T, BerParser, E>::new(bytes).collect(),
            Cow::Owned(data) => {
                let v1 =
                    SetIterator::<T, BerParser, E>::new(&data).collect::<Result<Vec<T>, E>>()?;
                let v2 = v1.iter().map(|t| t.to_static()).collect::<Vec<_>>();
                Ok(v2)
            }
        }
    }

    /// Attempt to parse the set as a `SET OF` items (DER) (consuming input),
    /// and return the parsed items as a `Vec`.
    ///
    /// Note: if `Self` is an `Owned` object, the data will be duplicated (causing allocations) into separate objects.
    pub fn into_der_set_of<T, E>(self) -> Result<Vec<T>, E>
    where
        for<'b> T: FromDer<'b, E>,
        E: From<Error>,
        T: ToStatic<Owned = T>,
    {
        match self.content {
            Cow::Borrowed(bytes) => SetIterator::<T, DerParser, E>::new(bytes).collect(),
            Cow::Owned(data) => {
                let v1 =
                    SetIterator::<T, DerParser, E>::new(&data).collect::<Result<Vec<T>, E>>()?;
                let v2 = v1.iter().map(|t| t.to_static()).collect::<Vec<_>>();
                Ok(v2)
            }
        }
    }

    pub fn into_der_set_of_ref<T, E>(self) -> Result<Vec<T>, E>
    where
        T: FromDer<'a, E>,
        E: From<Error>,
    {
        match self.content {
            Cow::Borrowed(bytes) => SetIterator::<T, DerParser, E>::new(bytes).collect(),
            Cow::Owned(_) => Err(Error::LifetimeError.into()),
        }
    }
}

impl<'a> ToStatic for Set<'a> {
    type Owned = Set<'static>;

    fn to_static(&self) -> Self::Owned {
        Set {
            content: Cow::Owned(self.content.to_vec()),
        }
    }
}

impl<'a> AsRef<[u8]> for Set<'a> {
    fn as_ref(&self) -> &[u8] {
        &self.content
    }
}

impl<'a> TryFrom<Any<'a>> for Set<'a> {
    type Error = Error;

    fn try_from(any: Any<'a>) -> Result<Set<'a>> {
        TryFrom::try_from(&any)
    }
}

impl<'a, 'b> TryFrom<&'b Any<'a>> for Set<'a> {
    type Error = Error;

    fn try_from(any: &'b Any<'a>) -> Result<Set<'a>> {
        any.tag().assert_eq(Self::TAG)?;
        any.header.assert_constructed()?;
        Ok(Set {
            content: Cow::Borrowed(any.data),
        })
    }
}

impl<'a> CheckDerConstraints for Set<'a> {
    fn check_constraints(_any: &Any) -> Result<()> {
        Ok(())
    }
}

impl<'a> DerAutoDerive for Set<'a> {}

impl<'a> Tagged for Set<'a> {
    const TAG: Tag = Tag::Set;
}

#[cfg(feature = "std")]
impl ToDer for Set<'_> {
    fn to_der_len(&self) -> Result<usize> {
        let sz = self.content.len();
        if sz < 127 {
            // 1 (class+tag) + 1 (length) + len
            Ok(2 + sz)
        } else {
            // 1 (class+tag) + n (length) + len
            let n = Length::Definite(sz).to_der_len()?;
            Ok(1 + n + sz)
        }
    }

    fn write_der_header(&self, writer: &mut dyn std::io::Write) -> SerializeResult<usize> {
        let header = Header::new(
            Class::Universal,
            true,
            Self::TAG,
            Length::Definite(self.content.len()),
        );
        header.write_der_header(writer).map_err(Into::into)
    }

    fn write_der_content(&self, writer: &mut dyn std::io::Write) -> SerializeResult<usize> {
        writer.write(&self.content).map_err(Into::into)
    }
}

#[cfg(feature = "std")]
impl<'a> Set<'a> {
    /// Attempt to create a `Set` from an iterator over serializable objects (to DER)
    ///
    /// # Examples
    ///
    /// ```
    /// use asn1_rs::Set;
    ///
    /// // build set
    /// let it = [2, 3, 4].iter();
    /// let seq = Set::from_iter_to_der(it).unwrap();
    /// ```
    pub fn from_iter_to_der<T, IT>(it: IT) -> SerializeResult<Self>
    where
        IT: Iterator<Item = T>,
        T: ToDer,
        T: Tagged,
    {
        let mut v = Vec::new();
        for item in it {
            let item_v = <T as ToDer>::to_der_vec(&item)?;
            v.extend_from_slice(&item_v);
        }
        Ok(Set {
            content: Cow::Owned(v),
        })
    }
}