use html5ever::{namespace_url, ns, LocalName, QualName};
use kuchiki::{iter::NodeEdge, traits::*};

use super::{MessageComponent, MessageContent};

pub fn convert_matrix(message: &str) -> MessageContent {
    let dom = kuchiki::parse_fragment(
        QualName::new(None, ns!(html), LocalName::from("div")),
        vec![],
    )
    .one(message);

    // TODO: Work out how to convert the DOM into a message syntax tree
    for edge in dom.traverse() {
        match edge {
            NodeEdge::Start(_) => {}
            NodeEdge::End(_) => {}
        };
    }

    todo!();
}

pub fn format_matrix(message_content: &[MessageComponent]) -> String {
    message_content
        .iter()
        .map(|component| match component {
            MessageComponent::Plain(text) => html_escape::encode_text(text).to_string(),
            MessageComponent::Link { target, text } => format!(
                r#"<a href="{}">{}</a>"#,
                html_escape::encode_quoted_attribute(target),
                format_matrix(text)
            ),

            MessageComponent::Italic(inner) => format!("<em>{}</em>", format_matrix(inner)),
            MessageComponent::Bold(inner) => format!("<strong>{}</strong>", format_matrix(inner)),
            MessageComponent::Strikethrough(inner) => {
                format!("<del>{}</del>", format_matrix(inner))
            }
            MessageComponent::Underline(inner) => format!("<u>{}</u>", format_matrix(inner)),

            MessageComponent::Code(code) => {
                format!("<code>{}</code>", html_escape::encode_text(code))
            }
            MessageComponent::CodeBlock { lang, source } => {
                format!(
                    r#"<pre><code{}>{}</code></pre>"#,
                    lang.as_ref()
                        .map(|lang| format!(
                            r#" class="language-{}""#,
                            html_escape::encode_quoted_attribute(lang)
                        ))
                        .unwrap_or_else(|| "".to_string()),
                    source,
                )
            }

            MessageComponent::Spoiler { reason, content } => format!(
                "<span data-mx-spoiler{}>{}</span>",
                reason
                    .as_ref()
                    .map(|reason| format!(r#"="{}""#, html_escape::encode_quoted_attribute(reason)))
                    .unwrap_or_else(|| "".to_string()),
                format_matrix(content)
            ),
            MessageComponent::HardBreak => "<br>".to_string(),
            MessageComponent::BlockQuote(inner) => {
                format!("<blockquote>{}</blockquote>", format_matrix(inner))
            }
        })
        .collect()
}