use serde::Serialize;

use super::render_context::RenderContext;
use crate::error::CustomError;
use crate::intermediate::IRegularLink;
use crate::intermediate::LinkTarget;

use super::macros::render;
use super::RenderObject;

#[derive(Debug, Serialize)]
#[serde(tag = "type")]
#[serde(rename = "regular_link")]
pub(crate) enum RenderRegularLink {
    #[serde(rename = "regular_link_anchor")]
    Anchor(RenderRegularLinkAnchor),
    #[serde(rename = "regular_link_image")]
    Image(RenderRegularLinkImage),
}

#[derive(Debug, Serialize)]
pub(crate) struct RenderRegularLinkAnchor {
    target: String,
    raw_link: String,
    children: Vec<RenderObject>,
    post_blank: organic::types::PostBlank,
}

#[derive(Debug, Serialize)]
pub(crate) struct RenderRegularLinkImage {
    src: String,
    alt: String,
    raw_link: String,
    post_blank: organic::types::PostBlank,
}

render!(RenderRegularLink, IRegularLink, original, render_context, {
    let children = {
        let mut ret = Vec::new();
        for obj in original.children.iter() {
            ret.push(RenderObject::new(render_context.clone(), obj)?);
        }
        ret
    };

    let target = original
        .target
        .generate_final_target(render_context.clone())?
        .unwrap_or_else(|| "".to_owned());

    let render_link = match &original.target {
        LinkTarget::Raw(_) | LinkTarget::Post { .. } | LinkTarget::Target { .. } => {
            RenderRegularLink::Anchor(RenderRegularLinkAnchor {
                target,
                raw_link: original.raw_link.clone(),
                children,
                post_blank: original.post_blank,
            })
        }
        LinkTarget::Image { alt, .. } => RenderRegularLink::Image(RenderRegularLinkImage {
            src: target,
            alt: alt.clone(),
            raw_link: original.raw_link.clone(),
            post_blank: original.post_blank,
        }),
    };

    Ok(render_link)
});