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

// parse_and_transform reads parse and transform input for v3 tests.
fn parse_and_transform(source string) &flat.FlatAst {
    src := os.join_path(os.temp_dir(), 'v3_struct_default_transform_test.v')
    os.write_file(src, source) or { panic(err) }
    prefs := pref.new_preferences()
    mut p := parser.Parser.new(prefs)
    mut a := p.parse_file(src)
    mut tc := types.TypeChecker.new(a)
    tc.collect(a)
    tc.annotate_types()
    transform.transform(mut a, &tc)
    return a
}

// transformed_struct_init supports transformed struct init handling for v3 tests.
fn transformed_struct_init(a &flat.FlatAst, fn_name string) flat.Node {
    for node in a.nodes {
        if node.kind != .fn_decl || node.value != fn_name {
            continue
        }
        for i in 0 .. node.children_count {
            stmt := a.child_node(&node, i)
            if stmt.kind != .decl_assign || stmt.children_count < 2 {
                continue
            }
            rhs := a.child_node(stmt, 1)
            if rhs.kind == .struct_init {
                return *rhs
            }
        }
    }
    assert false
    return flat.Node{}
}

// find_field resolves find field information for v3 tests.
fn find_field(a &flat.FlatAst, node flat.Node, name string) flat.Node {
    for i in 0 .. node.children_count {
        field := a.child_node(&node, i)
        if field.kind == .field_init && field.value == name {
            return *field
        }
    }
    assert false
    return flat.Node{}
}

// call_name updates call name state for v3 tests.
fn call_name(a &flat.FlatAst, call flat.Node) string {
    if call.kind != .call || call.children_count == 0 {
        return ''
    }
    return a.child_node(&call, 0).value
}

// test_transform_fills_missing_struct_defaults validates this v3 regression case.
fn test_transform_fills_missing_struct_defaults() {
    mut a := parse_and_transform("
struct Person {
    name string = 'v' + '3'
    age int = 42
}

fn main() {
    person := Person{age: 7}
}
")
    init := transformed_struct_init(a, 'main')
    assert init.value == 'Person'
    assert init.children_count == 2

    name_field := find_field(a, init, 'name')
    name_value := a.child_node(&name_field, 0)
    assert name_value.kind == .string_literal
    assert name_value.value == 'v3'

    age_field := find_field(a, init, 'age')
    age_value := a.child_node(&age_field, 0)
    assert age_value.kind == .int_literal
    assert age_value.value == '7'
}