module dtm2

import hash
import json
import os
import strings

// dtm2 is the modern runtime renderer for Dynamic Template Manager.
// It keeps DTM dynamic, meaning templates can still be edited on disk without
// recompiling the application, while moving the hot path to a parsed-template
// cache instead of a rendered-output cache. File extensions are configurable,
// but every template ultimately renders in either HTML mode or text mode.
//
// The intended runtime model is one long-lived Manager per application or
// rendering context. Tests and benchmarks may create short-lived managers, but
// normal applications should reuse a manager so parsed templates and resolved
// paths stay hot.
const message_signature = '[Dynamic Template Manager 2]'
const internal_server_error = 'Internal Server Error'
const include_html_key_suffix = '_#includehtml'
const include_directive = '@include '
const max_include_depth = 32
const max_extension_config_size = 64 * 1024
const default_extension_config_filename = 'dtm2_extensions.json'
const segment_instruction_size = 9
const segment_kind_text = u8(0)
const segment_kind_placeholder = u8(1)

// These tags are the compatibility allow-list for the historical `_#includehtml`
// placeholder suffix. Any other tag is still escaped.
const allowed_html_tags = ['<div>', '</div>', '<h1>', '</h1>', '<h2>', '</h2>', '<h3>', '</h3>',
	'<h4>', '</h4>', '<h5>', '</h5>', '<h6>', '</h6>', '<p>', '</p>', '<br>', '<hr>', '<span>',
	'</span>', '<ul>', '</ul>', '<ol>', '</ol>', '<li>', '</li>', '<dl>', '</dl>', '<dt>', '</dt>',
	'<dd>', '</dd>', '<menu>', '</menu>', '<table>', '</table>', '<caption>', '</caption>', '<th>',
	'</th>', '<tr>', '</tr>', '<td>', '</td>', '<thead>', '</thead>', '<thread>', '</thread>',
	'<tbody>', '</tbody>', '<tfoot>', '</tfoot>', '<col>', '</col>', '<colgroup>', '</colgroup>',
	'<header>', '</header>', '<footer>', '</footer>', '<main>', '</main>', '<section>', '</section>',
	'<article>', '</article>', '<aside>', '</aside>', '<details>', '</details>', '<dialog>',
	'</dialog>', '<data>', '</data>', '<summary>', '</summary>']!

pub enum TemplateType {
	html
	text
}

// ExtensionConfig is the JSON representation accepted by
// `ManagerParams.extension_config_file`.
//
// Example:
//
// ```json
// {
//   "html": [".html", ".htm", ".xml", ".view"],
//   "text": [".txt", ".mail"]
// }
// ```
pub struct ExtensionConfig {
pub:
	html []string
	text []string
}

// TemplateDependency records the file metadata that decides whether a parsed
// template is still fresh. Includes are tracked as dependencies of the parent
// template, so editing a partial can invalidate the compiled parent tree.
struct TemplateDependency {
	path         string
	modified_at  i64
	size         u64
	content_hash u64
}

// CompiledTemplate is the parsed representation stored by Manager.
//
// It intentionally stores a compact instruction string instead of slices of
// segment structs. The instructions contain offsets into the owned `content`
// string, which keeps the cache compact and avoids keeping fragile string-slice
// graphs alive across many -prod renders.
@[heap]
struct CompiledTemplate {
	// Rendering mode inferred from the source file extension.
	template_type TemplateType
	// Full template content after static @include expansion.
	content string
	// Compact metadata used to decide whether this compiled tree is stale.
	dependency_signature string
	// Binary instruction stream: one fixed-size record per text/placeholder segment.
	instructions string
	// Number of text and placeholder records in `instructions`.
	segment_count int
	// Static-text size hint used to preallocate the render buffer.
	estimated_size int
}

