module main

import os
import rand

const current_vexe = @VEXE

const delegated_marker = 'VVM-DELEGATED'

const delegated_v2_marker = 'V2-DELEGATED-WAITED'

const requested_vvm_test_version = '99.99.99'

struct CmdResult {
    exit_code int
    output    string
}

fn vvm_test_repo_root() string {
    mut dir := os.dir(@FILE)
    for _ in 0 .. 10 {
        if os.exists(os.join_path(dir, 'cmd', 'v', 'v.v'))
            && os.exists(os.join_path(dir, 'vlib', 'builtin')) {
            return dir
        }
        dir = os.dir(dir)
    }
    panic('could not locate repo root for vvm tests')
}

fn build_current_v_wrapper(tmp_root string) string {
    vroot := vvm_test_repo_root()
    wrapper_exe := os.join_path(tmp_root, if os.user_os() == 'windows' {
        'v_public_wrapper.exe'
    } else {
        'v_public_wrapper'
    })
    compile_res := os.execute('${os.quoted_path(current_vexe)} -path "${os.join_path(vroot, 'vlib')}|@vlib|@vmodules" -o ${os.quoted_path(wrapper_exe)} ${os.quoted_path(os.join_path(vroot,
        'cmd', 'v'))}')
    assert compile_res.exit_code == 0, compile_res.output
    return wrapper_exe
}

fn test_parse_vvmrc_version() {
    assert parse_vvmrc_version('') == ''
    assert parse_vvmrc_version('   ') == ''
    assert parse_vvmrc_version('# only comments') == ''
    assert parse_vvmrc_version('\n# comment\n0.4.6\n') == '0.4.6'
    assert parse_vvmrc_version(' latest # comment ') == 'latest'
}

fn test_find_project_vvmrc_stops_at_stop_paths() {
    tmp_root := os.join_path(os.vtmp_dir(), 'vvmrc_stop_test_${rand.ulid()}')
    os.mkdir_all(tmp_root) or { panic(err) }
    defer {
        os.rmdir_all(tmp_root) or {}
    }
    project_dir := os.join_path(tmp_root, 'project')
    source_dir := os.join_path(project_dir, 'src')
    os.mkdir_all(source_dir) or { panic(err) }
    os.mkdir_all(os.join_path(project_dir, '.git')) or { panic(err) }
    os.write_file(os.join_path(tmp_root, '.vvmrc'), requested_vvm_test_version) or { panic(err) }
    main_v := os.join_path(source_dir, 'main.v')
    os.write_file(main_v, 'fn main() {}') or { panic(err) }
    assert find_project_vvmrc(main_v) == ''
    local_vvmrc := os.join_path(project_dir, '.vvmrc')
    os.write_file(local_vvmrc, requested_vvm_test_version) or { panic(err) }
    assert find_project_vvmrc(main_v) == os.real_path(local_vvmrc)
}

fn test_vvmrc_delegates_to_matching_compiler_executable() {
    tmp_root := os.join_path(os.vtmp_dir(), 'vvmrc_delegate_test_${rand.ulid()}')
    os.mkdir_all(tmp_root) or { panic(err) }
    defer {
        os.rmdir_all(tmp_root) or {}
    }
    bin_dir := os.join_path(tmp_root, 'bin')
    os.mkdir_all(bin_dir) or { panic(err) }
    fake_compiler_source := os.join_path(tmp_root, 'fake_compiler.v')
    os.write_file(fake_compiler_source,
        "import os\nfn main() {\n\tprintln('${delegated_marker} ' + os.args[1..].join(' '))\n}\n") or {
        panic(err)
    }
    fake_compiler_exe := os.join_path(bin_dir, if os.user_os() == 'windows' {
        'v${requested_vvm_test_version}.exe'
    } else {
        'v${requested_vvm_test_version}'
    })
    compile_res :=
        os.execute('${os.quoted_path(current_vexe)} -o ${os.quoted_path(fake_compiler_exe)} ${os.quoted_path(fake_compiler_source)}')
    assert compile_res.exit_code == 0, compile_res.output
    project_dir := os.join_path(tmp_root, 'project')
    os.mkdir_all(project_dir) or { panic(err) }
    os.write_file(os.join_path(project_dir, '.vvmrc'), requested_vvm_test_version) or { panic(err) }
    os.write_file(os.join_path(project_dir, 'main.v'),
        "fn main() {\n\tprintln('from project')\n}\n") or { panic(err) }
    mut envs := os.environ()
    path_key := find_path_env_key(envs)
    envs[path_key] = '${bin_dir}${os.path_delimiter}${envs[path_key]}'
    envs['V_SKIP_VVMRC'] = ''
    res := run_v_command(project_dir, ['run', 'main.v'], envs)
    assert res.exit_code == 0, res.output
    assert res.output.contains('${delegated_marker} run main.v'), res.output
}

