// vtest retry: 2
// vtest build: !windows
module main

import os
import arrays
import v.ast
import document as doc
import markdown

const vexe_path = @VEXE
const vexe_ = os.quoted_path(vexe_path)
const tpath = os.join_path(os.vtmp_dir(), 'vod_test_module')

fn testsuite_begin() {
    os.rmdir_all(tpath) or {}
    os.mkdir_all(tpath)!
    os.chdir(tpath)!
}

fn testsuite_end() {
    os.rmdir_all(tpath) or {}
}

fn test_trim_doc_node_description() {
    mod := 'foo'
    mut readme := '## Description

`foo` is a module that provides tools and utility functions to assist in working with bar.
It also assists with composing and testing baz.'
    expected := 'is a module that provides tools and utility functions to assist in working with'
    res := trim_doc_node_description(mod, readme).trim_space()
    assert res == expected

    readme = '# Foo
`foo` is a module that provides tools and utility functions to assist in working with bar.
It also assists with composing and testing baz.'
    res2 := trim_doc_node_description(mod, readme).trim_space()
    assert res2 == res
}

fn test_ignore_rules() {
    os.write_file('.vdocignore', ['pattern1', 'pattern2', '/path1'].join_lines())!
    os.mkdir('subdir')!
    os.write_file(os.join_path('subdir', '.vdocignore'), ['pattern3', '/path2'].join_lines())!
    rules := IgnoreRules.get('.')
    assert rules.patterns['.'] == ['pattern1', 'pattern2']
    assert rules.patterns['./subdir'] == ['pattern3']
    assert rules.paths == {
        './path1':        true
        './subdir/path2': true
    }
}

fn test_get_module_list() {
    // For information on leading slash rules, refer to the comments in `IgnoreRules.get`.
    ignore_rules := ['bravo', '/echo', '/foxtrot/golf', 'hotel.v/', 'india/juliett']
    os.write_file('.vdocignore', ignore_rules.join_lines())!

    /* Create some submodules.
    Modules inside `testdata` and `tests` directories and modules that
    only contain `_test.v` files should be ignored by default. */
    // Modules NOT to ignore.
    submodules_no_ignore := [
        'alpha',
        'alpha_bravo', // test `bravo`
        'bravo_charly', // test `bravo`
        'charly',
        'charly/alpha',
        'charly/delta', // test `delta` in separate ignore file in `alpha`
        'charly/echo', // test `/echo`
        'charly/foxtrot/golf', // test `/foxtrot/golf`
        'foxtrot',
        'golf',
        'hotel', // will include a `hotel.v` file, whose pattern is in the ignore list with a trailing slash
    ]
    // Modules TO ignore.
    submodules_to_ignore := [
        'alpha/bravo', // test `bravo`
        'alpha/delta', // test `delta` in separate ignore file
        'alpha/india/juliett/kilo', // test `india/juliett`
        'bravo', // test `bravo`
        'echo', // test `/echo`
        'foxtrot/golf', // test `/foxtrot/golf`
        'hotel.v', // test `hotel.v/`
        'tests', // test default
        'testdata', // test default
        'testdata/foxtrot', // test default
    ]
    for p in arrays.append(submodules_no_ignore, submodules_to_ignore) {
        os.mkdir_all(p)!
        mod_name := p.all_after_last('/')
        os.write_file(os.join_path(p, '${mod_name}.v'), 'module ${mod_name}')!
    }
    // Create a module that only contains a `_test.v` file.
    os.mkdir('delta')!
    os.write_file(os.join_path('delta', 'delta_test.v'), 'module delta')!
    // Add a `.vdocignore` file to a submodule.
    os.write_file(os.join_path('alpha', '.vdocignore'), 'delta\n')!

    mod_list := get_modules(tpath)
    // dump(mod_list)
    assert mod_list.len == submodules_no_ignore.len
    for m in submodules_no_ignore.map(os.join_path(tpath, it)) {
        assert m in mod_list
    }
    for m in submodules_to_ignore.map(os.join_path(tpath, it)) {
        assert m !in mod_list
    }
    // `delta` only contains a `_test.v` file.
    assert !mod_list.any(it.contains(os.join_path(tpath, 'delta')))
}

