// vtest build: !msvc
module main

import os

const parallel_cc_test_path = os.join_path(os.vtmp_dir(), 'parallel_cc_failure_test')
const parallel_cc_vexe = @VEXE

fn run_parallel_cc_case(case_name string, files map[string]string) os.Result {
    return run_parallel_cc_case_with_env(case_name, files, {})
}

fn run_parallel_cc_case_with_env(case_name string, files map[string]string, env_overrides map[string]string) os.Result {
    return run_parallel_cc_case_with_args(case_name, ['-parallel-cc', 'main.v'], files,
        env_overrides)
}

fn run_parallel_cc_case_with_args(case_name string, args []string, files map[string]string, env_overrides map[string]string) os.Result {
    case_dir := os.join_path(parallel_cc_test_path, case_name)
    os.rmdir_all(case_dir) or {}
    os.mkdir_all(case_dir) or { panic(err) }
    defer {
        os.rmdir_all(case_dir) or {}
    }
    for rel_path, contents in files {
        fpath := os.join_path(case_dir, rel_path)
        os.mkdir_all(os.dir(fpath)) or { panic(err) }
        os.write_file(fpath, contents) or { panic(err) }
    }
    mut env := os.environ()
    for key, value in env_overrides {
        env[key] = value
    }
    mut p := os.new_process(parallel_cc_vexe)
    p.set_work_folder(case_dir)
    p.set_args(args)
    p.set_environment(env)
    p.set_redirect_stdio()
    p.wait()
    stdout := p.stdout_slurp()
    stderr := p.stderr_slurp()
    exit_code := p.code
    p.close()
    return os.Result{
        exit_code: exit_code
        output:    '${stdout}${stderr}'
    }
}

fn run_parallel_cc_failure_case(case_name string, files map[string]string) os.Result {
    return run_parallel_cc_case(case_name, files)
}

fn test_parallel_cc_fails_when_c_compilation_fails() {
    res := run_parallel_cc_failure_case('compile_fail', {
        'main.v': 'module main
    #include "definitely_missing_parallel_cc_header.h"
fn main() {}
'
    })
    assert res.exit_code == 1, res.output
    assert res.output.contains('failed parallel C compilation'), res.output
}

fn test_parallel_cc_fails_when_final_linking_fails() {
    res := run_parallel_cc_failure_case('link_fail', {
        'parallel_cc_duplicate_symbol.h': 'int parallel_cc_duplicate_symbol(void) { return 42; }
'
        'main.v':                         'module main
#include "@DIR/parallel_cc_duplicate_symbol.h"
fn C.parallel_cc_duplicate_symbol() int
fn main() {
    println(C.parallel_cc_duplicate_symbol())
}
'
    })
    assert res.exit_code == 1, res.output
    assert res.output.contains('failed to link after parallel C compilation'), res.output
}

fn test_parallel_cc_succeeds_with_array_sort_compare_helper() {
    res := run_parallel_cc_case('array_sort_compare_helper', {
        'main.v': 'module main
    fn main() {
        mut xs := [3, 1, 2]
        xs.sort(a < b)
        println(xs)
    }
    '
    })
    assert res.exit_code == 0, res.output
}

fn test_parallel_cc_uses_resolved_compiler_even_when_cc_env_is_invalid() {
    res := run_parallel_cc_case_with_env('ignore_invalid_cc_env', {
        'main.v': 'module main
fn main() {
    println("hello")
}
'
    }, {
        'CC': 'definitely_missing_parallel_cc_compiler_23174'
    })
    assert res.exit_code == 0, res.output
}