fn test_v2_delegation_waits_for_compiler_process_and_propagates_exit_code() {
    tmp_root := os.join_path(os.vtmp_dir(), 'v2_delegate_wait_test_${rand.ulid()}')
    os.mkdir_all(tmp_root) or { panic(err) }
    defer {
        os.rmdir_all(tmp_root) or {}
    }
    fake_compiler_source := os.join_path(tmp_root, 'fake_v2_compiler.v')
    marker_file := os.join_path(tmp_root, 'v2_marker.txt')
    os.write_file(fake_compiler_source,
        "import os\nimport time\nfn main() {\n\ttime.sleep(700 * time.millisecond)\n\tmarker := os.getenv('V_V2_TEST_MARKER')\n\tos.write_file(marker, os.args[1..].join(' ')) or { panic(err) }\n\tprintln('${delegated_v2_marker}')\n\texit(7)\n}\n") or {
        panic(err)
    }
    fake_compiler_exe := os.join_path(tmp_root, if os.user_os() == 'windows' {
        'fake_v2_compiler.exe'
    } else {
        'fake_v2_compiler'
    })
    compile_res :=
        os.execute('${os.quoted_path(current_vexe)} -o ${os.quoted_path(fake_compiler_exe)} ${os.quoted_path(fake_compiler_source)}')
    assert compile_res.exit_code == 0, compile_res.output
    project_dir := os.join_path(tmp_root, 'project')
    os.mkdir_all(project_dir) or { panic(err) }
    os.write_file(os.join_path(project_dir, 'main.v'), "fn main() {\n\tprintln('unused')\n}\n") or {
        panic(err)
    }
    mut envs := os.environ()
    envs[delegated_v2_exe_env] = fake_compiler_exe
    envs['V_V2_TEST_MARKER'] = marker_file
    envs[vvmrc_skip_env] = '1'
    envs['VFLAGS'] = ''

    res := run_v_command(project_dir, ['-v2', 'main.v'], envs)
    assert res.exit_code == 7, res.output
    assert res.output.contains(delegated_v2_marker), res.output
    assert os.is_file(marker_file)
    marker := os.read_file(marker_file) or { panic(err) }
    assert marker.contains('main.v'), marker
    assert !marker.contains('-v2'), marker
}