// Manager owns the runtime state of a dtm2 renderer.
//
// It caches resolved template paths and parsed template trees, but never caches
// rendered HTML responses. This keeps the new engine deterministic and leaves
// legacy rendered-cache compatibility in `x.templating.dtm`.
@[heap]
pub struct Manager {
mut:
	// Base directory for relative template paths.
	template_dir string
	// Enables the lightweight deterministic HTML whitespace compressor.
	compress_html bool
	// When true, source and include files are stat-checked before cache reuse.
	reload_modified_templates bool
	// Maps caller-provided template paths to canonical source paths.
	resolved_template_paths map[string]string
	// Parsed-template cache keyed by canonical source path.
	compiled_templates map[string]&CompiledTemplate
	// User-provided extension-to-render-mode overrides. Built-in extensions are
	// resolved without allocating a per-manager default map.
	template_extensions map[string]TemplateType
}

// ManagerParams configure a dtm2 Manager.
@[params]
pub struct ManagerParams {
pub:
	// Root directory used when `expand()` receives a relative template path.
	// If empty, `<executable directory>/templates` is used.
	template_dir string
	// Compresses HTML output by removing newlines/tabs and redundant spaces.
	compress_html bool = true
	// Re-check source files and includes before reusing a parsed template tree.
	// Disable it for maximum hot-path throughput when templates are immutable.
	reload_modified_templates bool = true
	// Additional or overriding extension mappings.
	// Default mappings are: `.html`, `.htm`, `.xml` => HTML mode and
	// `.txt`, `.text` => text mode.
	template_extensions map[string]TemplateType
	// Optional JSON file containing extension mappings. It is merged after the
	// default mappings and before `template_extensions`, so explicit code
	// configuration wins over the file. If empty, DTM2 tries to load
	// `<template_dir>/dtm2_extensions.json` when that file exists.
	extension_config_file string
}

// RenderParams configure one render call.
@[params]
pub struct RenderParams {
pub:
	// Placeholder values keyed by their template name without the `@` prefix.
	// Values are escaped by default.
	placeholders &map[string]string = &map[string]string{}
	// Prefix written back when a placeholder is missing. The default preserves
	// the original `@placeholder` text.
	missing_placeholder_prefix string = '@'
}

// initialize creates a dynamic template manager rooted at `params.template_dir`.
//
// The returned manager should normally be kept and reused. Reusing it is what
// gives dtm2 its parsed-template and path-resolution cache benefits.
pub fn initialize(params ManagerParams) &Manager {
	raw_template_dir := if params.template_dir == '' {
		os.join_path(os.dir(os.executable()), 'templates')
	} else {
		params.template_dir
	}
	template_dir := canonical_template_dir(raw_template_dir)
	template_extensions := build_template_extensions(params, template_dir)
	return &Manager{
		template_dir:              template_dir.clone()
		compress_html:             params.compress_html
		reload_modified_templates: params.reload_modified_templates
		resolved_template_paths:   map[string]string{}
		compiled_templates:        map[string]&CompiledTemplate{}
		template_extensions:       template_extensions
	}
}

fn canonical_template_dir(template_dir string) string {
	return os.real_path(template_dir)
}

fn build_template_extensions(params ManagerParams, template_dir string) map[string]TemplateType {
	mut extensions := map[string]TemplateType{}
	config_path := extension_config_path(params, template_dir)
	if config_path != '' {
		file_extensions := read_extension_config_file(config_path) or {
			eprintln('${message_signature} ${err.msg()}')
			map[string]TemplateType{}
		}
		merge_template_extensions(mut extensions, file_extensions)
	}
	merge_template_extensions(mut extensions, params.template_extensions)
	return extensions
}

fn extension_config_path(params ManagerParams, template_dir string) string {
	if params.extension_config_file != '' {
		return params.extension_config_file
	}
	default_path := os.join_path(template_dir, default_extension_config_filename)
	if os.exists(default_path) {
		return default_path
	}
	return ''
}

