// 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
//
// Differential test harness for the flat-native markused walker.
//
// Markused decides which functions/methods the backend must emit. A wrong
// answer is silent — too few keys → linker errors, too many keys → bloated
// binary and slow build. The cursor-based walker that will replace the
// recursive walker must produce a bit-identical key set on every program
// that exercises the dispatch surface.
//
// This file provides the comparison machinery and a growing fixture catalog.
// The fixtures are intentionally small, one per language construct, so that
// when the diff fails the failing fixture immediately localises the bug.
// Until mark_used_flat lands, the "differential" tests assert determinism
// (legacy == legacy across two runs) — they prove the harness itself works
// without depending on the new walker.
module markused

import os
import time
import v2.ast
import v2.parser
import v2.pref
import v2.token
import v2.types

// ParsedFixture bundles every artefact a markused walker (legacy or flat)
// needs to run on a source string. It is returned by parse_fixture so each
// test fixture writes the source once and gets everything else for free.
struct ParsedFixture {
    files []ast.File
    flat  ast.FlatAst
    env   &types.Environment
}

fn parse_fixture(src string) ParsedFixture {
    tmp := '/tmp/v2_markused_diff_${os.getpid()}_${rand_suffix()}.v'
    os.write_file(tmp, src) or { panic('write_file: ${err}') }
    defer {
        os.rm(tmp) or {}
    }
    prefs := &pref.Preferences{
        skip_builtin: true
    }
    mut fs := token.FileSet.new()
    mut par := parser.Parser.new(prefs)
    files := par.parse_files([tmp], mut fs)
    flat := ast.flatten_files(files)
    // Skip the type checker entirely — fixtures use println / etc. which
    // would require pulling in builtin. The walker treats a near-empty env
    // as "no type info available" and falls back to syntactic receiver
    // candidates. Determinism is preserved (env in == env out for both runs)
    // which is all the differential harness needs.
    env := types.Environment.new()
    return ParsedFixture{
        files: files
        flat:  flat
        env:   env
    }
}

// rand_suffix produces a short pseudo-unique tag so concurrent test runs
// don't trample each other's tempfiles. We avoid pulling in `rand` so the
// harness has no dependency on RNG seeding inside the test binary.
fn rand_suffix() string {
    t := u64(time.now().unix_milli()) & 0xFFFFFFFF
    return '${t:x}'
}

// DiffReport captures the symmetric difference between two used_keys maps.
// It is a struct (not a bool) so failing tests can print exactly which keys
// drifted, which is essential for debugging walker bugs in 100+-key fixtures.
struct DiffReport {
    only_in_a []string
    only_in_b []string
    equal     bool
}

fn diff_used_keys(a map[string]bool, b map[string]bool) DiffReport {
    mut only_a := []string{}
    mut only_b := []string{}
    for k, _ in a {
        if k !in b {
            only_a << k
        }
    }
    for k, _ in b {
        if k !in a {
            only_b << k
        }
    }
    only_a.sort()
    only_b.sort()
    return DiffReport{
        only_in_a: only_a
        only_in_b: only_b
        equal:     only_a.len == 0 && only_b.len == 0
    }
}

fn assert_used_keys_equal(label string, a map[string]bool, b map[string]bool) {
    d := diff_used_keys(a, b)
    if d.equal {
        return
    }
    eprintln('[${label}] used_keys diverged:')
    if d.only_in_a.len > 0 {
        eprintln('  only in A (${d.only_in_a.len}):')
        for k in d.only_in_a {
            eprintln('    ${k}')
        }
    }
    if d.only_in_b.len > 0 {
        eprintln('  only in B (${d.only_in_b.len}):')
        for k in d.only_in_b {
            eprintln('    ${k}')
        }
    }
    assert false, '${label}: used_keys differ (see above)'
}

// run_legacy is a thin wrapper around mark_used so individual fixtures read
// as "legacy = run_legacy(p); flat = run_flat(p); assert_used_keys_equal".
fn run_legacy(p ParsedFixture) map[string]bool {
    return mark_used(p.files, p.env)
}

fn run_flat(p ParsedFixture) map[string]bool {
    return mark_used_flat(&p.flat, p.env)
}

// fixtures — each test exercises one slice of the walker dispatch surface.
// Adding a new fixture means: (1) write the smallest V program that hits the
// dispatch arm, (2) assert legacy determinism here, (3) when flat lands,
// flip to assert_used_keys_equal(name, run_legacy(p), run_flat(p)).

const fixture_plain_fn = 'module main

fn add(a int, b int) int {
    return a + b
}

fn main() {
    println(add(1, 2))
}
'

const fixture_method_call = 'module main

