// Copyright (c) 2026 Alexander Medvednikov. All rights reserved.
// Use of this source code is governed by an MIT license
// that can be found in the LICENSE file.
module builder

import runtime
import time
import v2.gen.cleanc

const max_cleanc_pass5_jobs = 16

$if !windows {
    struct GenCleancChunkArgs {
        worker         voidptr // &cleanc.Gen — pre-cloned worker
        work_items_ptr voidptr // &[]cleanc.Pass5WorkItem — work items to process
    }

    @[typedef]
    struct C.pthread_t {}

    fn C.pthread_create(thread &C.pthread_t, attr voidptr, start_routine fn (voidptr) voidptr, arg voidptr) int
    fn C.pthread_join(thread C.pthread_t, retval voidptr) int
    fn C.pthread_attr_init(attr voidptr) int
    fn C.pthread_attr_setstacksize(attr voidptr, stacksize usize) int
    fn C.pthread_attr_destroy(attr voidptr) int

    fn gen_cleanc_chunk_thread(arg voidptr) voidptr {
        a := unsafe { &GenCleancChunkArgs(arg) }
        mut w := unsafe { &cleanc.Gen(a.worker) }
        items := unsafe { &[]cleanc.Pass5WorkItem(a.work_items_ptr) }
        w.gen_pass5_work_items(*items)
        return unsafe { nil }
    }
}

fn print_cleanc_parallel_step_time(stats_enabled bool, step string, elapsed time.Duration) {
    if !stats_enabled {
        return
    }
    println('   - C Gen/full ${step}: ${elapsed.milliseconds()}ms')
}

fn mark_cleanc_parallel_step(stats_enabled bool, mut sw time.StopWatch, stage_start time.Duration, step string) time.Duration {
    if !stats_enabled {
        return stage_start
    }
    now := sw.elapsed()
    print_cleanc_parallel_step_time(true, step, time.Duration(now - stage_start))
    return now
}