fn read_extension_config_file(config_path string) !map[string]TemplateType {
	if !os.exists(config_path) {
		return error('extension config file "${config_path}" not found')
	}
	if os.is_dir(config_path) {
		return error('extension config path "${config_path}" is a directory')
	}
	config_stat := os.stat(config_path)!
	if config_stat.size > u64(max_extension_config_size) {
		return error('extension config file "${config_path}" is larger than ${max_extension_config_size} bytes')
	}
	raw_config := os.read_file(config_path)!
	config := json.decode(ExtensionConfig, raw_config)!
	mut extensions := map[string]TemplateType{}
	merge_template_extension_list(mut extensions, config.html, .html)
	merge_template_extension_list(mut extensions, config.text, .text)
	return extensions
}

fn merge_template_extensions(mut target map[string]TemplateType, source map[string]TemplateType) {
	for ext, template_type in source {
		normalized := validate_template_extension(ext) or {
			eprintln('${message_signature} ${err.msg()}')
			continue
		}
		target[normalized] = template_type
	}
}

fn merge_template_extension_list(mut target map[string]TemplateType, extensions []string, template_type TemplateType) {
	for ext in extensions {
		normalized := validate_template_extension(ext) or {
			eprintln('${message_signature} ${err.msg()}')
			continue
		}
		target[normalized] = template_type
	}
}

fn normalize_template_extension(ext string) string {
	trimmed := ext.trim_space().to_lower()
	if trimmed == '' {
		return ''
	}
	if trimmed.starts_with('.') {
		return trimmed
	}
	return '.${trimmed}'
}

fn validate_template_extension(ext string) !string {
	normalized := normalize_template_extension(ext)
	if normalized.len < 2 {
		return error('ignoring invalid template extension "${ext}"')
	}
	for i := 1; i < normalized.len; i++ {
		c := normalized[i]
		if (c >= `a` && c <= `z`) || (c >= `0` && c <= `9`) || c == `_` || c == `-` || c == `.` {
			continue
		}
		return error('ignoring invalid template extension "${ext}"')
	}
	return normalized
}

// compiled_template_count is intentionally exposed for tests and diagnostics. In
// dtm2 it counts parsed template trees currently held by the manager.
pub fn (m &Manager) compiled_template_count() int {
	return m.compiled_templates.len
}

// expand renders `template_path` with the provided placeholders.
//
// `template_path` can be absolute or relative to the manager's template
// directory. Supported extensions come from the manager extension table.
// Errors are reported to stderr and return the legacy-compatible
// `Internal Server Error` string.
pub fn (mut m Manager) expand(template_path string, params RenderParams) string {
	source_path := m.cached_template_path(template_path) or {
		eprintln('${message_signature} ${err.msg()}')
		return internal_server_error
	}
	compiled := m.compiled_template_for_path(source_path) or {
		eprintln('${message_signature} ${err.msg()}')
		return internal_server_error
	}
	if m.compress_html && compiled.template_type == .html {
		rendered := render_compiled_template(compiled, params)
		compressed := compress_html_output(rendered)
		return compressed.clone()
	}
	rendered := render_compiled_template(compiled, params)
	return rendered.clone()
}

// cached_template_path reuses canonical paths when reload checks are disabled.
// When reload checks are enabled, it revalidates the current real path so a
// replaced symlink cannot bypass the template directory boundary.
fn (mut m Manager) cached_template_path(template_path string) !string {
	if source_path := m.resolved_template_paths[template_path] {
		if m.reload_modified_templates {
			current_source_path := m.resolve_template_path(template_path)!
			if current_source_path != source_path {
				m.resolved_template_paths[template_path] = current_source_path
				return current_source_path
			}
		}
		return source_path
	}
	source_path := m.resolve_template_path(template_path)!
	m.resolved_template_paths[template_path] = source_path
	return source_path
}

// compiled_template_for_path returns the parsed tree for a canonical source
// path. When reload checks are enabled, dependency metadata decides whether the
// tree can be reused or must be rebuilt from disk.
fn (mut m Manager) compiled_template_for_path(source_path string) !&CompiledTemplate {
	if compiled := m.compiled_templates[source_path] {
		if !m.reload_modified_templates || compiled.dependencies_are_fresh(m.template_dir) {
			return compiled
		}
	}
	compiled := compile_template_from_file(source_path, m.template_dir, m.template_extensions,
		m.reload_modified_templates)!
	m.compiled_templates[source_path] = compiled
	return compiled
}

