import os
import v3.flat
import v3.parser
import v3.pref
import v3.types

// parse_parser_regression_source reads parse parser regression source input for v3 tests.
fn parse_parser_regression_source(name string, source string) &flat.FlatAst {
    src := os.join_path(os.temp_dir(), 'v3_${name}.v')
    os.write_file(src, source) or { panic(err) }
    mut prefs := pref.new_preferences()
    mut p := parser.Parser.new(prefs)
    p.parse_into(src)
    return p.a
}

fn parse_parser_regression_sources(name string, sources []string) &flat.FlatAst {
    mut prefs := pref.new_preferences()
    mut p := parser.Parser.new(prefs)
    for i, source in sources {
        src := os.join_path(os.temp_dir(), 'v3_${name}_${i}.v')
        os.write_file(src, source) or { panic(err) }
        p.parse_into(src)
    }
    return p.a
}

// interface_method_param_types supports interface method param types handling for v3 tests.
fn interface_method_param_types(a &flat.FlatAst, iface string, method string) []string {
    for node in a.nodes {
        if node.kind != .interface_decl || node.value != iface {
            continue
        }
        for i in 0 .. node.children_count {
            field := a.child_node(&node, i)
            if field.kind != .interface_field || field.value != method {
                continue
            }
            mut params := []string{}
            for j in 0 .. field.children_count {
                param := a.child_node(field, j)
                if param.kind == .param {
                    params << param.typ
                }
            }
            return params
        }
    }
    return []string{}
}

fn fn_decl_param_pairs(a &flat.FlatAst, kind flat.NodeKind, name string) []string {
    for node in a.nodes {
        if node.kind != kind || node.value != name {
            continue
        }
        mut pairs := []string{}
        for i in 0 .. node.children_count {
            param := a.child_node(&node, i)
            if param.kind == .param {
                pairs << '${param.value}:${param.typ}'
            }
        }
        return pairs
    }
    return []string{}
}

// test_interface_method_generic_type_only_param_is_not_parsed_as_name
// validates this v3 regression case.
fn test_interface_method_generic_type_only_param_is_not_parsed_as_name() {
    a := parse_parser_regression_source('interface_generic_param',
        'const max_len = 16\nstruct Result[T] {}\nstruct Node {}\n\ninterface Sink {\n\tput(Result[int])\n\tappend(values []int)\n\tvisit(node &Node)\n\tread(buf [max_len]u8)\n}\n')
    assert interface_method_param_types(a, 'Sink', 'put') == ['Result[int]']
    assert interface_method_param_types(a, 'Sink', 'append') == ['[]int']
    assert interface_method_param_types(a, 'Sink', 'visit') == ['&Node']
    assert interface_method_param_types(a, 'Sink', 'read') == ['[max_len]u8']
}

fn test_c_function_anonymous_params_are_parsed_as_types() {
    a := parse_parser_regression_source('c_anon_params',
        'struct T {}\nstruct C.FILE {}\nstruct C.Widget {}\nstruct C.Node {}\ntype MyHandle = voidptr\n\nfn C.anon(&C.FILE, voidptr, int, &&T, [4]&C.Widget, ?&C.Node, !&C.Node, fn (&C.Node) int) int\nfn C.custom(MyHandle, int, MyHandle) int\nfn C.lower(size_t, int, pthread_t) int\nfn C.named(stream &C.FILE, a, b int) int\nfn C.named_custom(handle MyHandle, a, b int) int\nfn C.named_arrays(m [16]f32, r []rune) int\nfn C.variadic(...int) int\nfn JS.js_anon(JS.Number) JS.Number\nfn JS.js_named(x JS.Number) JS.Number\nfn JS.setInterval(any, int, ...any) int\nfn JS.console.dir(any, any)\nfn JS.named_any(x any) any\nfn ordinary(int) {}\n')
    assert fn_decl_param_pairs(a, .c_fn_decl, 'anon') == [
        ':&C.FILE',
        ':voidptr',
        ':int',
        ':&&T',
        ':[4]&C.Widget',
        ':?&C.Node',
        ':!&C.Node',
        ':fn(&C.Node) int',
    ]
    assert fn_decl_param_pairs(a, .c_fn_decl, 'custom') == [
        ':MyHandle',
        ':int',
        ':MyHandle',
    ]
    assert fn_decl_param_pairs(a, .c_fn_decl, 'lower') == [
        ':size_t',
        ':int',
        ':pthread_t',
    ]
    assert fn_decl_param_pairs(a, .c_fn_decl, 'named') == [
        'stream:&C.FILE',
        'a:int',
        'b:int',
    ]
    assert fn_decl_param_pairs(a, .c_fn_decl, 'named_custom') == [
        'handle:MyHandle',
        'a:int',
        'b:int',
    ]
    assert fn_decl_param_pairs(a, .c_fn_decl, 'named_arrays') == [
        'm:[16]f32',
        'r:[]rune',
    ]
    assert fn_decl_param_pairs(a, .c_fn_decl, 'variadic') == [':...int']
    assert fn_decl_param_pairs(a, .c_fn_decl, 'js_anon') == [':JS.Number']
    assert fn_decl_param_pairs(a, .c_fn_decl, 'js_named') == ['x:JS.Number']
    assert fn_decl_param_pairs(a, .c_fn_decl, 'setInterval') == [
        ':any',
        ':int',
        ':...any',
    ]
    assert fn_decl_param_pairs(a, .c_fn_decl, 'console.dir') == [
        ':any',
        ':any',
    ]
    assert fn_decl_param_pairs(a, .c_fn_decl, 'named_any') == ['x:any']
    assert fn_decl_param_pairs(a, .fn_decl, 'ordinary') == ['int:']
}

fn test_moduleless_file_does_not_inherit_previous_parser_module() {
    a := parse_parser_regression_sources('moduleless_export', [
        'module expmod\n\nfn helper() {}\n',
        "@[export: '1bad']\nfn lonely() {}\n",
    ])
    mut tc := types.TypeChecker.new(a)
    tc.collect(a)
    tc.check_semantics()
    assert tc.errors.len == 1, tc.errors.str()
    assert tc.errors[0].msg.contains('for `lonely`'), tc.errors.str()
    assert !tc.errors[0].msg.contains('expmod.lonely'), tc.errors.str()
    assert fn_decl_param_pairs(a, .fn_decl, 'lonely') == []
}

fn test_sql_identifier_calls_are_not_parsed_as_sql_expr() {
    a := parse_parser_regression_source('sql_identifier_call',
        'fn sql(x int) int {\n\treturn x + 1\n}\n\nfn main() {\n\tx := sql(2)\n\tsql := 1\n\t_ := sql + 2\n}\n')
    mut sql_expr_count := 0
    mut call_count := 0
    for node in a.nodes {
        if node.kind == .sql_expr {
            sql_expr_count++
        }
        if node.kind == .call {
            call_count++
        }
    }
    assert sql_expr_count == 0
    assert call_count == 1
}