// Copyright (c) 2019-2024 Alexander Medvednikov. All rights reserved.
// Use of this source code is governed by an MIT license
// that can be found in the LICENSE file.
module parser

import v.ast
import v.token
import v.errors
import os
import strings

enum State {
    simple // default - no special interpretation of tags, *at all*!
    // That is suitable for the general case of text template interpolation,
    // for example for interpolating arbitrary source code (even V source) templates.
    //
    html // default, only when the template extension is .html
    css  // <style>
    js   // <script>
    // span // span.{
}

fn (mut state State) update(line string) {
    trimmed_line := line.trim_space()
    if is_html_open_tag('style', line) {
        state = .css
    } else if trimmed_line == '</style>' {
        state = .html
    } else if is_html_open_tag('script', line) {
        state = .js
    } else if trimmed_line == '</script>' {
        state = .html
    }
}

const tmpl_str_end = "')\n"
const tmpl_literal_dollar_marker = '__V_TMPL_LITERAL_DOLLAR__'

// check HTML open tag `<name attr="x" >`
fn is_html_open_tag(name string, s string) bool {
    trimmed_line := s.trim_space()
    mut len := trimmed_line.len

    if len < name.len {
        return false
    }

    mut sub := trimmed_line[0..1]
    if sub != '<' { // not start with '<'
        return false
    }
    sub = trimmed_line[len - 1..len]
    if sub != '>' { // not end with '<'
        return false
    }
    sub = trimmed_line[len - 2..len - 1]
    if sub == '/' { // self-closing
        return false
    }
    sub = trimmed_line[1..len - 1]
    if sub.contains_any('<>') { // `<name <bad> >`
        return false
    }
    if sub == name { // `<name>`
        return true
    } else {
        len = name.len
        if sub.len <= len { // `<nam>` or `<meme>`
            return false
        }
        if sub[..len + 1] != '${name} ' { // not `<name ...>`
            return false
        }
        return true
    }
}

fn is_tmpl_ident_start(c u8) bool {
    return c.is_letter() || c == `_`
}

fn is_tmpl_ident_part(c u8) bool {
    return c.is_letter() || c.is_digit() || c == `_`
}

fn find_tmpl_balanced_end(line string, start int, open u8, close u8) int {
    if start >= line.len || line[start] != open {
        return -1
    }
    mut depth := 0
    mut i := start
    mut in_single_quote := false
    mut in_double_quote := false
    for i < line.len {
        ch := line[i]
        if ch == `\\` {
            i += 2
            continue
        }
        if in_single_quote {
            if ch == `'` {
                in_single_quote = false
            }
            i++
            continue
        }
        if in_double_quote {
            if ch == `"` {
                in_double_quote = false
            }
            i++
            continue
        }
        if ch == `'` {
            in_single_quote = true
            i++
            continue
        }
        if ch == `"` {
            in_double_quote = true
            i++
            continue
        }
        if ch == open {
            depth++
        } else if ch == close {
            depth--
            if depth == 0 {
                return i + 1
            }
        }
        i++
    }
    return -1
}

fn find_tmpl_complex_at_expr_end(line string, start int) int {
    mut i := start
    if i >= line.len || !is_tmpl_ident_start(line[i]) {
        return -1
    }
    i++
    for i < line.len && is_tmpl_ident_part(line[i]) {
        i++
    }
    mut has_complex_suffix := false
    for i + 1 < line.len && line[i] == `.` && is_tmpl_ident_start(line[i + 1]) {
        i += 2
        has_complex_suffix = true
        for i < line.len && is_tmpl_ident_part(line[i]) {
            i++
        }
    }
    for i < line.len {
        if line[i] == `[` {
            expr_end := find_tmpl_balanced_end(line, i, `[`, `]`)
            if expr_end == -1 {
                return -1
            }
            i = expr_end
            has_complex_suffix = true
            continue
        }
        if line[i] == `(` {
            expr_end := find_tmpl_balanced_end(line, i, `(`, `)`)
            if expr_end == -1 {
                return -1
            }
            i = expr_end
            has_complex_suffix = true
            continue
        }
        if i + 1 < line.len && line[i] == `.` && is_tmpl_ident_start(line[i + 1]) {
            i += 2
            for i < line.len && is_tmpl_ident_part(line[i]) {
                i++
            }
            continue
        }
        break
    }
    if !has_complex_suffix {
        return -1
    }
    return i
}