// compile_template_from_file reads a template, expands static includes, parses
// placeholders, and stores dependency metadata for future invalidation.
fn compile_template_from_file(source_path string, template_root string, template_extensions map[string]TemplateType, track_dependencies bool) !&CompiledTemplate {
	canonical_path := os.real_path(source_path)
	ensure_path_inside_template_dir(canonical_path, template_root)!
	template_type := template_type_from_path(canonical_path, template_extensions)!
	content, dependencies := read_template_with_includes(canonical_path, template_root, 0,
		track_dependencies)!
	instructions, estimated_size, segment_count := parse_segments(content)
	dependency_signature := encode_dependencies(dependencies)
	return &CompiledTemplate{
		template_type:        template_type
		content:              copy_string(content)
		dependency_signature: copy_string(dependency_signature)
		instructions:         copy_string(instructions)
		segment_count:        segment_count
		estimated_size:       estimated_size
	}
}

// copy_string forces cached strings to own their memory. Cached templates live
// beyond the stack frame that built them, so the cache should not retain
// accidental views into temporary buffers.
fn copy_string(value string) string {
	mut bytes := []u8{len: value.len}
	for i := 0; i < value.len; i++ {
		bytes[i] = value[i]
	}
	copied := bytes.bytestr()
	return copied.clone()
}

// dependencies_are_fresh checks root and included files. The content hash closes
// the same-second, same-size edit window left by second-resolution mtimes.
fn (compiled &CompiledTemplate) dependencies_are_fresh(template_root string) bool {
	signature := compiled.dependency_signature
	mut offset := 0
	for offset < signature.len {
		first_sep := index_byte_from(signature, `|`, offset) or { return false }
		second_sep := index_byte_from(signature, `|`, first_sep + 1) or { return false }
		third_sep := index_byte_from(signature, `|`, second_sep + 1) or { return false }
		line_end := index_byte_from(signature, `\n`, third_sep + 1) or { signature.len }
		size := signature[first_sep + 1..second_sep].i64()
		if size < 0 {
			return false
		}
		content_hash := signature[second_sep + 1..third_sep].u64()
		path := signature[third_sep + 1..line_end]
		current_path := os.real_path(path)
		ensure_path_inside_template_dir(current_path, template_root) or { return false }
		if current_path != path {
			return false
		}
		stat := os.stat(path) or { return false }
		if stat.mtime != signature[offset..first_sep].i64() || stat.size != u64(size) {
			return false
		}
		content := os.read_file(path) or { return false }
		if content_fingerprint(content) != content_hash {
			return false
		}
		offset = line_end + 1
	}
	return true
}

fn index_byte_from(value string, needle u8, start int) ?int {
	for i := start; i < value.len; i++ {
		if value[i] == needle {
			return i
		}
	}
	return none
}

fn encode_dependencies(dependencies []TemplateDependency) string {
	mut out := strings.new_builder(dependencies.len * 64)
	for dependency in dependencies {
		out.writeln('${dependency.modified_at}|${dependency.size}|${dependency.content_hash}|${dependency.path}')
	}
	encoded := out.str()
	return encoded.clone()
}

// resolve_template_path converts absolute or manager-relative template names to
// canonical paths. The canonical path is used as the compiled-template cache key.
fn (m &Manager) resolve_template_path(template_path string) !string {
	source_path := if os.is_abs_path(template_path) {
		template_path
	} else {
		os.join_path(m.template_dir, template_path)
	}
	if !os.exists(source_path) {
		return error('template "${source_path}" not found')
	}
	canonical_path := os.real_path(source_path)
	ensure_path_inside_template_dir(canonical_path, m.template_dir)!
	return canonical_path
}

fn ensure_path_inside_template_dir(path string, template_root string) ! {
	root := path_without_trailing_separator(template_root)
	candidate := path_without_trailing_separator(path)
	if candidate == root || candidate.starts_with(root + os.path_separator) {
		return
	}
	return error('template "${path}" is outside template directory "${template_root}"')
}

