#!/usr/bin/env -S v

import os

const total_steps = 15
const v2_bak = '/tmp/v2_src_bak_test_all'
const cleanc_cache = '/tmp/v2_cleanc_obj_cache'
const gitly_clone_dir = '/tmp/v2_test_gitly_clone'
const gitly_repo_url = 'https://github.com/vlang/gitly'

struct Config {
    v1_compiler  string
    script_dir   string
    repo_root    string
    v2_src       string
    backend_arch string
    backend_flag string
}

struct Args {
    backend_arch string
    opt_flag     string
}

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

    rm_rf(cleanc_cache)

    section(1, '${cfg.backend_arch} self-host hello world')
    backup_v2_src(cfg)
    run('${q(cfg.v1_compiler)} -gc none -cc cc -o v2 v2.v')
    restore_v2_src(cfg)
    run('./v2 --no-parallel -backend ${cfg.backend_arch} -gc none -nocache ${cfg.backend_flag} -o v3 v2.v')
    run('./v3 --no-parallel -backend ${cfg.backend_arch} ${cfg.backend_flag} -o hello_backend hello.v')
    run('./hello_backend')
    cleanup_files(['v3', 'hello_backend'])

    section(2, '${cfg.backend_arch} self-host chain (v2->v3->v4->v5->v6)')
    println('  Building v3 from v2...')
    run('./v2 --no-parallel -nocache -gc none -backend ${cfg.backend_arch} ${cfg.backend_flag} -o v3_chain v2.v')
    println('  Building v4 from v3...')
    run('./v3_chain --no-parallel -nocache -gc none -backend ${cfg.backend_arch} ${cfg.backend_flag} -o v4_chain v2.v')
    println('  Building v5 from v4...')
    run('./v4_chain --no-parallel -nocache -gc none -backend ${cfg.backend_arch} ${cfg.backend_flag} -o v5_chain v2.v')
    println('  Building v6 from v5...')
    run('./v5_chain --no-parallel -nocache -gc none -backend ${cfg.backend_arch} ${cfg.backend_flag} -o v6_chain v2.v')
    v5_size := os.file_size('v5_chain')
    v6_size := os.file_size('v6_chain')
    if v5_size == v6_size {
        println('  v5=v6 (${v5_size} bytes) - chain converged')
    } else {
        fail('  FAIL: v5 (${v5_size}) != v6 (${v6_size})')
    }
    cleanup_files(['v3_chain', 'v4_chain', 'v5_chain', 'v6_chain'])

    section(3, 'Self-host test')
    run('bash test_v2_self.sh')

    section(4, 'Builtin test files (cleanc)')
    rm_rf(cleanc_cache)
    run('./v2 ../../vlib/builtin/array_test.v')
    run('./v2 ../../vlib/builtin/string_test.v')
    run('./v2 ../../vlib/builtin/map_test.v')

    section(5, 'Builtin test files (${cfg.backend_arch})')
    for backend_test in ['array_test.v', 'string_test.v', 'map_test.v'] {
        run('./v2 -backend ${cfg.backend_arch} ${cfg.backend_flag} "../../vlib/builtin/${backend_test}"')
    }

    section(6, 'Math test')
    run('./v2 ../../vlib/math/math_test.v')

    section(7, 'Math test (${cfg.backend_arch})')
    run('./v2 -backend ${cfg.backend_arch} ${cfg.backend_flag} ../../vlib/math/math_test.v')

    section(8, 'Sumtype tests')
    for st in sumtype_tests() {
        run('./v2 ${st}')
    }

    section(9, 'Sumtype tests (${cfg.backend_arch})')
    for st in sumtype_tests() {
        run('./v2 -backend ${cfg.backend_arch} ${cfg.backend_flag} ${st}')
    }

    section(10, 'SSA backends test (${cfg.backend_arch})')
    run('${q(cfg.v1_compiler)} -gc none run test_ssa_backends.v ${cfg.backend_arch} ${cfg.backend_flag}')

    section(11, 'SSA backends test (cleanc)')
    run('${q(cfg.v1_compiler)} -gc none run test_ssa_backends.v cleanc')

    section(12, 'Transformer unit tests')
    run('${q(cfg.v1_compiler)} -gc none ../../vlib/v2/transformer/transformer_test.v')

    section(13, 'Transformer integration test')
    run('${q(cfg.v1_compiler)} -gc none ../../vlib/v2/transformer/transformer_v2_darwin_test.v')

    section(14, 'Cleanc runtime tests')
    run('${q(cfg.v1_compiler)} -gc none run ../../vlib/v2/gen/cleanc/tests/run_tests.v')

    section(15, 'Gitly build (cleanc, -d use_openssl -d sqlite)')
    v2_bin := os.join_path(cfg.script_dir, 'v2')
    gitly_dir := resolve_gitly_dir()
    os.chdir(gitly_dir) or { fail('failed to enter ${gitly_dir}: ${err}') }
    run('${q(v2_bin)} -v -showcc -o x -stats -d use_openssl -d sqlite .')
    cleanup_files(['x'])
    os.chdir(cfg.script_dir) or { fail('failed to return to ${cfg.script_dir}: ${err}') }

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