fn rewrite_complex_template_at_expressions(line string) string {
    mut b := strings.new_builder(line.len + 8)
    mut i := 0
    for i < line.len {
        if line[i] != `@` {
            b.write_u8(line[i])
            i++
            continue
        }
        if i > 0 && line[i - 1] == `\\` {
            b.write_u8(`@`)
            i++
            continue
        }
        if i + 1 >= line.len {
            b.write_u8(`@`)
            i++
            continue
        }
        next := line[i + 1]
        if next == `@` || next == `{` {
            b.write_u8(`@`)
            i++
            continue
        }
        if next == `(` {
            expr_end := find_tmpl_balanced_end(line, i + 1, `(`, `)`)
            if expr_end != -1 && expr_end > i + 2 {
                b.write_string('@{')
                b.write_string(line[i + 2..expr_end - 1])
                b.write_u8(`}`)
                i = expr_end
                continue
            }
            b.write_u8(`@`)
            i++
            continue
        }
        expr_end := find_tmpl_complex_at_expr_end(line, i + 1)
        if expr_end != -1 {
            b.write_string('@{')
            b.write_string(line[i + 1..expr_end])
            b.write_u8(`}`)
            i = expr_end
            continue
        }
        b.write_u8(`@`)
        i++
    }
    return b.str()
}

fn escape_bare_tmpl_dollar_interpolations(line string) string {
    mut sb := strings.new_builder(line.len)
    mut i := 0
    for i < line.len {
        if i + 1 < line.len && ((line[i] == `@` && line[i + 1] == `{`)
            || (line[i] == `$` && line[i + 1] == `{`)) {
            expr_end := find_tmpl_balanced_end(line, i + 1, `{`, `}`)
            if expr_end != -1 {
                sb.write_string(line[i..expr_end])
                i = expr_end
                continue
            }
        }
        if line[i] == `$` && i + 1 < line.len && is_tmpl_ident_start(line[i + 1]) {
            sb.write_string(tmpl_literal_dollar_marker)
            i++
            continue
        }
        sb.write_u8(line[i])
        i++
    }
    return sb.str()
}

fn insert_template_code(fn_name string, tmpl_str_start string, line string) string {
    // HTML, may include `@var`
    // escaped by cgen, unless it's a `veb.RawHtml` string
    trailing_bs := tmpl_str_end + 'sb_${fn_name}.write_u8(92)\n' + tmpl_str_start
    literal_dollar := tmpl_str_end + 'sb_${fn_name}.write_u8(36)\n' + tmpl_str_start
    rewritten_line :=
        escape_bare_tmpl_dollar_interpolations(rewrite_complex_template_at_expressions(line))
    mut sb := strings.new_builder(rewritten_line.len + 16)
    mut i := 0
    for i < rewritten_line.len {
        ch := rewritten_line[i]
        match ch {
            `\\` {
                sb.write_string('\\\\')
                i++
                continue
            }
            `'` {
                sb.write_string("\\'")
                i++
                continue
            }
            `@` {
                if i + 1 < rewritten_line.len && rewritten_line[i + 1] == `@` {
                    sb.write_u8(`@`)
                    i += 2
                    continue
                }
                if i + 1 < rewritten_line.len {
                    next := rewritten_line[i + 1]
                    if next == `{` {
                        sb.write_u8(`$`)
                        i++
                        continue
                    }
                    if is_tmpl_ident_start(next) {
                        // Bare @ident: find the end of the identifier and wrap with ${}
                        mut end := i + 2
                        for end < rewritten_line.len && is_tmpl_ident_part(rewritten_line[end]) {
                            end++
                        }
                        sb.write_string('\${')
                        sb.write_string(rewritten_line[i + 1..end])
                        sb.write_u8(`}`)
                        i = end
                        continue
                    }
                }
                sb.write_u8(`@`)
                i++
                continue
            }
            `$` {
                if i + 1 < rewritten_line.len && rewritten_line[i + 1] == `$` {
                    sb.write_string(r'\@')
                    i += 2
                    continue
                }
            }
            else {}
        }

        sb.write_u8(ch)
        i++
    }
    mut rline := sb.str()
    rline = normalize_keyword_template_interpolations(rline)
    comptime_call_str := rline.find_between('\${', '}')
    if comptime_call_str.contains("\\'") {
        rline = rline.replace(comptime_call_str, comptime_call_str.replace("\\'", r"'"))
    }
    rline = rline.replace(tmpl_literal_dollar_marker, literal_dollar)
    if rline.ends_with('\\') {
        rline = rline[0..rline.len - 2] + trailing_bs
    }
    return rline
}

