// 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

// NodeKind identifies what kind of AST node a Node represents.
pub enum NodeKind {
	document
	heading
	paragraph
	blockquote
	list
	list_item
	code_block
	fenced_code
	thematic_break
	html_block
	link_ref_def
	table
	table_head
	table_body
	table_row
	table_cell
	definition_list
	definition_term
	definition_desc
	footnote_def
	text
	emphasis
	strong
	code_span
	link
	image
	autolink
	raw_html
	hard_break
	soft_break
	strikethrough
	footnote_ref
	task_checkbox
}

// Alignment is the text alignment of a table cell column.
pub enum Alignment {
	none_
	left
	center
	right
}

// Node is a node in the parsed markdown AST.
// A document is a tree of Nodes with .document as the root.
@[heap]
pub struct Node {
pub mut:
	kind       NodeKind
	level      int
	is_tight   bool
	is_ordered bool
	list_start int = 1
	fence_info string
	literal    string
	dest       string
	title      string
	label      string
	checked    bool
	align      Alignment
	id         string
	fn_label   string
	fn_index   int
	children   []&Node
}

// new_node allocates and returns a new Node of the given kind.
pub fn new_node(kind NodeKind) &Node {
	return &Node{
		kind: kind
	}
}

// append_child appends child as the last child of n.
pub fn (mut n Node) append_child(child &Node) {
	n.children << child
}

// text_content returns the plain-text content of this node and all descendants,
// concatenated in document order.
pub fn (n &Node) text_content() string {
	match n.kind {
		.text, .code_span, .raw_html {
			return n.literal
		}
		else {
			mut sb := strings.new_builder(64)
			for child in n.children {
				sb.write_string(child.text_content())
			}
			return sb.str()
		}
	}
}

// walk traverses n and all its descendants in pre-order (root before children).
// The callback f receives each node; return false from f to stop traversal early.
// walk itself returns false if traversal was stopped, true otherwise.
pub fn (n &Node) walk(f fn (&Node) bool) bool {
	if !f(n) {
		return false
	}
	for child in n.children {
		if !child.walk(f) {
			return false
		}
	}
	return true
}