fn path_without_trailing_separator(path string) string {
	if path.len > os.path_separator.len && path.ends_with(os.path_separator) {
		return path[..path.len - os.path_separator.len]
	}
	return path
}

// template_type_from_path keeps rendering rules extension-driven and explicit.
fn template_type_from_path(source_path string, template_extensions map[string]TemplateType) !TemplateType {
	ext := normalize_template_extension(os.file_ext(source_path))
	if template_extensions.len > 0 {
		if template_type := template_extensions[ext] {
			return template_type
		}
	}
	if template_type := default_template_type_from_extension(ext) {
		return template_type
	}
	return error('template "${source_path}" uses unsupported extension "${ext}"')
}

fn default_template_type_from_extension(ext string) ?TemplateType {
	match ext {
		'.html', '.htm', '.xml' {
			return .html
		}
		'.txt', '.text' {
			return .text
		}
		else {
			return none
		}
	}
}

// read_template_with_includes expands simple line-level `@include "path"`
// directives before parsing placeholders. Includes are part of the parsed tree
// and are tracked as dependencies for reload checks.
fn read_template_with_includes(source_path string, template_root string, depth int, track_dependencies bool) !(string, []TemplateDependency) {
	if depth > max_include_depth {
		return error('maximum @include depth exceeded while reading "${source_path}"')
	}
	content := os.read_file(source_path)!
	mut dependencies := []TemplateDependency{cap: 4}
	if track_dependencies {
		dependencies << template_dependency(source_path, content)!
	}
	if !content_needs_include_expansion(content) {
		return content_with_template_newline(content), dependencies
	}
	base_dir := os.dir(source_path)
	mut out := strings.new_builder(content.len)
	lines := content.split_into_lines()
	for line in lines {
		expanded_line, line_dependencies := expand_include_directives(line, base_dir,
			template_root, depth, track_dependencies)!
		out.write_string(expanded_line)
		out.write_u8(`\n`)
		dependencies << line_dependencies
	}
	rendered := out.str()
	return rendered.clone(), dependencies
}

fn content_with_template_newline(content string) string {
	if content == '' || content[content.len - 1] == `\n` {
		return content.clone()
	}
	with_newline := content + '\n'
	return with_newline.clone()
}

fn content_needs_include_expansion(content string) bool {
	for i := 0; i < content.len; i++ {
		if content[i] == `\r` {
			return true
		}
		if is_include_directive_at(content, i) {
			return true
		}
	}
	return false
}

fn is_include_directive_at(content string, pos int) bool {
	return pos + include_directive.len <= content.len && content[pos] == `@`
		&& content[pos + 1] == `i` && content[pos + 2] == `n` && content[pos + 3] == `c`
		&& content[pos + 4] == `l` && content[pos + 5] == `u` && content[pos + 6] == `d`
		&& content[pos + 7] == `e` && content[pos + 8] == ` `
}

fn template_dependency(source_path string, content string) !TemplateDependency {
	stat := os.stat(source_path)!
	return TemplateDependency{
		path:         source_path.clone()
		modified_at:  stat.mtime
		size:         stat.size
		content_hash: content_fingerprint(content)
	}
}

fn content_fingerprint(content string) u64 {
	return hash.sum64_string(content, 0)
}

fn expand_include_directives(line string, base_dir string, template_root string, depth int, track_dependencies bool) !(string, []TemplateDependency) {
	mut out := strings.new_builder(line.len)
	mut dependencies := []TemplateDependency{}
	mut offset := 0
	for {
		rel_pos := line[offset..].index(include_directive) or {
			out.write_string(line[offset..])
			break
		}
		pos := offset + rel_pos
		target, end_pos := include_target_from_line_at(line, pos) or {
			out.write_string(line[offset..pos + include_directive.len])
			offset = pos + include_directive.len
			continue
		}
		out.write_string(line[offset..pos])
		include_path := resolve_include_path(base_dir, target, template_root)!
		next_depth := depth + 1
		included, include_dependencies := read_template_with_includes(include_path, template_root,
			next_depth, track_dependencies)!
		out.write_string(included.trim_right('\n'))
		dependencies << include_dependencies
		offset = end_pos
	}
	expanded := out.str()
	return expanded.clone(), dependencies
}

