//! Reference entry description.
use crate::xml::element::{Elements, FromElements};

mod part;

pub use part::{Error as PartError, Part};

/// Reference entry description.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Description
{
    for_function: Option<String>,
    parts: Vec<Part>,
}

impl Description
{
    /// Returns a new empty `Description`.
    #[must_use]
    pub fn new() -> Self
    {
        Self {
            for_function: None,
            parts: Vec::new(),
        }
    }

    /// Returns what function this description is specific for.
    #[must_use]
    pub fn for_function(&self) -> &Option<String>
    {
        &self.for_function
    }

    /// Returns the description's parts.
    #[must_use]
    pub fn parts(&self) -> &[Part]
    {
        &self.parts
    }
}

impl Default for Description
{
    fn default() -> Self
    {
        Self::new()
    }
}

impl FromElements for Description
{
    type Error = Error;

    fn from_elements(elements: &Elements) -> Result<Self, Self::Error>
    {
        let for_function =
            elements
                .get_first_tagged_with_name("title")
                .and_then(|title_element| {
                    let title_text =
                        title_element.child_elements().get_first_text_element()?;

                    if title_text != "Description for " {
                        return None;
                    }

                    let function_element = title_element
                        .child_elements()
                        .get_first_tagged_with_name("function")?;

                    function_element
                        .child_elements()
                        .get_first_text_element()
                        .cloned()
                });

        let parts = elements
            .get_all_tagged_elements()
            .into_iter()
            .map(Part::from_tagged_element)
            .collect::<Result<Vec<_>, _>>()?;

        Ok(Description {
            for_function,
            parts,
        })
    }
}

/// [`Description`] error.
#[derive(Debug, thiserror::Error)]
pub enum Error
{
    /// Invalid description part.
    #[error("Invalid description part")]
    InvalidPart(#[from] PartError),
}