// Copyright 2026 The V Language. All rights reserved.
// Use of this source code is governed by an MIT license
// that can be found in the LICENSE file.
module markdown

import strings

// HTMLRenderer renders a parsed markdown AST to an HTML string.
struct HTMLRenderer {
    opts    Options
    ref_map map[string]LinkRef
mut:
    sb strings.Builder
    // footnote tracking
    fn_order      []string         // ordered list of encountered fn labels
    fn_nodes      map[string]&Node // label → footnote_def node
    tight_list    bool             // whether we're inside a tight list
    in_table_head bool
}

// render renders the document node to an HTML string.
pub fn (mut r HTMLRenderer) render(doc &Node) string {
    r.sb = strings.new_builder(1024)
    // Pre-collect footnote definitions if extension is enabled.
    if r.opts.footnotes {
        for child in doc.children {
            if child.kind == .footnote_def {
                r.fn_nodes[child.fn_label] = child
            }
        }
    }
    r.render_children(doc)
    // Append footnotes section if any refs were used.
    if r.opts.footnotes && r.fn_order.len > 0 {
        r.render_footnotes_section()
    }
    return r.sb.str()
}

// render_node dispatches rendering to the appropriate method.
fn (mut r HTMLRenderer) render_node(node &Node) {
    match node.kind {
        .document { r.render_children(node) }
        .heading { r.render_heading(node) }
        .paragraph { r.render_paragraph(node) }
        .blockquote { r.render_blockquote(node) }
        .list { r.render_list(node) }
        .list_item { r.render_list_item(node) }
        .code_block { r.render_code_block(node) }
        .fenced_code { r.render_fenced_code(node) }
        .thematic_break { r.render_thematic_break() }
        .html_block { r.render_html_block(node) }
        .link_ref_def {} // already collected, nothing to render
        .table { r.render_table(node) }
        .table_head { r.render_table_section(node, 'thead') }
        .table_body { r.render_table_section(node, 'tbody') }
        .table_row { r.render_table_row(node) }
        .table_cell { r.render_table_cell(node) }
        .definition_list { r.render_definition_list(node) }
        .definition_term { r.render_definition_term(node) }
        .definition_desc { r.render_definition_desc(node) }
        .footnote_def {} // rendered in the footnote section
        .text { r.render_text(node) }
        .emphasis { r.render_emphasis(node) }
        .strong { r.render_strong(node) }
        .code_span { r.render_code_span(node) }
        .link { r.render_link(node) }
        .image { r.render_image(node) }
        .autolink { r.render_autolink(node) }
        .raw_html { r.render_raw_html(node) }
        .hard_break { r.render_hard_break() }
        .soft_break { r.render_soft_break() }
        .strikethrough { r.render_strikethrough(node) }
        .task_checkbox { r.render_task_checkbox(node) }
        .footnote_ref { r.render_footnote_ref(node) }
    }
}

// render_children renders all children of node.
fn (mut r HTMLRenderer) render_children(node &Node) {
    for child in node.children {
        r.render_node(child)
    }
}

// render_inline parses and renders inline content from a literal string.
fn (mut r HTMLRenderer) render_inline(src string) {
    nodes := parse_inline(src, r.opts, r.ref_map)
    for node in nodes {
        r.render_node(node)
    }
}

fn (mut r HTMLRenderer) render_heading(node &Node) {
    tag := 'h${node.level}'
    if node.id.len > 0 {
        r.sb.write_string('<${tag} id="${html_escape(node.id)}">')
    } else {
        r.sb.write_string('<${tag}>')
    }
    if node.children.len > 0 {
        r.render_children(node)
    } else {
        r.render_inline(node.literal)
    }
    r.sb.write_string('</${tag}>\n')
}

fn (mut r HTMLRenderer) render_paragraph(node &Node) {
    if r.tight_list {
        // In a tight list, paragraph content is rendered directly without <p> tags.
        if node.children.len > 0 {
            r.render_children(node)
        } else {
            r.render_inline(node.literal)
        }
        return
    }
    r.sb.write_string('<p>')
    if node.children.len > 0 {
        r.render_children(node)
    } else {
        r.render_inline(node.literal)
    }
    r.sb.write_string('</p>\n')
}

fn (mut r HTMLRenderer) render_blockquote(node &Node) {
    r.sb.write_string('<blockquote>\n')
    r.render_children(node)
    r.sb.write_string('</blockquote>\n')
}