fn include_target_from_line_at(line string, pos int) ?(string, int) {
	mut cursor := pos + include_directive.len
	for cursor < line.len && line[cursor].is_space() {
		cursor++
	}
	if cursor >= line.len {
		return none
	}
	quote := line[cursor]
	if quote != `'` && quote != `"` {
		return none
	}
	start := cursor + 1
	for cursor = start; cursor < line.len; cursor++ {
		if line[cursor] == quote {
			return line[start..cursor], cursor + 1
		}
	}
	return none
}

fn resolve_include_path(base_dir string, include_target string, template_root string) !string {
	mut target := include_target
	if os.file_ext(target) == '' {
		target += '.html'
	}
	source_path := if os.is_abs_path(target) {
		target
	} else {
		os.join_path(base_dir, target)
	}
	if !os.exists(source_path) {
		return error('included template "${source_path}" not found')
	}
	include_path := os.real_path(source_path)
	ensure_path_inside_template_dir(include_path, template_root)!
	return include_path
}

// parse_segments converts template content to a compact instruction stream.
// Each instruction stores a segment kind plus offset/length into `content`.
// Rendering can then walk the stream without reparsing placeholder syntax.
fn parse_segments(content string) (string, int, int) {
	mut instructions := []u8{cap: segment_instruction_size * 16}
	mut text_start := 0
	mut estimated_size := 0
	mut segment_count := 0
	mut i := 0
	for i < content.len {
		if content[i] != `@` || i + 1 >= content.len || !is_placeholder_char(content[i + 1]) {
			i++
			continue
		}
		if i > text_start {
			append_segment_instruction(mut instructions, segment_kind_text, text_start,
				i - text_start)
			segment_count++
			estimated_size += i - text_start
		}
		mut end := i + 1
		for end < content.len && is_placeholder_char(content[end]) {
			end++
		}
		append_segment_instruction(mut instructions, segment_kind_placeholder, i + 1, end - i - 1)
		segment_count++
		i = end
		text_start = end
	}
	if text_start < content.len {
		append_segment_instruction(mut instructions, segment_kind_text, text_start,
			content.len - text_start)
		segment_count++
		estimated_size += content.len - text_start
	}
	encoded := instructions.bytestr()
	return encoded.clone(), estimated_size, segment_count
}

fn append_segment_instruction(mut instructions []u8, kind u8, start int, len int) {
	instructions << kind
	append_u32(mut instructions, start)
	append_u32(mut instructions, len)
}

fn append_u32(mut data []u8, value int) {
	encoded := u32(value)
	data << u8(encoded & 0xff)
	data << u8((encoded >> 8) & 0xff)
	data << u8((encoded >> 16) & 0xff)
	data << u8((encoded >> 24) & 0xff)
}

fn read_u32(data string, offset int) int {
	b0 := u32(data[offset])
	b1 := u32(data[offset + 1]) << 8
	b2 := u32(data[offset + 2]) << 16
	b3 := u32(data[offset + 3]) << 24
	value := b0 | b1 | b2 | b3
	return int(value)
}

fn is_placeholder_char(c u8) bool {
	return (c >= `a` && c <= `z`) || (c >= `A` && c <= `Z`) || (c >= `0` && c <= `9`) || c == `_`
}

