// 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 s161: the `post_pass_to_flat` driver must run
// the six flat-aware post_pass steps in the same order as legacy
// `post_pass`, with the same gating, producing a FlatAst whose
// `signature()` matches what legacy `post_pass` + `flatten_files`
// produces. Pins the driver assembly that wires together
// s151/s152/s153/s155/s159/s160's `_to_flat` variants.
module transformer

import v2.ast
import v2.pref as vpref
import v2.types

// Local helper — `v test` compiles each `_test.v` file in isolation.
fn create_post_pass_to_flat_test_transformer() &Transformer {
    env := &types.Environment{}
    return &Transformer{
        pref:                        &vpref.Preferences{}
        env:                         unsafe { env }
        needed_clone_fns:            map[string]string{}
        needed_array_contains_fns:   map[string]ArrayMethodInfo{}
        needed_array_index_fns:      map[string]ArrayMethodInfo{}
        needed_array_last_index_fns: map[string]ArrayMethodInfo{}
        local_decl_types:            map[string]types.Type{}
        runtime_const_inits_by_mod:  map[string][]RuntimeConstInit{}
        runtime_const_init_fn_name:  map[string]string{}
    }
}

fn make_minimal_main_file_with_main_fn() ast.File {
    return ast.File{
        name:  'main.v'
        mod:   'main'
        stmts: [
            ast.Stmt(ast.ModuleStmt{
                name: 'main'
            }),
            ast.Stmt(ast.FnDecl{
                name:  'main'
                stmts: []ast.Stmt{}
            }),
        ]
    }
}

fn make_mymod_file_for_driver() ast.File {
    return ast.File{
        name:  'mymod.v'
        mod:   'mymod'
        stmts: [
            ast.Stmt(ast.ModuleStmt{
                name: 'mymod'
            }),
        ]
    }
}

// All gates off → driver is a near-no-op (only `inject_runtime_const_init_fns_to_flat`
// and `inject_main_runtime_const_init_to_flat` and `inject_test_main_to_flat`
// have unconditional entry, but they short-circuit because state is empty).
// Bit-equality with legacy `post_pass + flatten_files` proves the driver
// preserves the post_pass control-flow tree even when all steps no-op.
fn test_post_pass_to_flat_all_gates_off_matches_legacy() {
    mut ref_files := [make_minimal_main_file_with_main_fn()]
    mut t_ref := create_post_pass_to_flat_test_transformer()
    t_ref.post_pass(mut ref_files)
    ref_sig := ast.flatten_files(ref_files).signature()

    mut b := ast.new_flat_builder()
    b.append_file(make_minimal_main_file_with_main_fn())
    mut t_sub := create_post_pass_to_flat_test_transformer()
    t_sub.post_pass_to_flat(mut b, none)
    assert b.flat.signature() == ref_sig
}

// Active runtime-const-init gate exercises s160 (generate the
// `__v_init_consts_mymod` fn into the mymod file) AND s155 (prepend init
// call to main's body). Two-mod fixture leaks intern order through
// `.file.extra=intern(mod)`, so compare per-file via subtree_signature.
fn test_post_pass_to_flat_runtime_const_init_matches_legacy() {
    mut t_ref := create_post_pass_to_flat_test_transformer()
    t_ref.runtime_const_modules = ['mymod']
    t_ref.runtime_const_inits_by_mod['mymod'] = [
        RuntimeConstInit{
            name: 'mymod__answer'
            expr: ast.Expr(ast.BasicLiteral{
                kind:  .number
                value: '42'
            })
        },
    ]
    mut ref_files := [make_minimal_main_file_with_main_fn(), make_mymod_file_for_driver()]
    t_ref.post_pass(mut ref_files)
    ref_flat := ast.flatten_files(ref_files)
    // File 0 (main): edge 2 = stmts list — main's body should be prepended
    // with init call.
    ref_main_stmts := ref_flat.child_at(ref_flat.files[0].file_id, 2)
    ref_main_sub_sig := ref_flat.subtree_signature(ref_main_stmts)
    // File 1 (mymod): edge 2 = stmts list — should contain the generated
    // `__v_init_consts_mymod` fn.
    ref_mymod_stmts := ref_flat.child_at(ref_flat.files[1].file_id, 2)
    ref_mymod_sub_sig := ref_flat.subtree_signature(ref_mymod_stmts)

    mut t_sub := create_post_pass_to_flat_test_transformer()
    t_sub.runtime_const_modules = ['mymod']
    t_sub.runtime_const_inits_by_mod['mymod'] = [
        RuntimeConstInit{
            name: 'mymod__answer'
            expr: ast.Expr(ast.BasicLiteral{
                kind:  .number
                value: '42'
            })
        },
    ]
    mut b := ast.new_flat_builder()
    b.append_file(make_minimal_main_file_with_main_fn())
    b.append_file(make_mymod_file_for_driver())
    t_sub.post_pass_to_flat(mut b, none)
    sub_main_stmts := b.flat.child_at(b.flat.files[0].file_id, 2)
    sub_main_sub_sig := b.flat.subtree_signature(sub_main_stmts)
    sub_mymod_stmts := b.flat.child_at(b.flat.files[1].file_id, 2)
    sub_mymod_sub_sig := b.flat.subtree_signature(sub_mymod_stmts)

    assert ref_main_sub_sig == sub_main_sub_sig
    assert ref_mymod_sub_sig == sub_mymod_sub_sig
}

// Backend gating: cleanc must skip inject_test_main, eval must skip
// inject_runtime_const_init_fns + inject_main_runtime_const_init_calls.
// We don't fully exercise eval backend here (no test_ fns, no native
// backend), but cleanc gating is observable: with a `test_*` fn, default
// backend produces `fn main()` (synthesised), cleanc skips that. The
// driver must match legacy on both.
fn test_post_pass_to_flat_cleanc_skips_test_main() {
    mut t_ref := create_post_pass_to_flat_test_transformer()
    t_ref.pref = &vpref.Preferences{
        backend: .cleanc
    }
    test_file := ast.File{
        name:  'foo_test.v'
        mod:   'main'
        stmts: [
            ast.Stmt(ast.ModuleStmt{
                name: 'main'
            }),
            ast.Stmt(ast.FnDecl{
                name:  'test_one'
                stmts: []ast.Stmt{}
            }),
        ]
    }
    mut ref_files := [test_file]
    t_ref.post_pass(mut ref_files)
    ref_sig := ast.flatten_files(ref_files).signature()

    mut t_sub := create_post_pass_to_flat_test_transformer()
    t_sub.pref = &vpref.Preferences{
        backend: .cleanc
    }
    mut b := ast.new_flat_builder()
    b.append_file(ast.File{
        name:  'foo_test.v'
        mod:   'main'
        stmts: [
            ast.Stmt(ast.ModuleStmt{
                name: 'main'
            }),
            ast.Stmt(ast.FnDecl{
                name:  'test_one'
                stmts: []ast.Stmt{}
            }),
        ]
    })
    t_sub.post_pass_to_flat(mut b, none)
    assert b.flat.signature() == ref_sig
}