fn normalize_keyword_template_interpolations(line string) string {
    mut sb := strings.new_builder(line.len)
    mut i := 0
    for i < line.len {
        ch := line[i]
        if ch == `$` && i > 0 && line[i - 1] == `\\` {
            sb.write_u8(ch)
            i++
            continue
        }
        if ch == `$` && i + 1 < line.len && (line[i + 1].is_letter() || line[i + 1] == `_`) {
            mut j := i + 1
            for j < line.len && (line[j].is_letter() || line[j].is_digit() || line[j] == `_`) {
                j++
            }
            name := line[i + 1..j]
            if token.is_key(name) {
                // Force keyword names into the escaped identifier form to avoid parser/scanner issues.
                sb.write_string('\${@${name}}')
                i = j
                continue
            }
        }
        sb.write_u8(ch)
        i++
    }
    return sb.str()
}

struct TmplControlLine {
    header              string
    inline_body         string
    prefix              string
    has_inline_body     bool
    opens_brace_block   bool
    closes_inline_block bool
}

fn parse_tmpl_control_line(line string, directive string) TmplControlLine {
    pos := line.index(directive) or { return TmplControlLine{} }
    remainder := line[pos + directive.len..].trim_space()
    if remainder.len == 0 {
        return TmplControlLine{
            prefix: line[..pos]
        }
    }
    if remainder.ends_with('{') {
        return TmplControlLine{
            header:            remainder[..remainder.len - 1].trim_space()
            prefix:            line[..pos]
            opens_brace_block: true
        }
    }
    if !remainder.ends_with('}') {
        return TmplControlLine{
            header: remainder
            prefix: line[..pos]
        }
    }
    close_pos := remainder.last_index('}') or {
        return TmplControlLine{
            header: remainder
            prefix: line[..pos]
        }
    }
    open_pos := remainder.index('{') or {
        return TmplControlLine{
            header: remainder
            prefix: line[..pos]
        }
    }
    return TmplControlLine{
        header:              remainder[..open_pos].trim_space()
        inline_body:         remainder[open_pos + 1..close_pos].trim_space()
        prefix:              line[..pos]
        has_inline_body:     open_pos + 1 < close_pos
        opens_brace_block:   true
        closes_inline_block: true
    }
}

fn parse_tmpl_else_line(line string) TmplControlLine {
    pos := line.index('@else') or { return TmplControlLine{} }
    remainder := line[pos + '@else'.len..].trim_space()
    if remainder.len == 0 {
        return TmplControlLine{
            header: 'else'
            prefix: line[..pos]
        }
    }
    if remainder.ends_with('{') {
        suffix := remainder[..remainder.len - 1].trim_space()
        return TmplControlLine{
            header:            if suffix.len == 0 { 'else' } else { 'else ${suffix}' }
            prefix:            line[..pos]
            opens_brace_block: true
        }
    }
    if !remainder.ends_with('}') {
        return TmplControlLine{
            header: if remainder.len == 0 { 'else' } else { 'else ${remainder}' }
            prefix: line[..pos]
        }
    }
    close_pos := remainder.last_index('}') or {
        return TmplControlLine{
            header: if remainder.len == 0 { 'else' } else { 'else ${remainder}' }
            prefix: line[..pos]
        }
    }
    open_pos := remainder.index('{') or {
        return TmplControlLine{
            header: if remainder.len == 0 { 'else' } else { 'else ${remainder}' }
            prefix: line[..pos]
        }
    }
    suffix := remainder[..open_pos].trim_space()
    return TmplControlLine{
        header:              if suffix.len == 0 { 'else' } else { 'else ${suffix}' }
        inline_body:         remainder[open_pos + 1..close_pos].trim_space()
        prefix:              line[..pos]
        has_inline_body:     open_pos + 1 < close_pos
        opens_brace_block:   true
        closes_inline_block: true
    }
}