// render_compiled_template walks the parsed instruction stream and writes the
// final output. Placeholder values are rendered only for this call; the manager
// never stores caller data after `expand()` returns.
fn render_compiled_template(compiled &CompiledTemplate, params RenderParams) string {
	mut out := strings.new_builder(estimate_render_size(compiled))
	mut offset := 0
	for offset + segment_instruction_size <= compiled.instructions.len {
		kind := compiled.instructions[offset]
		start := read_u32(compiled.instructions, offset + 1)
		len := read_u32(compiled.instructions, offset + 5)
		offset += segment_instruction_size
		if kind == segment_kind_text {
			text := compiled.segment_text(start, len)
			out.write_string(text)
			continue
		}
		if kind == segment_kind_placeholder {
			name := compiled.segment_text(start, len)
			if write_placeholder_value(mut out, name, params.placeholders, compiled.template_type) {
				continue
			}
			out.write_string(params.missing_placeholder_prefix)
			out.write_string(name)
		}
	}
	rendered := out.str()
	return rendered.clone()
}

fn (compiled &CompiledTemplate) segment_text(start int, len int) string {
	end := start + len
	if start < 0 || len < 0 || end > compiled.content.len {
		return ''
	}
	return compiled.content[start..end]
}

// write_placeholder_value resolves the normal placeholder name first, then the
// historical `_#includehtml` alias. The alias is accepted for compatibility but
// still passes through the allow-list based HTML escaping path.
fn write_placeholder_value(mut out strings.Builder, name string, placeholders &map[string]string, template_type TemplateType) bool {
	unsafe {
		if raw_value := placeholders[name] {
			rendered_value := render_value(raw_value, name.ends_with(include_html_key_suffix),
				template_type)
			out.write_string(rendered_value)
			return true
		}
		include_html_name := name + include_html_key_suffix
		if raw_html := placeholders[include_html_name] {
			rendered_html := render_value(raw_html, true, template_type)
			out.write_string(rendered_html)
			return true
		}
	}
	return false
}

// estimate_render_size gives strings.Builder enough capacity for common
// placeholder expansion without making a second pre-render pass.
fn estimate_render_size(compiled &CompiledTemplate) int {
	return compiled.estimated_size + 1024 + (compiled.segment_count * 64)
}

// render_value applies DTM's safety default: values are escaped unless the
// caller explicitly uses the include-html convention in an HTML template.
fn render_value(raw string, allow_html bool, template_type TemplateType) string {
	if allow_html && template_type == .html {
		return escape_with_allowed_html(raw)
	}
	return escape_html(raw)
}

// escape_with_allowed_html escapes the full value first, then restores only the
// supported tags. This preserves the legacy opt-in behavior without allowing
// arbitrary raw HTML through.
fn escape_with_allowed_html(value string) string {
	mut escaped := escape_html(value)
	for tag in allowed_html_tags {
		escaped = escaped.replace(escape_html(tag), tag)
	}
	return escaped
}

// escape_html is a local deterministic HTML escape helper. It avoids depending
// on heavier generic replacement paths in the hot render loop.
fn escape_html(value string) string {
	mut escaped := strings.new_builder(value.len)
	for i := 0; i < value.len; i++ {
		match value[i] {
			`&` {
				escaped.write_string('&amp;')
			}
			`<` {
				escaped.write_string('&lt;')
			}
			`>` {
				escaped.write_string('&gt;')
			}
			`"` {
				escaped.write_string('&#34;')
			}
			`'` {
				escaped.write_string('&#39;')
			}
			else {
				escaped.write_u8(value[i])
			}
		}
	}
	escaped_value := escaped.str()
	return escaped_value.clone()
}

// compress_html_output performs a small, predictable whitespace compression
// pass for HTML templates. It intentionally avoids regex work in the hot path.
fn compress_html_output(html string) string {
	mut result := strings.new_builder(html.len)
	mut pending_space := false
	mut last_written := u8(0)
	for i := 0; i < html.len; i++ {
		c := html[i]
		if c == `\n` || c == `\t` {
			continue
		}
		if c == ` ` {
			pending_space = true
			continue
		}
		if pending_space {
			if !(last_written == `>` && c == `<`) {
				result.write_u8(` `)
				last_written = ` `
			}
			pending_space = false
		}
		result.write_u8(c)
		last_written = c
	}
	compressed := result.str()
	return compressed.clone()
}