fn test_html_highlight_escapes_html_tokens() {
    table := ast.new_table()
    code := 'fn main() {
    // <h1>owned</h1>
    assert 1 < 2
}'
    highlighted := html_highlight(code, table)
    assert highlighted.contains('// <h1>owned</h1>')
    assert !highlighted.contains('<h1>owned</h1>')
    assert highlighted.contains('<span class="token operator"><</span>')
}

fn test_get_readme_md_src() {
    // a special testcase for `src` dir get_readme
    // https://github.com/vlang/v/issues/24232

    os.mkdir('src')!
    os.write_file('v.mod', "Module {
        name: 'foobar'
        description: 'foobar'
        version: '0.0.0'
        license: 'MIT'
        dependencies: []
}
")!
    os.write_file('src/foobar.v', 'module foobar

// square calculates the second power of `x`
pub fn square(x int) int {
        return x * x
}
')!
    res := os.execute_opt('${vexe_} doc -m src/ -v') or { panic(err) }
    assert res.exit_code == 0
    assert res.output.contains('square')
}

fn test_gen_modules_toc_skips_hash_links_for_prefix_only_groups() {
    mut vd := VDoc{
        cfg: Config{
            is_multi: true
        }
    }
    vd.docs = [
        doc.Doc{
            head: doc.DocNode{
                name: 'main'
            }
        },
        doc.Doc{
            head: doc.DocNode{
                name: 'db.mysql'
            }
        },
        doc.Doc{
            head: doc.DocNode{
                name: 'db.sqlite'
            }
        },
    ]
    toc := vd.gen_modules_toc('main')
    assert !toc.contains('href="#"')
    assert toc.contains('<div class="menu-row"><a>db</a></div>')
    assert toc.contains('<li><a href="./db.mysql.html">mysql</a></li>')
}

fn test_gen_modules_toc_uses_prefix_module_page_when_available() {
    mut vd := VDoc{
        cfg: Config{
            is_multi: true
        }
    }
    vd.docs = [
        doc.Doc{
            head: doc.DocNode{
                name: 'db.sqlite'
            }
        },
        doc.Doc{
            head: doc.DocNode{
                name: 'db'
            }
        },
    ]
    toc := vd.gen_modules_toc('db')
    assert toc.contains('<div class="menu-row"><a href="./db.html">db</a></div>')
}

fn test_module_overview_uses_post_module_comment_without_readme() {
    mod_dir := 'module_overview'
    os.mkdir(mod_dir)!
    os.write_file(os.join_path(mod_dir, 'overview.v'), "module overview

// `overview` uses the first comment after the module declaration as the module overview.

pub fn greet() string {
    return 'hello'
}
")!
    res := os.execute_opt('${vexe_} doc -no-timestamp -f text -o - -readme -comments ${os.quoted_path(
        './' + mod_dir)}') or { panic(err) }
    assert res.exit_code == 0
    assert res.output.replace('\r\n', '\n').trim_space() == 'module overview
    `overview` uses the first comment after the module declaration as the module overview.

fn greet() string'
}

fn test_html_keeps_enum_comment_after_top_level_comptime_if() {
    mod_dir := 'issue_23338'
    os.mkdir(mod_dir)!
    os.write_file(os.join_path(mod_dir, 'issue_23338.v'), 'module issue_23338

\$if macos {
}

// Foo lorem ipsum foo.
pub enum Foo {
    foo
}

// Bar ipsum lorem bar.
pub enum Bar {
    bar
}
')!
    res := os.execute_opt('${vexe_} doc -no-timestamp -m -f html -o - -html-only-contents ${os.quoted_path(
        './' + mod_dir)}') or { panic(err) }
    assert res.exit_code == 0
    output := res.output.replace('\r\n', '\n')
    assert output.contains('Foo lorem ipsum foo.')
    assert output.contains('Bar ipsum lorem bar.')
}

fn test_doc_generates_for_modules_without_public_symbols() {
    mod_dir := 'module_without_public_symbols'
    os.mkdir(mod_dir)!
    os.write_file(os.join_path(mod_dir, 'module_without_public_symbols.v'), 'module module_without_public_symbols

const internal = 1
')!
    res := os.execute_opt('${vexe_} doc -no-timestamp -f text -o - ${os.quoted_path('./' + mod_dir)}') or {
        panic(err)
    }
    assert res.exit_code == 0
    assert res.output.replace('\r\n', '\n').trim_space() == 'module module_without_public_symbols'
}

fn test_resolve_relative_markdown_link() {
    base := 'https://github.com/vlang/v/blob/master/vlib/net/html/'
    assert resolve_relative_markdown_link(base, 'parser_test.v') == 'https://github.com/vlang/v/blob/master/vlib/net/html/parser_test.v'
    assert resolve_relative_markdown_link(base, './html_test.v') == 'https://github.com/vlang/v/blob/master/vlib/net/html/html_test.v'
    assert resolve_relative_markdown_link(base, '../README.md#usage') == 'https://github.com/vlang/v/blob/master/vlib/net/README.md#usage'
}

fn test_resolve_relative_markdown_link_keeps_absolute_urls() {
    base := 'https://github.com/vlang/v/blob/master/vlib/net/html/'
    assert resolve_relative_markdown_link(base, 'https://vlang.io') == 'https://vlang.io'
    assert resolve_relative_markdown_link(base, '/rooted/path') == '/rooted/path'
    assert resolve_relative_markdown_link(base, '#local') == '#local'
}

fn test_markdown_renderer_resolves_relative_links() ! {
    base := 'https://github.com/vlang/v/blob/master/vlib/net/html/'
    mut renderer := markdown.HtmlRenderer{
        transformer: &MdHtmlCodeHighlighter{
            table:              ast.new_table()
            relative_link_base: base
        }
    }
    out := markdown.render('More examples in [parser](parser_test.v).', mut renderer)!
    assert out.contains('<a href="https://github.com/vlang/v/blob/master/vlib/net/html/parser_test.v">')
}

fn test_prepare_markdown_for_html_preserves_blockquote_linebreaks() ! {
    mut renderer := markdown.HtmlRenderer{
        transformer: &MdHtmlCodeHighlighter{
            table: ast.new_table()
        }
    }
    out := markdown.render(prepare_markdown_for_html('> **Note**\n> line one\n> line two'), mut
        renderer)!
    assert out.contains('<blockquote>')
    assert out.contains('<strong>Note</strong><br />line one<br />line two')
}

fn test_prepare_markdown_for_html_skips_fenced_code_blocks() {
    input := '```sh\n> prompt\n> next\n```'
    assert prepare_markdown_for_html(input) == input
}

fn test_markdown_renderer_preserves_wrapped_readme_markdown() ! {
    input := '1. The basic atomic elements of this regex engine are the tokens.\n   In a query string a simple character is a token.\n\n- The basic element **is the token not the sequence of symbols**,\n  and the most simple token, is a single character.\n\n- `|` **the OR operator acts on tokens,** for example `abc|ebc` is not\n  `abc` OR `ebc`.'
    mut renderer := markdown.HtmlRenderer{
        transformer: &MdHtmlCodeHighlighter{
            table: ast.new_table()
        }
    }
    out := markdown.render(prepare_markdown_for_html(input), mut renderer)!
    assert !out.contains('tokens.In')
    assert !out.contains('mostsimple')
    assert !out.contains('not<code>abc</code>')
    assert out.contains('tokens. In a query string a simple character is a token.')
    assert out.contains('the most simple token')
    assert out.contains('is not <code>abc</code> OR <code>ebc</code>')
}