fn (mut b Builder) gen_cleanc_parallel(mut gen cleanc.Gen) {
    stats_enabled := b.pref != unsafe { nil } && b.pref.stats
    mut stats_sw := time.new_stopwatch()
    mut stage_start := stats_sw.elapsed()
    emit_indices := gen.gen_pass5_pre()
    stage_start = mark_cleanc_parallel_step(stats_enabled, mut stats_sw, stage_start, 'pass 5 pre')

    // Split large files into sub-file work items so no single huge file
    // (e.g. ssa/builder.v) pins the whole parallel phase.
    work_items := gen.build_pass5_work_items(emit_indices)
    n_items := work_items.len
    n_runtime_jobs := runtime.nr_jobs()
    n_jobs := cleanc_parallel_pass5_job_count(n_runtime_jobs, n_items)

    $if windows {
        gen.gen_pass5_files(emit_indices)
        stage_start = mark_cleanc_parallel_step(stats_enabled, mut stats_sw, stage_start,
            'pass 5 files')
        gen.gen_pass5_post()
        _ = mark_cleanc_parallel_step(stats_enabled, mut stats_sw, stage_start, 'pass 5 post')
        return
    } $else {
        if n_items <= 1 || n_jobs <= 1 {
            // Fallback to sequential
            gen.gen_pass5_files(emit_indices)
            stage_start = mark_cleanc_parallel_step(stats_enabled, mut stats_sw, stage_start,
                'pass 5 files')
            gen.gen_pass5_post()
            _ = mark_cleanc_parallel_step(stats_enabled, mut stats_sw, stage_start, 'pass 5 post')
            return
        }

        mut thread_ids := []C.pthread_t{len: n_jobs}
        mut args := []GenCleancChunkArgs{cap: n_jobs}
        mut workers := []voidptr{cap: n_jobs}
        // chunk_items: work items assigned to each worker.
        // chunk_indices: unique file indices each worker touches (for
        // new_pass5_worker's owned-file / cross-worker dedup bookkeeping).
        mut chunk_items := [][]cleanc.Pass5WorkItem{cap: n_jobs}
        mut chunk_indices := [][]int{cap: n_jobs}
        mut chunk_file_seen := []map[int]bool{cap: n_jobs}
        mut chunk_costs := []int{cap: n_jobs}

        mut chunk_idx := n_jobs
        if chunk_idx > n_items {
            chunk_idx = n_items
        }
        for ci := 0; ci < chunk_idx; ci++ {
            chunk_items << []cleanc.Pass5WorkItem{}
            chunk_indices << []int{}
            chunk_file_seen << map[int]bool{}
            chunk_costs << 0
        }
        mut sorted_items := work_items.clone()
        for i := 1; i < sorted_items.len; i++ {
            mut j := i
            for j > 0 && sorted_items[j - 1].cost < sorted_items[j].cost {
                sorted_items[j - 1], sorted_items[j] = sorted_items[j], sorted_items[j - 1]
                j--
            }
        }
        for item in sorted_items {
            mut target := 0
            for ci := 1; ci < chunk_idx; ci++ {
                if chunk_costs[ci] < chunk_costs[target] {
                    target = ci
                }
            }
            chunk_items[target] << item
            // Only the worker that emits a file's globals (a whole-file item, or the
            // first slice of a split file — both carry emit_globals) takes file-level
            // dedup ownership. A split file's later slices deliberately do NOT, so the
            // file's lazily/transitively emitted fns stay blocked in those workers and
            // only the owning worker can emit them; the explicit slice still emits via
            // the owner-scoped bypass in gen_file_range. This closes the duplicate /
            // reordered-emission hole that file-level ownership left open for files
            // split across workers.
            if item.emit_globals && item.file_idx !in chunk_file_seen[target] {
                chunk_file_seen[target][item.file_idx] = true
                chunk_indices[target] << item.file_idx
            }
            chunk_costs[target] += item.cost
        }
        stage_start = mark_cleanc_parallel_step(stats_enabled, mut stats_sw, stage_start,
            'pass 5 chunk split')
        for ci := 0; ci < chunk_idx; ci++ {
            w := gen.new_pass5_worker(chunk_indices[ci], ci)
            workers << voidptr(w)
        }
        stage_start = mark_cleanc_parallel_step(stats_enabled, mut stats_sw, stage_start,
            'pass 5 worker setup')

        // Set up args after all chunk_items are stable
        for ci := 0; ci < chunk_idx; ci++ {
            args << GenCleancChunkArgs{
                worker:         workers[ci]
                work_items_ptr: unsafe { voidptr(&chunk_items[ci]) }
            }
        }

        attr_buf := [64]u8{}
        attr := unsafe { voidptr(&attr_buf[0]) }
        C.pthread_attr_init(attr)
        C.pthread_attr_setstacksize(attr, 64 * 1024 * 1024)

        for ci := 0; ci < chunk_idx; ci++ {
            C.pthread_create(unsafe { &thread_ids[ci] }, attr, gen_cleanc_chunk_thread,
                unsafe { voidptr(&args[ci]) })
        }
        C.pthread_attr_destroy(attr)

        // Wait for all workers
        for ci := 0; ci < chunk_idx; ci++ {
            C.pthread_join(thread_ids[ci], unsafe { nil })
        }
        stage_start = mark_cleanc_parallel_step(stats_enabled, mut stats_sw, stage_start,
            'pass 5 worker run')

        // Merge worker results in order
        for ci := 0; ci < chunk_idx; ci++ {
            w := unsafe { &cleanc.Gen(workers[ci]) }
            gen.merge_pass5_worker(w)
        }
        stage_start = mark_cleanc_parallel_step(stats_enabled, mut stats_sw, stage_start,
            'pass 5 merge')
        gen.print_pass5_file_times(8)

        gen.gen_pass5_post()
        _ = mark_cleanc_parallel_step(stats_enabled, mut stats_sw, stage_start, 'pass 5 post')
    }
}

fn cleanc_parallel_pass5_job_count(n_runtime_jobs int, n_files int) int {
    if n_runtime_jobs <= 0 || n_files <= 0 {
        return 0
    }
    mut n_jobs := n_runtime_jobs
    if n_jobs > max_cleanc_pass5_jobs {
        n_jobs = max_cleanc_pass5_jobs
    }
    if n_jobs > n_files {
        n_jobs = n_files
    }
    return n_jobs
}