fn (mut r HTMLRenderer) render_list(node &Node) {
    tag := if node.is_ordered { 'ol' } else { 'ul' }
    if node.is_ordered && node.list_start != 1 {
        r.sb.write_string('<${tag} start="${node.list_start}">\n')
    } else {
        r.sb.write_string('<${tag}>\n')
    }
    prev_tight := r.tight_list
    r.tight_list = node.is_tight
    r.render_children(node)
    r.tight_list = prev_tight
    r.sb.write_string('</${tag}>\n')
}

fn (mut r HTMLRenderer) render_list_item(node &Node) {
    // Check if this is a task list item (first child is task_checkbox).
    if r.opts.task_list && node.children.len > 0 && node.children[0].kind == .task_checkbox {
        chk := node.children[0]
        checked_attr := if chk.checked { ' checked=""' } else { '' }
        if r.opts.renderer_opts.xhtml {
            r.sb.write_string('<li><input type="checkbox" disabled=""${checked_attr} /> ')
        } else {
            r.sb.write_string('<li><input type="checkbox" disabled=""${checked_attr}> ')
        }
        for i := 1; i < node.children.len; i++ {
            r.render_node(node.children[i])
        }
        r.sb.write_string('</li>\n')
        return
    }
    r.sb.write_string('<li>')
    r.render_children(node)
    r.sb.write_string('</li>\n')
}

fn (mut r HTMLRenderer) render_code_block(node &Node) {
    r.sb.write_string('<pre><code>')
    r.sb.write_string(html_escape(node.literal))
    r.sb.write_string('</code></pre>\n')
}

fn (mut r HTMLRenderer) render_fenced_code(node &Node) {
    if node.fence_info.len > 0 {
        // Use only the first word of the info string as the language class.
        lang := node.fence_info.split(' ')[0].split('\t')[0]
        r.sb.write_string('<pre><code class="language-${html_escape(lang)}">')
    } else {
        r.sb.write_string('<pre><code>')
    }
    r.sb.write_string(html_escape(node.literal))
    r.sb.write_string('</code></pre>\n')
}

fn (mut r HTMLRenderer) render_thematic_break() {
    if r.opts.renderer_opts.xhtml {
        r.sb.write_string('<hr />\n')
    } else {
        r.sb.write_string('<hr>\n')
    }
}

fn (mut r HTMLRenderer) render_html_block(node &Node) {
    if r.opts.renderer_opts.unsafe_ {
        r.sb.write_string(node.literal)
    } else {
        r.sb.write_string('<!-- raw HTML omitted -->\n')
    }
}

fn (mut r HTMLRenderer) render_table(node &Node) {
    r.sb.write_string('<table>\n')
    r.render_children(node)
    r.sb.write_string('</table>\n')
}

fn (mut r HTMLRenderer) render_table_section(node &Node, tag string) {
    prev_in_table_head := r.in_table_head
    r.in_table_head = tag == 'thead'
    r.sb.write_string('<${tag}>\n')
    r.render_children(node)
    r.sb.write_string('</${tag}>\n')
    r.in_table_head = prev_in_table_head
}

fn (mut r HTMLRenderer) render_table_row(node &Node) {
    // Determine cell tag based on parent kind (table_head uses th).
    // We pass the context via a field or inspect the row context.
    // Since we don't have parent pointer, check if this is a header row via the
    // node's parent tracking. We'll check node.children[0].align as a proxy.
    // Instead, use a simple flag: if any sibling is a table_head, use <th>.
    // For simplicity, we use <td> always and let render_table_cell decide.
    r.sb.write_string('<tr>\n')
    r.render_children(node)
    r.sb.write_string('</tr>\n')
}

fn (mut r HTMLRenderer) render_table_cell(node &Node) {
    // We use a flag in the renderer to know if we're in the head.
    // Simple approach: the cell tag is set by the surrounding context.
    // We'll use <td> and trust the renderer state.
    align_attr := match node.align {
        .left { ' align="left"' }
        .center { ' align="center"' }
        .right { ' align="right"' }
        else { '' }
    }

    cell_tag := if r.in_table_head { 'th' } else { 'td' }
    r.sb.write_string('<${cell_tag}${align_attr}>')
    r.render_inline(node.literal)
    r.sb.write_string('</${cell_tag}>\n')
}

fn (mut r HTMLRenderer) render_definition_list(node &Node) {
    r.sb.write_string('<dl>\n')
    r.render_children(node)
    r.sb.write_string('</dl>\n')
}

fn (mut r HTMLRenderer) render_definition_term(node &Node) {
    r.sb.write_string('<dt>')
    r.render_inline(node.literal)
    r.sb.write_string('</dt>\n')
    for child in node.children {
        r.render_node(child)
    }
}