enum TmplBraceBlockKind {
    control
    div
    span
}

fn (mut p Parser) append_tmpl_line_info(template_file string, tmpl_line int, count int) {
    for _ in 0 .. count {
        p.template_line_map << ast.TemplateLineInfo{
            tmpl_path: template_file
            tmpl_line: tmpl_line
        }
    }
}

// struct to track dependecies and cache templates for reuse without io
struct DependencyCache {
pub mut:
    dependencies map[string][]string
    cache        map[string][]string
}

// custom error to handle issues when including template files
struct IncludeError {
    Error
pub:
    calling_file string
    line_nr      int
    position     int
    col          u16
    message      string
}

fn (err IncludeError) msg() string {
    return err.message
}

fn (err IncludeError) line_nr() int {
    return err.line_nr
}

fn (err IncludeError) pos() int {
    return err.position
}

fn (err IncludeError) calling_file() string {
    return err.calling_file
}

fn (err IncludeError) col() u16 {
    return err.col
}

struct TmplInclude {
    path     string
    position int
}

fn tmpl_include_path_error(calling_file string, line_nr int, position int) IError {
    return &IncludeError{
        calling_file: calling_file
        line_nr:      line_nr
        position:     position
        col:          u16(position)
        message:      'path for @include must be quoted with \' or "'
    }
}

fn parse_tmpl_include_path(calling_file string, line_nr int, line string) !TmplInclude {
    include_pos := line.index('@include ') or { 0 }
    mut quote_pos := include_pos + '@include '.len
    for quote_pos < line.len && line[quote_pos].is_space() {
        quote_pos++
    }
    if quote_pos >= line.len || (line[quote_pos] != `'` && line[quote_pos] != `"`) {
        return tmpl_include_path_error(calling_file, line_nr, quote_pos)
    }
    quote := line[quote_pos]
    mut end_pos := quote_pos + 1
    for end_pos < line.len && line[end_pos] != quote {
        end_pos++
    }
    if end_pos >= line.len {
        return tmpl_include_path_error(calling_file, line_nr, quote_pos)
    }
    return TmplInclude{
        path:     line[quote_pos + 1..end_pos]
        position: quote_pos
    }
}

fn (mut p Parser) process_includes(calling_file string, line_number int, line string, mut dc DependencyCache) ![]string {
    base_path := os.dir(calling_file)
    mut tline_number := line_number
    include := parse_tmpl_include_path(calling_file, tline_number, line)!
    mut file_name := include.path
    mut file_ext := os.file_ext(file_name)
    if file_ext == '' {
        file_ext = '.html'
    }
    file_name = file_name.replace(file_ext, '')
    mut file_path := os.real_path(os.join_path_single(base_path, '${file_name}${file_ext}'))

    if !os.exists(file_path) && !file_name.contains('../') {
        // the calling file is probably original way (relative to calling file) and works from the root folder
        path_arr := base_path.split_any('/\\')
        idx := path_arr.index('templates')
        root_path := path_arr[..idx + 1].join('/')
        file_name = file_name.rsplit('../')[0]
        file_path = os.real_path(os.join_path_single(root_path, '${file_name}${file_ext}'))
    }

    // If file hasnt been called before then add to dependency tree
    if file_path !in dc.dependencies {
        dc.dependencies[file_path] = []string{}
    }
    if !dc.dependencies[file_path].contains(calling_file) {
        dc.dependencies[file_path] << calling_file
    }

    // Circular import detection
    for callee in dc.dependencies[file_path] {
        if dc.dependencies[callee].contains(file_path) {
            return &IncludeError{
                calling_file: calling_file
                line_nr:      tline_number
                position:     line.index('@include ') or { 0 }
                message:      'A recursive call is being made on template ${file_name}'
            }
        }
    }
    mut file_content := []string{}
    if file_path in dc.cache {
        file_content = dc.cache[file_path]
    } else {
        file_content = os.read_lines(file_path) or {
            position := include.position
            return &IncludeError{
                calling_file: calling_file
                line_nr:      tline_number // line_number
                position:     position
                message:      'Reading file `${file_name}` from path: ${file_path} failed'
            }
        }
    }
    // no errors detected in calling file - reset tline_number (error reporting)
    tline_number = 1

    // loop over the imported file
    for i, l in file_content {
        if l.contains('@include ') {
            processed := p.process_includes(file_path, tline_number, l, mut dc) or { return err }
            file_content.delete(i) // remove the include line
            for processed_line in processed.reverse() {
                file_content.insert(i, processed_line)
                tline_number--
            }
        }
    }
    // Add template to parser for reloading
    p.template_paths << file_path
    // Add the imported template to the cache
    dc.cache[file_path] = file_content
    return file_content
}

