module cbuilder

import os
import time
import v.util
import v.builder
import sync.pool
import v.gen.c

const cc_compiler = os.getenv_opt('CC') or { 'cc' }
const cc_ldflags = os.getenv_opt('LDFLAGS') or { '' }
const cc_cflags = os.getenv_opt('CFLAGS') or { '' }
const cc_cflags_opt = os.getenv_opt('CFLAGS_OPT') or { '' } // '-O3' }

fn parallel_cc_compiler_path(b &builder.Builder) string {
    if b.pref.ccompiler != '' {
        return b.pref.ccompiler
    }
    return cc_compiler
}

fn parallel_cc(mut b builder.Builder, result c.GenOutput) ! {
    tmp_dir := os.vtmp_dir()
    sw_total := time.new_stopwatch()
    defer {
        eprint_time(sw_total, @METHOD)
    }
    c_files := int_max(1, util.nr_jobs)
    eprintln('> c_files: ${c_files} | util.nr_jobs: ${util.nr_jobs}')

    // Write generated stuff in `g.out` before and after the `out_fn_start_pos` locations,
    // like the `int main()` to "out_0.c" and "out_x.c"

    // out.h
    os.write_file('${tmp_dir}/out.h', result.header) or { panic(err) }

    // out_0.c
    out0 := '//out0\n' + result.out_str[..result.out_fn_start_pos[0]]
    os.write_file('${tmp_dir}/out_0.c', '#include "out.h"\n' + out0 + '\n//X:\n' + result.out0_str) or {
        panic(err)
    }

    // out_x.c
    os.write_file('${tmp_dir}/out_x.c', '#include "out.h"\n\n' + result.extern_str + '\n' +
        result.out_str[result.out_fn_start_pos.last()..]) or { panic(err) }

    mut prev_fn_pos := 0
    mut out_files := []os.File{len: c_files}
    mut fnames := []string{}

    for i in 0 .. c_files {
        fname := '${tmp_dir}/out_${i + 1}.c'
        fnames << fname
        out_files[i] = os.create(fname) or { panic(err) }

        // Common .c file code
        out_files[i].writeln('#include "out.h"\n') or { panic(err) }
        out_files[i].writeln(result.extern_str) or { panic(err) }
    }

    for i, fn_pos in result.out_fn_start_pos {
        if prev_fn_pos >= result.out_str.len || fn_pos >= result.out_str.len || prev_fn_pos > fn_pos {
            eprintln('> EXITING i=${i} out of ${result.out_fn_start_pos.len} prev_pos=${prev_fn_pos} fn_pos=${fn_pos}')
            break
        }
        if i == 0 {
            // Skip typeof etc stuff that's been added to out_0.c
            prev_fn_pos = fn_pos
            continue
        }
        fn_text := result.out_str[prev_fn_pos..fn_pos]
        out_files[i % c_files].writeln(fn_text) or { panic(err) }
        prev_fn_pos = fn_pos
    }
    for i in 0 .. c_files {
        out_files[i].close()
    }

    cc := b.quote_compiler_name(parallel_cc_compiler_path(b))
    mut compile_args := b.get_compile_args()
    mut linker_args := b.get_linker_args()
    if b.ccoptions.cc == .tcc {
        // vlang/tcc has its system headers under `${vroot}/thirdparty/tcc/lib/tcc/include/`
        // and its runtime objects (libtcc1.a, bt-*.o) under `${vroot}/thirdparty/tcc/lib/tcc/`.
        // `-B` controls tcc's include search (`${B}/include`) and `-L` adds a library search path,
        // so pass absolute paths for both. This lets tcc find them regardless of the cwd from
        // which v was invoked, without affecting how user-supplied relative flags are resolved.
        tcc_install_dir := os.join_path(@VEXEROOT, 'thirdparty', 'tcc', 'lib', 'tcc')
        if os.is_dir(tcc_install_dir) {
            tcc_b_arg := '-B${b.tcc_quoted_path(tcc_install_dir)}'
            tcc_l_arg := '-L${b.tcc_quoted_path(tcc_install_dir)}'
            compile_args << tcc_b_arg
            linker_args << tcc_b_arg
            linker_args << tcc_l_arg
        }
    }
    scompile_args := compile_args.join(' ')
    slinker_args := linker_args.join(' ')
    scompile_args_for_linker := compile_args.filter(it != '-x objective-c').join(' ')

    mut o_postfixes := ['0', 'x']
    mut cmds := []string{}
    for i in 0 .. c_files {
        o_postfixes << (i + 1).str()
    }
    for postfix in o_postfixes {
        out_o := os.quoted_path('${tmp_dir}/out_${postfix}.o')
        out_c := os.quoted_path('${tmp_dir}/out_${postfix}.c')
        cmds << '${cc} ${cc_cflags} ${cc_cflags_opt} ${scompile_args} -w -o ${out_o} -c ${out_c}'
    }
    mut failed := 0
    sw := time.new_stopwatch()
    mut pp := pool.new_pool_processor(callback: build_parallel_o_cb)
    pp.set_max_jobs(util.nr_jobs)
    pp.work_on_items(cmds)
    for x in pp.get_results[os.Result]() {
        failed += if x.exit_code == 0 { 0 } else { 1 }
    }
    eprint_time(sw,
        'C compilation on ${util.nr_jobs} thread(s), processing ${cmds.len} commands, failed: ${failed}')
    if failed > 0 {
        return error_with_code('failed parallel C compilation', failed)
    }

    mut ofiles := []string{}
    for f in fnames {
        fo := f.replace('.c', '.o')
        ofiles << os.quoted_path(fo)
    }
    obj_files := ofiles.join(' ')

    alink := [
        cc,
        scompile_args_for_linker,
        '-o',
        os.quoted_path(b.pref.out_name),
        os.quoted_path('${tmp_dir}/out_0.o'),
        obj_files,
        os.quoted_path('${tmp_dir}/out_x.o'),
        slinker_args,
        cc_ldflags,
    ]
    link_cmd := alink.join(' ')

    sw_link := time.new_stopwatch()
    link_res := os.execute(link_cmd)
    eprint_result_time(sw_link, 'link_cmd', link_cmd, link_res)
    // tcc reports duplicate symbol errors via stderr and an executable still gets emitted with exit code 0,
    // so detect that pattern and treat it as a link failure too.
    link_failed_with_tcc_dup := b.ccoptions.cc == .tcc && link_res.output.contains('defined twice')
    if link_res.exit_code != 0 || link_failed_with_tcc_dup {
        return error_with_code('failed to link after parallel C compilation', 1)
    }
}

fn build_parallel_o_cb(mut p pool.PoolProcessor, idx int, _wid int) voidptr {
    cmd := p.get_item[string](idx)
    sw := time.new_stopwatch()
    res := os.execute(cmd)
    eprint_result_time(sw, 'cc_cmd', cmd, res)
    return voidptr(&os.Result{
        ...res
    })
}

fn eprint_result_time(sw time.StopWatch, label string, cmd string, res os.Result) {
    eprint_time(sw, '${label}: `${cmd}` => ${res.exit_code}')
    if res.exit_code != 0 {
        eprintln(res.output)
    }
}

fn eprint_time(sw time.StopWatch, label string) {
    eprintln('> ${sw.elapsed().milliseconds():5} ms, ${label}')
}