use std::pin::Pin;
use std::collections::HashMap;
use std::future::Future;
use futures::future::join_all;

pub trait Component {
    fn render(self: Box<Self>) -> Vec<RenderNode>;
}

pub enum RenderNode {
    Suspense {
        fallback: Box<RenderNode>,
        children: Pin<Box<dyn Future<Output = Vec<RenderNode>>>>
    },
    Component(Box<dyn Component>),
    Element {
        name: String,
        attributes: HashMap<String, String>,
        children: Vec<RenderNode>
    },
    Fragment {
        children: Vec<RenderNode>
    },
    TextNode {
        content: String,
    },
    Null,
}

impl RenderNode {
    pub(crate) fn render_to_string(self) -> Pin<Box<dyn Future<Output = String>>> {
        match self {
            RenderNode::Component(component) => {
                let elements = component.render();
                Box::pin((async move || {
                    join_all(elements.into_iter()
                        .map(|child| child.render_to_string())
                        .collect::<Vec<_>>()).await.join("")
                })())
            },

            RenderNode::Suspense {fallback: _, children} => {
                Box::pin((async move || {
                    join_all(children.await.into_iter()
                        .map(|child| child.render_to_string())).await
                        .join("")
                })())
            },

            RenderNode::Element { name, attributes, children } => {
                let text_attributes = attributes.into_iter()
                    .map(|(key, value)| format!(" {key}=\"{value}\""))
                    .collect::<Vec<_>>().join("");

                Box::pin((async move || {
                    let rendered_children = join_all(children.into_iter()
                        .map(|child| child.render_to_string())
                        .collect::<Vec<_>>()).await.join("");

                    format!("<{name}{text_attributes}>{rendered_children}</{name}>")

                })())
            },
            RenderNode::Fragment { children } => {
                Box::pin((async move || {
                    join_all(children.into_iter()
                        .map(|child| child.render_to_string())).await
                        .join("")
                })())
            }

            RenderNode::TextNode { content } => Box::pin((async move || content)()),
            RenderNode::Null => Box::pin((async move || "".to_string())()),
        }
    }
}