fn (mut r HTMLRenderer) render_definition_desc(node &Node) {
    r.sb.write_string('<dd>')
    r.render_inline(node.literal)
    r.sb.write_string('</dd>\n')
}

fn (mut r HTMLRenderer) render_footnote_ref(node &Node) {
    label := node.fn_label
    // Assign an ordinal on first encounter.
    mut idx := 0
    for i, l in r.fn_order {
        if l == label {
            idx = i + 1
            break
        }
    }
    if idx == 0 {
        r.fn_order << label
        idx = r.fn_order.len
    }
    r.sb.write_string('<sup><a href="#fn-${html_escape(label)}" id="fnref-${html_escape(label)}">${idx}</a></sup>')
}

fn (mut r HTMLRenderer) render_footnotes_section() {
    r.sb.write_string('<section class="footnotes">\n<ol>\n')
    for label in r.fn_order {
        fn_node := r.fn_nodes[label] or { continue }
        r.sb.write_string('<li id="fn-${html_escape(label)}">')
        r.render_inline(fn_node.literal)
        r.sb.write_string(' <a href="#fnref-${html_escape(label)}">↩</a></li>\n')
    }
    r.sb.write_string('</ol>\n</section>\n')
}

fn (mut r HTMLRenderer) render_text(node &Node) {
    content := if r.opts.typographer {
        smart_punctuate(node.literal)
    } else {
        node.literal
    }
    r.sb.write_string(html_escape(content))
}

fn (mut r HTMLRenderer) render_emphasis(node &Node) {
    r.sb.write_string('<em>')
    r.render_children(node)
    r.sb.write_string('</em>')
}

fn (mut r HTMLRenderer) render_strong(node &Node) {
    r.sb.write_string('<strong>')
    r.render_children(node)
    r.sb.write_string('</strong>')
}

fn (mut r HTMLRenderer) render_code_span(node &Node) {
    r.sb.write_string('<code>')
    r.sb.write_string(html_escape(node.literal))
    r.sb.write_string('</code>')
}

fn (mut r HTMLRenderer) render_link(node &Node) {
    r.sb.write_string('<a href="${html_escape(url_encode(node.dest))}"')
    if node.title.len > 0 {
        r.sb.write_string(' title="${html_escape(node.title)}"')
    }
    r.sb.write_string('>')
    r.render_children(node)
    r.sb.write_string('</a>')
}

fn (mut r HTMLRenderer) render_image(node &Node) {
    alt := node.text_content()
    r.sb.write_string('<img src="${html_escape(url_encode(node.dest))}" alt="${html_escape(alt)}"')
    if node.title.len > 0 {
        r.sb.write_string(' title="${html_escape(node.title)}"')
    }
    if r.opts.renderer_opts.xhtml {
        r.sb.write_string(' />')
    } else {
        r.sb.write_string('>')
    }
}

fn (mut r HTMLRenderer) render_autolink(node &Node) {
    r.sb.write_string('<a href="${html_escape(url_encode(node.dest))}">')
    r.sb.write_string(html_escape(node.literal))
    r.sb.write_string('</a>')
}

fn (mut r HTMLRenderer) render_raw_html(node &Node) {
    if r.opts.renderer_opts.unsafe_ {
        r.sb.write_string(node.literal)
    } else {
        r.sb.write_string('<!-- raw HTML omitted -->')
    }
}

fn (mut r HTMLRenderer) render_hard_break() {
    if r.opts.renderer_opts.xhtml {
        r.sb.write_string('<br />\n')
    } else {
        r.sb.write_string('<br>\n')
    }
}

fn (mut r HTMLRenderer) render_soft_break() {
    if r.opts.renderer_opts.hard_wraps {
        if r.opts.renderer_opts.xhtml {
            r.sb.write_string('<br />\n')
        } else {
            r.sb.write_string('<br>\n')
        }
    } else {
        r.sb.write_string('\n')
    }
}

fn (mut r HTMLRenderer) render_strikethrough(node &Node) {
    r.sb.write_string('<del>')
    r.render_children(node)
    r.sb.write_string('</del>')
}

fn (mut r HTMLRenderer) render_task_checkbox(node &Node) {
    // Rendered inline in render_list_item; standalone fallback:
    checked := if node.checked { ' checked=""' } else { '' }
    if r.opts.renderer_opts.xhtml {
        r.sb.write_string('<input type="checkbox" disabled=""${checked} />')
    } else {
        r.sb.write_string('<input type="checkbox" disabled=""${checked}>')
    }
}