struct Counter {
mut:
    n int
}

fn (mut c Counter) inc() {
    c.n++
}

fn (c Counter) value() int {
    return c.n
}

fn main() {
    mut c := Counter{}
    c.inc()
    println(c.value())
}
'

const fixture_infix_operator = 'module main

struct Vec {
    x int
    y int
}

fn (a Vec) + (b Vec) Vec {
    return Vec{a.x + b.x, a.y + b.y}
}

fn main() {
    v := Vec{1, 2} + Vec{3, 4}
    println(v.x)
}
'

const fixture_array_and_loop = 'module main

fn sum(xs []int) int {
    mut s := 0
    for x in xs {
        s += x
    }
    return s
}

fn main() {
    xs := [1, 2, 3]
    println(sum(xs))
}
'

const fixture_match_expr = 'module main

fn describe(n int) string {
    return match n {
        0 { "zero" }
        1 { "one" }
        else { "many" }
    }
}

fn main() {
    println(describe(1))
}
'

const fixture_if_guard = 'module main

fn maybe(n int) ?int {
    if n > 0 {
        return n
    }
    return none
}

fn main() {
    if v := maybe(3) {
        println(v)
    }
}
'

const fixture_global_init = 'module main

__global g_counter = 0

fn bump() {
    g_counter++
}

fn main() {
    bump()
    println(g_counter)
}
'

const fixture_global_init_calls_fn = 'module main

struct Value {
    n int
}

fn make_value() Value {
    return Value{n: 1}
}

__global state = make_value()

fn main() {
    _ = state.n
}
'

// fixture_generic_fn exercises walker dispatch on generic function calls.
// The walker must mark both the generic base and any concrete bindings
// reachable through env.generic_types — the closest analogue of a real
// codebase\'s "[]T → []int" specialization path.
const fixture_generic_fn = 'module main

fn identity[T](x T) T {
    return x
}

fn main() {
    a := identity[int](42)
    b := identity[string]("hi")
    println(a)
    println(b)
}
'

// fixture_closure exercises closure capture: the walker must not lose
// reachability when the called fn is the value of a local variable that
// itself was assigned a fn literal closing over outer state.
const fixture_closure = 'module main

fn make_counter() fn () int {
    mut n := 0
    return fn [mut n] () int {
        n++
        return n
    }
}

fn main() {
    c := make_counter()
    println(c())
    println(c())
}
'

// fixture_sumtype_is_as covers the .is / as / smart-cast dispatch arms
// in walk_expr that resolve variant-specific method calls.
const fixture_sumtype_is_as = 'module main

type Shape = Circle | Square

struct Circle {
    r f64
}

struct Square {
    side f64
}

fn area(s Shape) f64 {
    return match s {
        Circle { 3.14 * s.r * s.r }
        Square { s.side * s.side }
    }
}

fn main() {
    c := Shape(Circle{r: 2.0})
    if c is Circle {
        println(c.r)
    }
    println(area(c))
}
'

// fixture_defer_and_map exercises defer statement walking plus map literal
// init / index / "in" lookup — three distinct walk_stmt / walk_expr arms
// that share no helpers with the simpler fixtures.
const fixture_defer_and_map = 'module main

fn lookup() int {
    mut m := {"a": 1, "b": 2}
    defer {
        m["a"] = 9
    }
    if "b" in m {
        return m["b"]
    }
    return 0
}

fn main() {
    println(lookup())
}
'

// fixture_string_interp_and_array_slice covers string-interpolation
// expressions and array slicing — both have their own walk_expr arms
// with their own sub-expression edges. Uses a raw string (r'...') so
// the outer V parser does not try to interpolate the inner ${...}.
const fixture_string_interp_and_array_slice = r'module main

fn slice_sum(xs []int) string {
    tail := xs[1..]
    mut s := 0
    for x in tail {
        s += x
    }
    return "sum=${s} count=${tail.len}"
}

fn main() {
    println(slice_sum([10, 20, 30, 40]))
}
'

fn all_fixtures() []string {
    return [
        fixture_plain_fn,
        fixture_method_call,
        fixture_infix_operator,
        fixture_array_and_loop,
        fixture_match_expr,
        fixture_if_guard,
        fixture_global_init,
        fixture_global_init_calls_fn,
        fixture_generic_fn,
        fixture_closure,
        fixture_sumtype_is_as,
        fixture_defer_and_map,
        fixture_string_interp_and_array_slice,
    ]
}

// --- flat-vs-legacy diff tests ---
// These are the real safety net for the markused migration. Each PR that
// rewrites part of mark_used_flat must keep every fixture green. While the
// shim still calls flat.to_files() + the legacy walker, both runs must
// trivially produce the same map — once the body diverges, these fixtures
// catch regressions immediately and the DiffReport pinpoints which key set
// drifted.

