#!/usr/bin/env -S v

import os

const total_steps = 6
const temp_prefix = 'v3_test_all'

struct Config {
    vexe         string
    script_dir   string
    repo_root    string
    tests_dir    string
    v3_src       string
    c99          bool
    c99_flag     string
    host_backend string
    host_os      string
}

fn main() {
    cfg := parse_config()
    os.chdir(cfg.repo_root) or { fail('failed to enter ${cfg.repo_root}: ${err}') }

    v3_bin := temp_path('v3')
    hello_c_bin := temp_path('hello_c')
    hello_arm_bin := temp_path('hello_arm64')
    v4_arm_bin := temp_path('v4_arm64')
    v3_lang_bin := temp_path('v3_lang')
    v4_bin := temp_path('v4_chain')
    v5_bin := temp_path('v5_chain')
    v6_bin := temp_path('v6_chain')
    cleanup_files([
        v3_bin,
        hello_c_bin,
        hello_c_bin + '.c',
        hello_arm_bin,
        v4_arm_bin,
        v3_lang_bin,
        v3_lang_bin + '.c',
        v4_bin,
        v4_bin + '.c',
        v5_bin,
        v5_bin + '.c',
        v6_bin,
        v6_bin + '.c',
    ])

    section(1, 'V3 unit tests')
    run('${q(cfg.vexe)} -silent test ${q(cfg.script_dir)}')

    section(2, 'Build v3')
    run('${q(cfg.vexe)} -o ${q(v3_bin)} ${q(cfg.v3_src)}')

    section(3, 'C backend hello world')
    hello_v := os.join_path(cfg.tests_dir, 'hello.v')
    run('${q(v3_bin)} ${cfg.c99_flag} ${q(hello_v)} -b c -o ${q(hello_c_bin)}')
    run(q(hello_c_bin))
    cleanup_files([hello_c_bin, hello_c_bin + '.c'])

    section(4, 'ARM64 self-host hello world')
    if cfg.c99 {
        println('  Skipping ARM64 self-host in C99 mode (-c99 applies to the C backend)')
    } else if cfg.host_backend == 'arm64' && cfg.host_os == 'macos' {
        run('${q(v3_bin)} --no-parallel -selfhost -b arm64 -o ${q(v4_arm_bin)} ${q(cfg.v3_src)}')
        run('${q(v4_arm_bin)} --no-parallel -b arm64 -o ${q(hello_arm_bin)} ${q(hello_v)}')
        run(q(hello_arm_bin))
        cleanup_files([v4_arm_bin, hello_arm_bin])
    } else {
        println('  Skipping ARM64 self-host on ${cfg.host_os}/${cfg.host_backend} host (Mach-O only)')
    }

    section(5, 'Self-host chain (v3->v4->v5->v6)')
    println('  Building v4 from v3...')
    run('${q(v3_bin)} ${cfg.c99_flag} --no-parallel -selfhost -o ${q(v4_bin)} ${q(cfg.v3_src)}')
    println('  Building v5 from v4...')
    run('${q(v4_bin)} ${cfg.c99_flag} --no-parallel -selfhost -o ${q(v5_bin)} ${q(cfg.v3_src)}')
    println('  Building v6 from v5...')
    run('${q(v5_bin)} ${cfg.c99_flag} --no-parallel -selfhost -o ${q(v6_bin)} ${q(cfg.v3_src)}')
    converged_size := assert_same_file_bytes('v5/v6 generated C output', v5_bin + '.c', v6_bin +
        '.c')
    println('  v5.c=v6.c (${converged_size} bytes) - chain converged')
    cleanup_files([v4_bin, v4_bin + '.c', v5_bin, v5_bin + '.c', v6_bin, v6_bin + '.c'])

    section(6, 'Language feature parity')
    lang_v := os.join_path(cfg.tests_dir, 'test_all_lang_features.v')
    lang_out := os.join_path(cfg.tests_dir, 'test_all_lang_features.out')
    run('${q(v3_bin)} ${cfg.c99_flag} ${q(lang_v)} -b c -o ${q(v3_lang_bin)}')
    v3_c_out := run_output(q(v3_lang_bin))
    expected_out := read_text_file(lang_out)
    assert_same_text('language feature output', v3_c_out, expected_out)
    println('  v3 C OK (${v3_c_out.split_into_lines().len} lines)')
    println('  ARM64 coverage is the one-generation macOS self-host smoke test in step 4')
    cleanup_files([v3_bin, v3_lang_bin, v3_lang_bin + '.c'])

    println('')
    println('=== ALL TESTS PASSED ===')
}