fn test_v2_delegation_forwards_target_specific_flags() {
    tmp_root := os.join_path(os.vtmp_dir(), 'v2_delegate_flags_test_${rand.ulid()}')
    os.mkdir_all(tmp_root) or { panic(err) }
    defer {
        os.rmdir_all(tmp_root) or {}
    }
    fake_compiler_source := os.join_path(tmp_root, 'fake_v2_compiler.v')
    marker_file := os.join_path(tmp_root, 'v2_args.txt')
    os.write_file(fake_compiler_source,
        "import os\nfn main() {\n\tmarker := os.getenv('V_V2_TEST_MARKER')\n\tos.write_file(marker, os.args[1..].join(' ')) or { panic(err) }\n}\n") or {
        panic(err)
    }
    fake_compiler_exe := os.join_path(tmp_root, if os.user_os() == 'windows' {
        'fake_v2_compiler.exe'
    } else {
        'fake_v2_compiler'
    })
    compile_res :=
        os.execute('${os.quoted_path(current_vexe)} -o ${os.quoted_path(fake_compiler_exe)} ${os.quoted_path(fake_compiler_source)}')
    assert compile_res.exit_code == 0, compile_res.output
    project_dir := os.join_path(tmp_root, 'project')
    os.mkdir_all(project_dir) or { panic(err) }
    os.write_file(os.join_path(project_dir, 'main.v'), 'fn main() {}\n') or { panic(err) }
    wrapper_exe := build_current_v_wrapper(tmp_root)
    mut envs := os.environ()
    envs[delegated_v2_exe_env] = fake_compiler_exe
    envs['V_V2_TEST_MARKER'] = marker_file
    envs[vvmrc_skip_env] = '1'
    envs['VFLAGS'] = ''
    envs['VEXE'] = os.join_path(vvm_test_repo_root(), 'v')

    res := run_v_command_with_exe(wrapper_exe, project_dir, [
        '-v2',
        '-freestanding',
        '-os',
        'none',
        '--skip-builtin',
        '--skip-type-check',
        '-fhooks',
        'output,panic,alloc',
        '-o',
        'out.c',
        'main.v',
    ], envs)
    assert res.exit_code == 0, res.output
    assert os.is_file(marker_file)
    marker := os.read_file(marker_file) or { panic(err) }
    assert marker.contains('-freestanding'), marker
    assert marker.contains('-os none'), marker
    assert marker.contains('--skip-builtin'), marker
    assert marker.contains('--skip-type-check'), marker
    assert marker.contains('-fhooks output,panic,alloc'), marker
    assert marker.contains('-o out.c'), marker
    assert marker.contains('main.v'), marker
    assert !marker.contains('-v2'), marker

    res_macos := run_v_command_with_exe(wrapper_exe, project_dir, [
        '-v2',
        '-b',
        'x64',
        '-os',
        'macos',
        '-no-mos-tiny',
        '-o',
        'out',
        'main.v',
    ], envs)
    assert res_macos.exit_code == 0, res_macos.output
    macos_marker := os.read_file(marker_file) or { panic(err) }
    assert macos_marker.contains('-b x64'), macos_marker
    assert macos_marker.contains('-os macos'), macos_marker
    assert macos_marker.contains('-no-mos-tiny'), macos_marker
    assert macos_marker.contains('-o out'), macos_marker
    assert macos_marker.contains('main.v'), macos_marker
    assert !macos_marker.contains('-v2'), macos_marker

    os.rm(marker_file) or {}
    legacy_macos_tiny_res := run_v_command_with_exe(wrapper_exe, project_dir, [
        '-v2',
        '-mos-tiny',
        'main.v',
    ], envs)
    assert legacy_macos_tiny_res.exit_code == 1, legacy_macos_tiny_res.output
    assert legacy_macos_tiny_res.output.contains('Unknown argument `-mos-tiny`'), legacy_macos_tiny_res.output
    assert !os.exists(marker_file), 'legacy -mos-tiny was forwarded to V2'

    for blocked_args in [
        ['--skip-builtin', '--', '-v2', 'main.v'],
        ['--skip-builtin', 'run', 'main.v', '-v2'],
        ['main.v', '--skip-builtin', '-v2'],
    ] {
        blocked_res := run_v_command_with_exe(wrapper_exe, project_dir, blocked_args, envs)
        assert blocked_res.exit_code == 1, blocked_res.output
        assert blocked_res.output.contains('Unknown argument `--skip-builtin`'), blocked_res.output
    }

    late_hooks_res := run_v_command_with_exe(wrapper_exe, project_dir, [
        '-fhooks',
        'output',
        'run',
        'main.v',
        '-v2',
    ], envs)
    assert late_hooks_res.exit_code == 1, late_hooks_res.output
    assert late_hooks_res.output.contains('Unknown argument `-fhooks`'), late_hooks_res.output

    os_none_after_run_res := run_v_command_with_exe(wrapper_exe, project_dir, [
        '-os',
        'none',
        'run',
        'main.v',
        '-v2',
    ], envs)
    assert os_none_after_run_res.exit_code == 1, os_none_after_run_res.output
    assert os_none_after_run_res.output.contains('unknown operating system target `none`'), os_none_after_run_res.output
}

fn run_v_command(work_dir string, args []string, envs map[string]string) CmdResult {
    return run_v_command_with_exe(current_vexe, work_dir, args, envs)
}

fn run_v_command_with_exe(vexe string, work_dir string, args []string, envs map[string]string) CmdResult {
    mut process := os.new_process(vexe)
    process.set_work_folder(work_dir)
    process.set_args(args)
    process.set_environment(envs)
    process.set_redirect_stdio()
    process.wait()
    output := process.stdout_slurp() + process.stderr_slurp()
    exit_code := if process.code == -1 { 1 } else { process.code }
    process.close()
    return CmdResult{
        exit_code: exit_code
        output:    output
    }
}

fn find_path_env_key(envs map[string]string) string {
    if 'PATH' in envs {
        return 'PATH'
    }
    if 'Path' in envs {
        return 'Path'
    }
    return 'PATH'
}