use serde::Serialize;

use super::macros::to_wasm;
use super::standard_properties::WasmStandardProperties;
use super::to_wasm::ToWasm;
use super::AdditionalProperties;
#[cfg(feature = "wasm_test")]
use crate::compare::ElispFact;
use crate::types::GetAffiliatedKeywords;
use crate::types::Paragraph;
use crate::wasm::to_wasm::ToWasmStandardProperties;
use crate::wasm::WasmAstNode;

#[derive(Debug, Serialize)]
#[serde(tag = "ast_node")]
#[serde(rename = "paragraph")]
pub struct WasmParagraph<'s, 'p> {
    pub(crate) standard_properties: WasmStandardProperties,
    pub(crate) additional_properties: AdditionalProperties<'s, 'p>,
    pub(crate) children: Vec<WasmAstNode<'s, 'p>>,
}

to_wasm!(
    WasmParagraph<'s, 'p>,
    Paragraph<'s>,
    original,
    wasm_context,
    standard_properties,
    {
        let additional_properties = original
            .get_affiliated_keywords()
            .to_wasm(wasm_context.clone())?;

        let children = original
            .children
            .iter()
            .map(|child| {
                child
                    .to_wasm(wasm_context.clone())
                    .map(Into::<WasmAstNode<'_, '_>>::into)
            })
            .collect::<Result<Vec<_>, _>>()?;

        Ok(WasmParagraph {
            standard_properties,
            additional_properties,
            children,
        })
    }
);

impl<'s, 'p> Into<WasmAstNode<'s, 'p>> for WasmParagraph<'s, 'p> {
    fn into(self) -> WasmAstNode<'s, 'p> {
        WasmAstNode::Paragraph(self)
    }
}

#[cfg(feature = "wasm_test")]
impl<'s, 'p> ElispFact<'s> for WasmParagraph<'s, 'p> {
    fn get_elisp_name<'b>(&'b self) -> std::borrow::Cow<'s, str> {
        "paragraph".into()
    }
}