// compile_file compiles the content of a file by the given path as a template
pub fn (mut p Parser) compile_template_file(template_file string, fn_name string) string {
    mut lines := os.read_lines(template_file) or {
        p.error('reading from ${template_file} failed')
        return ''
    }
    p.template_paths << template_file
    // create a new Dependency tree & cache any templates to avoid further io
    mut dc := DependencyCache{}
    lstartlength := lines.len * 30
    tmpl_str_start := "\tsb_${fn_name}.write_string('"
    mut source := strings.new_builder(1000)

    // Reset line mapping for this template compilation
    p.template_line_map = []

    source.writeln('
import strings
// === veb html template for file: ${template_file} ===
fn veb_tmpl_${fn_name}() string {
    mut sb_${fn_name} := strings.new_builder(${lstartlength})\n

')
    // Header adds 8 lines (0: empty, 1: import, 2: comment, 3: fn, 4: builder, 5: empty from \n escape, 6: empty from literal, 7: empty from writeln)
    // Pre-fill the line map with placeholder entries for header lines
    for _ in 0 .. 8 {
        p.template_line_map << ast.TemplateLineInfo{
            tmpl_path: template_file
            tmpl_line: 0
        }
    }

    source.write_string(tmpl_str_start)

    mut state := State.simple
    template_ext := os.file_ext(template_file)
    if template_ext.to_lower_ascii() == '.html' {
        state = .html
    }

    mut in_html_comment := false
    mut brace_block_kinds := []TmplBraceBlockKind{}
    mut end_of_line_pos := 0
    mut start_of_line_pos := 0
    mut tline_number := -1 // keep the original line numbers, even after insert/delete ops on lines; `i` changes
    for i := 0; i < lines.len; i++ {
        line := lines[i]
        trimmed_line := line.trim_space()
        tline_number++
        start_of_line_pos = end_of_line_pos
        end_of_line_pos += line.len + 1
        if state != .simple {
            state.update(line)
        }
        $if trace_tmpl ? {
            eprintln('>>> tfile: ${template_file}, spos: ${start_of_line_pos:6}, epos:${end_of_line_pos:6}, fi: ${tline_number:5}, i: ${i:5}, state: ${state:10}, line: ${line}')
        }
        // Track HTML comments: skip @-interpolation inside <!-- ... -->
        if state == .html {
            if in_html_comment {
                if line.contains('-->') {
                    in_html_comment = false
                }
                // Output comment line literally (no @-interpolation)
                escaped := line.replace('\\', '\\\\').replace("'", "\\'")
                source.writeln(escaped)
                p.template_line_map << ast.TemplateLineInfo{
                    tmpl_path: template_file
                    tmpl_line: tline_number
                }
                continue
            }
            if line.contains('<!--') {
                if !line.contains('-->') {
                    in_html_comment = true
                }
                // Single-line or start of multi-line comment: output literally
                escaped := line.replace('\\', '\\\\').replace("'", "\\'")
                source.writeln(escaped)
                p.template_line_map << ast.TemplateLineInfo{
                    tmpl_path: template_file
                    tmpl_line: tline_number
                }
                continue
            }
        }
        if line.contains('@header') {
            position := line.index('@header') or { 0 }
            p.error_with_error(errors.Error{
                message:   "Please use @include 'header' instead of @header (deprecated)"
                file_path: template_file
                pos:       token.Pos{
                    len:       '@header'.len
                    line_nr:   tline_number
                    pos:       start_of_line_pos + position
                    last_line: lines.len
                }
                reporter:  .parser
            })
            continue
        }
        if line.contains('@footer') {
            position := line.index('@footer') or { 0 }
            p.error_with_error(errors.Error{
                message:   "Please use @include 'footer' instead of @footer (deprecated)"
                file_path: template_file
                pos:       token.Pos{
                    len:       '@footer'.len
                    line_nr:   tline_number
                    pos:       start_of_line_pos + position
                    last_line: lines.len
                }
                reporter:  .parser
            })
            continue
        }
        if line.contains('@include ') {
            lines.delete(i)
            resolved := p.process_includes(template_file, tline_number, line, mut &dc) or {
                if err is IncludeError {
                    p.error_with_error(errors.Error{
                        message:   err.msg()
                        file_path: err.calling_file()
                        pos:       token.Pos{
                            len:       '@include '.len
                            line_nr:   err.line_nr()
                            pos:       start_of_line_pos + err.pos()
                            col:       err.col()
                            last_line: lines.len
                        }
                        reporter:  .parser
                    })
                    []string{}
                } else {
                    p.error_with_error(errors.Error{
                        message:   'An unknown error has occurred'
                        file_path: template_file
                        pos:       token.Pos{
                            len:       '@include '.len
                            line_nr:   tline_number
                            pos:       start_of_line_pos
                            last_line: lines.len
                        }
                        reporter:  .parser
                    })
                    []string{}
                }
            }
            for resolved_line in resolved.reverse() {
                tline_number--
                lines.insert(i, resolved_line)
            }

            i--
            continue
        }
        if trimmed_line == '}' && brace_block_kinds.len > 0 && brace_block_kinds.last() == .control {
            source.writeln(tmpl_str_end)
            // tmpl_str_end contains '\n', so writeln creates 2 lines: ')' and empty
            p.append_tmpl_line_info(template_file, tline_number, 2)
            source.writeln('}')
            p.append_tmpl_line_info(template_file, tline_number, 1)
            source.write_string(tmpl_str_start)
            brace_block_kinds.delete_last()
            continue
        }
        if line.contains('@if ') {
            control := parse_tmpl_control_line(line, '@if')
            source.writeln(tmpl_str_end)
            // tmpl_str_end contains '\n', so writeln creates 2 lines: ')' and empty
            p.append_tmpl_line_info(template_file, tline_number, 2)
            source.writeln('if ${control.header} {')
            p.append_tmpl_line_info(template_file, tline_number, 1)
            source.write_string(tmpl_str_start)
            if control.has_inline_body {
                source.writeln(insert_template_code(fn_name, tmpl_str_start, control.prefix +
                    control.inline_body))
                p.append_tmpl_line_info(template_file, tline_number, 1)
            }
            if control.closes_inline_block {
                source.writeln(tmpl_str_end)
                // tmpl_str_end contains '\n', so writeln creates 2 lines: ')' and empty
                p.append_tmpl_line_info(template_file, tline_number, 2)
                source.writeln('}')
                p.append_tmpl_line_info(template_file, tline_number, 1)
                source.write_string(tmpl_str_start)
            } else if control.opens_brace_block {
                brace_block_kinds << .control
            }
            continue
        }
        if line.contains('@end') {
            source.writeln(tmpl_str_end)
            // tmpl_str_end contains '\n', so writeln creates 2 lines: ')' and empty
            p.append_tmpl_line_info(template_file, tline_number, 2)
            source.writeln('}')
            p.append_tmpl_line_info(template_file, tline_number, 1)
            source.write_string(tmpl_str_start)
            if brace_block_kinds.len > 0 && brace_block_kinds.last() == .control {
                brace_block_kinds.delete_last()
            }
            continue
        }
        if line.contains('@else') {
            control := parse_tmpl_else_line(line)
            source.writeln(tmpl_str_end)
            // tmpl_str_end contains '\n', so writeln creates 2 lines: ')' and empty
            p.append_tmpl_line_info(template_file, tline_number, 2)
            source.writeln('} ${control.header} {')
            p.append_tmpl_line_info(template_file, tline_number, 1)
            source.write_string(tmpl_str_start)
            if control.has_inline_body {
                source.writeln(insert_template_code(fn_name, tmpl_str_start, control.prefix +
                    control.inline_body))
                p.append_tmpl_line_info(template_file, tline_number, 1)
            }
            if control.closes_inline_block {
                source.writeln(tmpl_str_end)
                // tmpl_str_end contains '\n', so writeln creates 2 lines: ')' and empty
                p.append_tmpl_line_info(template_file, tline_number, 2)
                source.writeln('}')
                p.append_tmpl_line_info(template_file, tline_number, 1)
                source.write_string(tmpl_str_start)
                if brace_block_kinds.len > 0 && brace_block_kinds.last() == .control {
                    brace_block_kinds.delete_last()
                }
            }
            continue
        }
        if line.contains('@for') {
            control := parse_tmpl_control_line(line, '@for')
            source.writeln(tmpl_str_end)
            // tmpl_str_end contains '\n', so writeln creates 2 lines: ')' and empty
            p.append_tmpl_line_info(template_file, tline_number, 2)
            source.writeln('for ${control.header} {')
            p.append_tmpl_line_info(template_file, tline_number, 1)
            source.write_string(tmpl_str_start)
            if control.has_inline_body {
                source.writeln(insert_template_code(fn_name, tmpl_str_start, control.prefix +
                    control.inline_body))
                p.append_tmpl_line_info(template_file, tline_number, 1)
            }
            if control.closes_inline_block {
                source.writeln(tmpl_str_end)
                // tmpl_str_end contains '\n', so writeln creates 2 lines: ')' and empty
                p.append_tmpl_line_info(template_file, tline_number, 2)
                source.writeln('}')
                p.append_tmpl_line_info(template_file, tline_number, 1)
                source.write_string(tmpl_str_start)
            } else if control.opens_brace_block {
                brace_block_kinds << .control
            }
            continue
        }
        if state == .simple {
            // by default, just copy 1:1
            source.writeln(insert_template_code(fn_name, tmpl_str_start, line))
            p.append_tmpl_line_info(template_file, tline_number, 1)
            continue
        }
        // in_write = false
        // The .simple mode ends here. The rest handles .html/.css/.js state transitions.

        if state != .simple {
            if line.contains('@js ') {
                pos := line.index('@js') or { continue }
                source.write_string('<script src="')
                source.write_string(line[pos + 5..line.len - 1])
                source.writeln('"></script>')
                p.template_line_map << ast.TemplateLineInfo{
                    tmpl_path: template_file
                    tmpl_line: tline_number
                }
                continue
            }
            if line.contains('@css ') {
                pos := line.index('@css') or { continue }
                source.write_string('<link href="')
                source.write_string(line[pos + 6..line.len - 1])
                source.writeln('" rel="stylesheet" type="text/css">')
                p.template_line_map << ast.TemplateLineInfo{
                    tmpl_path: template_file
                    tmpl_line: tline_number
                }
                continue
            }
        }

        match state {
            .html {
                line_t := line.trim_space()
                if line_t.starts_with('span.') && line.ends_with('{') {
                    // `span.header {` => `<span class='header'>`
                    class := line.find_between('span.', '{').trim_space()
                    source.writeln('<span class="${class}">')
                    p.template_line_map << ast.TemplateLineInfo{
                        tmpl_path: template_file
                        tmpl_line: tline_number
                    }
                    brace_block_kinds << .span
                    continue
                } else if line_t.starts_with('.') && line.ends_with('{') {
                    // `.header {` => `<div class='header'>`
                    class := line.find_between('.', '{').trim_space()
                    trimmed := line.trim_space()
                    source.write_string(strings.repeat(`\t`, line.len - trimmed.len)) // add the necessary indent to keep <div><div><div> code clean
                    source.writeln('<div class="${class}">')
                    p.template_line_map << ast.TemplateLineInfo{
                        tmpl_path: template_file
                        tmpl_line: tline_number
                    }
                    brace_block_kinds << .div
                    continue
                } else if line_t.starts_with('#') && line.ends_with('{') {
                    // `#header {` => `<div id='header'>`
                    class := line.find_between('#', '{').trim_space()
                    source.writeln('<div id="${class}">')
                    p.template_line_map << ast.TemplateLineInfo{
                        tmpl_path: template_file
                        tmpl_line: tline_number
                    }
                    brace_block_kinds << .div
                    continue
                } else if line_t == '}' {
                    source.write_string(strings.repeat(`\t`, line.len - line_t.len)) // add the necessary indent to keep <div><div><div> code clean
                    if brace_block_kinds.len > 0 && brace_block_kinds.last() == .span {
                        source.writeln('</span>')
                        brace_block_kinds.delete_last()
                    } else {
                        source.writeln('</div>')
                        if brace_block_kinds.len > 0 && brace_block_kinds.last() == .div {
                            brace_block_kinds.delete_last()
                        }
                    }
                    p.template_line_map << ast.TemplateLineInfo{
                        tmpl_path: template_file
                        tmpl_line: tline_number
                    }
                    continue
                }
            }
            .js {
                // if line.contains('//V_TEMPLATE') {
                source.writeln(insert_template_code(fn_name, tmpl_str_start, line))
                p.template_line_map << ast.TemplateLineInfo{
                    tmpl_path: template_file
                    tmpl_line: tline_number
                }
                //} else {
                // replace `$` to `\$` at first to escape JavaScript template literal syntax
                // source.writeln(line.replace(r'$', r'\$').replace(r'$$', r'@').replace(r'.$',
                // r'.@').replace(r"'", r"\'"))
                //}
                continue
            }
            .css {
                // disable template variable declaration in inline stylesheet
                // because of  some CSS rules prefixed with `@`.
                source.writeln(line.replace(r'.$', r'.@').replace(r"'", r"\'"))
                p.template_line_map << ast.TemplateLineInfo{
                    tmpl_path: template_file
                    tmpl_line: tline_number
                }
                continue
            }
            else {}
        }

        // %translation_key => ${tr('translation_key')}
        // Process all %key patterns on this line
        mut line_ := line
        mut search_start := 0
        for {
            pos := line_.index_after('%', search_start) or { break }
            is_raw := pos + 4 < line_.len && line_[pos..pos + 5] == '%raw '
            if is_raw {
                // Start reading the key after "raw " (pos + 5)
                mut end := pos + 5
                // valid variable characters
                for end < line_.len && (line_[end].is_letter() || line_[end] == `_`) {
                    end++
                }
                // Extract the key
                key := line_[pos + 5..end]
                if key.len > 0 {
                    // Replace '%raw key' with just '${key}'
                    line_ = line_.replace('%raw ${key}',
                        '\${veb.raw(veb.tr(ctx.lang.str(), "${key}"))}')
                }
                search_start = pos + 1
            } else {
                if pos + 1 < line_.len && line_[pos + 1].is_letter() {
                    mut end := pos + 1
                    for end < line_.len && (line_[end].is_letter() || line_[end] == `_`) {
                        end++
                    }
                    key := line_[pos + 1..end]
                    // println('GOT tr key line="${line_}" key="${key}"')
                    line_ = line_.replace('%${key}', '\${veb.tr(ctx.lang.str(), "${key}")}')
                    search_start = pos + 1
                } else {
                    // Not a valid translation key, skip this %
                    search_start = pos + 1
                }
            }
        }
        if line_ != line {
            source.writeln(insert_template_code(fn_name, tmpl_str_start, line_))
            p.template_line_map << ast.TemplateLineInfo{
                tmpl_path: template_file
                tmpl_line: tline_number
            }
        } else {
            // by default, just copy 1:1
            source.writeln(insert_template_code(fn_name, tmpl_str_start, line))
            p.template_line_map << ast.TemplateLineInfo{
                tmpl_path: template_file
                tmpl_line: tline_number
            }
        }
    }

    source.writeln(tmpl_str_end)
    source.writeln('\t_tmpl_res_${fn_name} := sb_${fn_name}.str() ')
    source.writeln('\treturn _tmpl_res_${fn_name}')
    source.writeln('}')
    source.writeln('// === end of veb html template_file: ${template_file} ===')

    mut result := source.str()
    if result.contains('veb.') {
        result = 'import veb\n' + result
    }
    $if trace_tmpl_expansion ? {
        eprintln('>>>>>>> template expanded to:')
        eprintln(result)
        eprintln('-----------------------------')
    }

    return result
}