fn test_flat_matches_legacy_plain_fn() {
    p := parse_fixture(fixture_plain_fn)
    assert_used_keys_equal('plain_fn', run_legacy(p), run_flat(p))
}

fn test_flat_matches_legacy_method_call() {
    p := parse_fixture(fixture_method_call)
    assert_used_keys_equal('method_call', run_legacy(p), run_flat(p))
}

fn test_flat_matches_legacy_infix_operator() {
    p := parse_fixture(fixture_infix_operator)
    assert_used_keys_equal('infix_operator', run_legacy(p), run_flat(p))
}

fn test_flat_matches_legacy_array_and_loop() {
    p := parse_fixture(fixture_array_and_loop)
    assert_used_keys_equal('array_and_loop', run_legacy(p), run_flat(p))
}

fn test_flat_matches_legacy_match_expr() {
    p := parse_fixture(fixture_match_expr)
    assert_used_keys_equal('match_expr', run_legacy(p), run_flat(p))
}

fn test_flat_matches_legacy_if_guard() {
    p := parse_fixture(fixture_if_guard)
    assert_used_keys_equal('if_guard', run_legacy(p), run_flat(p))
}

fn test_flat_matches_legacy_global_init() {
    p := parse_fixture(fixture_global_init)
    assert_used_keys_equal('global_init', run_legacy(p), run_flat(p))
}

fn test_flat_matches_legacy_global_init_calls_fn() {
    p := parse_fixture(fixture_global_init_calls_fn)
    assert_used_keys_equal('global_init_calls_fn', run_legacy(p), run_flat(p))
}

fn test_flat_matches_legacy_generic_fn() {
    p := parse_fixture(fixture_generic_fn)
    assert_used_keys_equal('generic_fn', run_legacy(p), run_flat(p))
}

fn test_flat_matches_legacy_closure() {
    p := parse_fixture(fixture_closure)
    assert_used_keys_equal('closure', run_legacy(p), run_flat(p))
}

fn test_flat_matches_legacy_sumtype_is_as() {
    p := parse_fixture(fixture_sumtype_is_as)
    assert_used_keys_equal('sumtype_is_as', run_legacy(p), run_flat(p))
}

fn test_flat_matches_legacy_defer_and_map() {
    p := parse_fixture(fixture_defer_and_map)
    assert_used_keys_equal('defer_and_map', run_legacy(p), run_flat(p))
}

fn test_flat_matches_legacy_string_interp_and_array_slice() {
    p := parse_fixture(fixture_string_interp_and_array_slice)
    assert_used_keys_equal('string_interp_and_array_slice', run_legacy(p), run_flat(p))
}

// test_flat_is_deterministic — two runs of mark_used_flat on the same fixture
// must produce the same map. Guards against accidental nondeterminism
// (e.g. iteration order over a map of types) creeping in as the body
// of the shim is progressively replaced.
fn test_flat_is_deterministic_all_fixtures() {
    for i, src in all_fixtures() {
        p := parse_fixture(src)
        assert_used_keys_equal('fixture-${i}-determinism', run_flat(p), run_flat(p))
    }
}

// test_fixtures_produce_nonempty_results guards against silently broken
// harness setup: every fixture has at least main() reachable, so a zero-key
// result means our parse/typecheck/walk pipeline broke before we even got
// to compare anything.
fn test_fixtures_produce_nonempty_results() {
    for i, src in all_fixtures() {
        p := parse_fixture(src)
        keys := run_legacy(p)
        assert keys.len > 0, 'fixture #${i} produced empty used_keys — pipeline broken before walker'
    }
}

// test_flat_ast_round_trips_every_fixture verifies the cursor-side machinery
// works end-to-end on the fixture surface: every fixture parses, flattens,
// and is reachable via the cursor API from each file root. This is what
// the future flat walker will consume, so it must not blow up here.
fn test_flat_ast_round_trips_every_fixture() {
    for i, src in all_fixtures() {
        p := parse_fixture(src)
        assert p.flat.files.len > 0, 'fixture #${i}: flat has no files'
        for fi in 0 .. p.flat.files.len {
            fc := p.flat.file_cursor(fi)
            assert fc.root().is_valid(), 'fixture #${i} file ${fi}: invalid root'
            assert fc.root().kind() == .file, 'fixture #${i} file ${fi}: root not .file'
            // Touch each top-level list so an aux_list miswiring trips here
            // rather than deep inside the future walker port.
            _ = fc.attrs().len()
            _ = fc.imports().len()
            _ = fc.stmts().len()
        }
    }
}