fn resolve_gitly_dir() string {
    local := os.join_path(os.home_dir(), 'code', 'gitly')
    if os.is_dir(local) {
        println('  Using local gitly at ${local}')
        return local
    }
    if os.is_dir(gitly_clone_dir) {
        println('  Reusing cloned gitly at ${gitly_clone_dir}')
        return gitly_clone_dir
    }
    println('  Cloning ${gitly_repo_url} into ${gitly_clone_dir}...')
    run('git clone --depth 1 ${gitly_repo_url} ${q(gitly_clone_dir)}')
    return gitly_clone_dir
}

fn parse_config() Config {
    args := parse_args()
    script_dir := os.real_path(@DIR)
    repo_root := os.real_path(os.join_path(script_dir, '..', '..'))
    v1_compiler := absolute_path(os.getenv_opt('V') or { os.join_path(repo_root, 'v') })
    if !os.is_executable(v1_compiler) {
        fail('FAIL: v1 compiler not found: ${v1_compiler}')
    }
    backend_flag := args.opt_flag
    return Config{
        v1_compiler:  v1_compiler
        script_dir:   script_dir
        repo_root:    repo_root
        v2_src:       os.join_path(repo_root, 'vlib', 'v2')
        backend_arch: args.backend_arch
        backend_flag: backend_flag
    }
}

fn parse_args() Args {
    mut backend_arch := ''
    mut opt_flag := '-O0'
    mut i := 1
    for i < os.args.len {
        arg := os.args[i]
        match arg {
            '-arch', '--arch' {
                i++
                if i >= os.args.len {
                    fail('missing value after -arch/--arch')
                }
                backend_arch = parse_backend_arch(os.args[i])
            }
            '-prod' {
                opt_flag = '-prod'
            }
            '-O0' {
                opt_flag = '-O0'
            }
            '-h', '--help' {
                println('Usage: v run cmd/v2/test_all.vsh [-arch|--arch auto|x64|arm64] [-prod|-O0]')
                println('')
                println('By default, backend tests use the native host architecture.')
                println('With -arch/--arch auto, backend tests use the native host architecture.')
                println('With -arch/--arch x64, backend tests use the x64 backend.')
                println('With -arch/--arch arm64, backend tests use the ARM64 backend.')
                println('With -prod, x64 and ARM64 backend builds use -prod.')
                println('With -O0, x64 and ARM64 backend builds use -O0.')
                println('With x64 backend builds, -O0 is passed through, but SSA optimize is still forced by the backend.')
                exit(0)
            }
            else {
                fail('unknown argument: ${arg}')
            }
        }

        i++
    }
    if backend_arch == '' {
        backend_arch = native_backend_arch()
    }
    return Args{
        backend_arch: backend_arch
        opt_flag:     opt_flag
    }
}

fn parse_backend_arch(arch string) string {
    match arch {
        'auto' {
            return native_backend_arch()
        }
        'x64', 'arm64' {
            return arch
        }
        else {
            fail('unsupported architecture: ${arch}; expected auto, x64 or arm64')
        }
    }

    return ''
}

fn native_backend_arch() string {
    machine := os.uname().machine.to_lower()
    match machine {
        'x86_64', 'amd64' {
            return 'x64'
        }
        'aarch64', 'arm64' {
            return 'arm64'
        }
        else {
            fail('unsupported native architecture: ${machine}; pass -arch/--arch x64 or -arch/--arch arm64')
        }
    }

    return ''
}

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 backup_v2_src(cfg Config) {
    rm_rf(v2_bak)
    run('cp -R ${q(cfg.v2_src)} ${q(v2_bak)}')
}

fn restore_v2_src(cfg Config) {
    run('rsync -a --delete ${q(v2_bak + '/')} ${q(cfg.v2_src + '/')}')
}

fn rm_rf(path string) {
    if !os.exists(path) {
        return
    }
    if os.is_dir(path) {
        os.rmdir_all(path) or { fail('failed to remove ${path}: ${err}') }
        return
    }
    os.rm(path) or { fail('failed to remove ${path}: ${err}') }
}

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

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

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

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

fn sumtype_tests() []string {
    return [
        'test_sumtype.v',
        'test_sumtype2.v',
        'test_sumtype3.v',
        'test_sumtype4.v',
        'test_sumtype_pos.v',
        'test_sumtype_data.v',
        'test_sumtype_ifexpr.v',
        'test_sumtype_nested.v',
        'test_sumtype_many.v',
        'test_sumtype_global.v',
    ]
}