fn parse_config() Config {
    c99 := parse_args()
    script_dir := os.real_path(@DIR)
    repo_root := os.real_path(os.join_path(script_dir, '..', '..'))
    tests_dir := os.join_path(script_dir, 'tests')
    vexe := absolute_path(@VEXE)
    if !os.is_executable(vexe) {
        fail('FAIL: V compiler not found: ${vexe}')
    }
    return Config{
        vexe:         vexe
        script_dir:   script_dir
        repo_root:    repo_root
        tests_dir:    tests_dir
        v3_src:       os.join_path(script_dir, 'v3.v')
        c99:          c99
        c99_flag:     if c99 { '-c99' } else { '' }
        host_backend: native_backend_arch()
        host_os:      os.user_os()
    }
}

fn parse_args() bool {
    mut c99 := false
    for arg in os.args[1..] {
        match arg {
            '-c99', '--c99' {
                c99 = true
            }
            '-h', '--help' {
                println('usage: test_all.vsh [-c99]')
                exit(0)
            }
            else {
                fail('unknown argument: ${arg}')
            }
        }
    }
    return c99
}

fn native_backend_arch() string {
    machine := os.uname().machine.to_lower()
    match machine {
        'x86_64', 'amd64' {
            return 'x64'
        }
        'aarch64', 'arm64' {
            return 'arm64'
        }
        else {
            return machine
        }
    }
}

fn temp_path(name string) string {
    return os.join_path(os.temp_dir(), '${temp_prefix}_${name}')
}

fn absolute_path(path string) string {
    if os.is_abs_path(path) {
        return path
    }
    return os.join_path(os.getwd(), path)
}

fn section(step int, title string) {
    if step > 1 {
        println('')
    }
    println('=== ${step}/${total_steps}: ${title} ===')
}

fn run(cmd string) {
    println('> ${cmd}')
    code := os.system(cmd)
    if code != 0 {
        exit(code)
    }
}

fn run_output(cmd string) string {
    stdout_path := temp_path('stdout')
    cleanup_files([stdout_path])
    println('> ${cmd}')
    code := os.system('${cmd} > ${q(stdout_path)}')
    if code != 0 {
        exit(code)
    }
    content := read_text_file(stdout_path)
    cleanup_files([stdout_path])
    return content
}

fn read_text_file(path string) string {
    content := os.read_file(path) or {
        fail('FAIL: failed to read ${path}: ${err}')
        return ''
    }
    return content
}

fn read_binary_file(path string) []u8 {
    content := os.read_bytes(path) or {
        fail('FAIL: failed to read ${path}: ${err}')
        return []u8{}
    }
    return content
}

fn assert_same_file_bytes(label string, left_path string, right_path string) int {
    left := read_binary_file(left_path)
    right := read_binary_file(right_path)
    if left != right {
        fail('FAIL: ${label} differs byte-for-byte (${left.len} bytes vs ${right.len} bytes)')
    }
    return left.len
}

fn assert_same_text(label string, actual string, expected string) {
    if actual == expected {
        return
    }
    actual_lines := actual.split_into_lines()
    expected_lines := expected.split_into_lines()
    min_lines := if actual_lines.len < expected_lines.len {
        actual_lines.len
    } else {
        expected_lines.len
    }
    for i in 0 .. min_lines {
        if actual_lines[i] != expected_lines[i] {
            fail('FAIL: ${label} differs at line ${i + 1}: expected `${expected_lines[i]}`, got `${actual_lines[i]}`')
        }
    }
    fail('FAIL: ${label} line count differs: expected ${expected_lines.len}, got ${actual_lines.len}')
}

fn cleanup_files(paths []string) {
    for path in paths {
        os.rm(path) or {}
    }
}

fn q(path string) string {
    return os.quoted_path(path)
}

fn fail(message string) {
    eprintln(message)
    exit(1)
}