// Copyright (c) 2026 Alexander Medvednikov. All rights reserved.
// Use of this source code is governed by an MIT license
// that can be found in the LICENSE file.
// vtest build: macos
//
// Bit-equality pin for s180: `build_module_from_flat` (fifth per-kind port
// inside the s175 seam) must set `b.cur_module` to the same dotted-to-
// underscore form as the legacy `ast.ModuleStmt` arm in `build_stmt`. The
// flat path drops the ModuleStmt struct decode entirely and reads the
// module name straight from `c.name()`.
module ssa

import v2.ast
import v2.types

// Fixture: a file with `module foo.bar` (dotted name to exercise the
// `.replace('.', '_')`). No fns — we test the seam by directly driving
// `build_stmt`/`build_stmt_from_flat` on the file's top-level stmts list.
fn make_module_fixture() []ast.File {
    return [
        ast.File{
            name:  'main.v'
            mod:   'foo.bar'
            stmts: [
                ast.Stmt(ast.ModuleStmt{
                    name: 'foo.bar'
                }),
            ]
        },
    ]
}

fn test_build_module_from_flat_matches_legacy() {
    files := make_module_fixture()
    flat := ast.flatten_files(files)
    env := types.Environment.new()

    mut mod_legacy := Module.new('mod_legacy')
    mut b_legacy := Builder.new_with_env(mod_legacy, env)
    b_legacy.build_stmts(files[0].stmts)

    mut mod_flat := Module.new('mod_flat')
    mut b_flat := Builder.new_with_env(mod_flat, env)
    b_flat.build_stmts_from_flat(flat.file_cursor(0).stmts())

    // Both paths must transform 'foo.bar' → 'foo_bar' on b.cur_module.
    assert b_legacy.cur_module == 'foo_bar'
    assert b_flat.cur_module == b_legacy.cur_module
    // And neither path emits any SSA for a ModuleStmt.
    assert mod_legacy.instrs.len == mod_flat.instrs.len
    assert mod_legacy.blocks.len == mod_flat.blocks.len
    assert mod_legacy.values.len == mod_flat.values.len
}

fn test_module_import_aliases_keep_nested_module_path() {
    aliases := module_import_aliases_from_imports([
        ast.ImportStmt{
            name:  'foo.bar'
            alias: 'bar'
        },
        ast.ImportStmt{
            name:       'foo.baz'
            alias:      'qux'
            is_aliased: true
        },
    ])
    assert aliases['bar'] == 'foo.bar'
    assert aliases['qux'] == 'foo.baz'
}

fn test_selective_import_fn_names_keep_nested_module_path() {
    names := selective_import_fn_names_from_imports([
        ast.ImportStmt{
            name:    'foo.bar'
            alias:   'bar'
            symbols: [
                ast.Expr(ast.Ident{
                    name: 'leaf'
                }),
            ]
        },
    ])
    assert names['leaf'] == 'foo_bar__leaf'
}

fn test_selective_import_fn_candidates_try_nested_path_then_leaf_module() {
    candidates := selective_import_fn_candidates_from_imports([
        ast.ImportStmt{
            name:    'foo.bar'
            alias:   'bar'
            symbols: [
                ast.Expr(ast.Ident{
                    name: 'leaf'
                }),
            ]
        },
    ])
    assert candidates['leaf'] == ['foo_bar__leaf', 'bar__leaf']

    mut mod_full := Module.new('selective_full')
    mut b_full := Builder.new_with_env(mod_full, types.Environment.new())
    b_full.selective_import_fn_candidates = candidates.clone()
    b_full.fn_index['foo_bar__leaf'] = 0
    b_full.fn_index['bar__leaf'] = 1
    resolved_full := b_full.selective_import_fn_name('leaf') or { '' }
    assert resolved_full == 'foo_bar__leaf'

    mut mod_leaf := Module.new('selective_leaf')
    mut b_leaf := Builder.new_with_env(mod_leaf, types.Environment.new())
    b_leaf.selective_import_fn_candidates = candidates.clone()
    b_leaf.fn_index['bar__leaf'] = 1
    resolved_leaf := b_leaf.selective_import_fn_name('leaf') or { '' }
    assert resolved_leaf == 'bar__leaf'
}