// 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 v2.gen.arm64

$if !windows {
    struct GenARM64ChunkArgs {
        worker    voidptr // &arm64.Gen — pre-cloned worker (created on main thread)
        start_idx int
        end_idx   int
    }

    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_arm64_chunk_thread(arg voidptr) voidptr {
        a := unsafe { &GenARM64ChunkArgs(arg) }
        mut w := unsafe { &arm64.Gen(a.worker) }
        for fi := a.start_idx; fi < a.end_idx; fi++ {
            w.gen_func(fi)
        }
        return unsafe { nil }
    }
}

fn (mut b Builder) gen_arm64_parallel(mut gen arm64.Gen) {
    gen.gen_pre_pass()

    n_funcs := gen.mod.funcs.len
    n_jobs := runtime.nr_jobs()

    $if windows {
        for fi := 0; fi < n_funcs; fi++ {
            gen.gen_func(fi)
        }
        gen.gen_post_pass()
        return
    } $else {
        if n_funcs <= 1 || n_jobs <= 1 {
            // Fallback to sequential
            for fi := 0; fi < n_funcs; fi++ {
                gen.gen_func(fi)
            }
            gen.gen_post_pass()
            return
        }

        // Split functions into chunks
        chunk_size := (n_funcs + n_jobs - 1) / n_jobs
        mut thread_ids := []C.pthread_t{len: n_jobs}
        mut args := []GenARM64ChunkArgs{cap: n_jobs}

        // Pre-create all workers on the main thread to avoid concurrent .clone() races.
        // Each worker gets its own deep copy of maps/arrays.
        mut workers := []voidptr{cap: n_jobs}

        mut chunk_idx := 0
        mut i := 0
        for i < n_funcs {
            end := if i + chunk_size < n_funcs { i + chunk_size } else { n_funcs }
            w := gen.new_worker_clone()
            workers << voidptr(w)
            args << GenARM64ChunkArgs{
                worker:    voidptr(w)
                start_idx: i
                end_idx:   end
            }
            i = end
            chunk_idx++
        }

        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_arm64_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 })
        }

        // Merge worker results in order
        for ci := 0; ci < chunk_idx; ci++ {
            w := unsafe { &arm64.Gen(workers[ci]) }
            gen.merge_worker(w)
        }

        gen.gen_post_pass()
    }
}