module c

import runtime
import strings
import v3.flat
import v3.types

const max_flat_cgen_jobs = 2
const min_flat_cgen_parallel_items = 1024

// FlatFnGenItem represents flat fn gen item data used by c.
struct FlatFnGenItem {
    node_id flat.NodeId
    file    string
    module  string
    cost    int
}

$if !windows {
    // FlatCgenChunkArgs represents flat cgen chunk args data used by c.
    struct FlatCgenChunkArgs {
        worker         voidptr
        work_items_ptr voidptr
    }

    // C.pthread_t declares C pthread t data used by c.
    @[typedef]
    struct C.pthread_t {}

    // C.pthread_create declares the C pthread_create symbol used by c.
    fn C.pthread_create(thread &C.pthread_t, attr voidptr, start_routine fn (voidptr) voidptr, arg voidptr) int

    // C.pthread_join declares the C pthread_join symbol used by c.
    fn C.pthread_join(thread C.pthread_t, retval voidptr) int

    // C.pthread_attr_init declares the C pthread_attr_init symbol used by c.
    fn C.pthread_attr_init(attr voidptr) int

    // C.pthread_attr_setstacksize declares the C pthread_attr_setstacksize symbol used by c.
    fn C.pthread_attr_setstacksize(attr voidptr, stacksize usize) int

    // C.pthread_attr_destroy declares the C pthread_attr_destroy symbol used by c.
    fn C.pthread_attr_destroy(attr voidptr) int

    // flat_cgen_chunk_thread supports flat cgen chunk thread handling for c.
    fn flat_cgen_chunk_thread(arg voidptr) voidptr {
        a := unsafe { &FlatCgenChunkArgs(arg) }
        mut w := unsafe { &FlatGen(a.worker) }
        items := unsafe { &[]FlatFnGenItem(a.work_items_ptr) }
        w.gen_fn_items(*items)
        return unsafe { nil }
    }
}

// gen_fns_dispatch emits fns dispatch output for c.
fn (mut g FlatGen) gen_fns_dispatch(no_parallel bool) {
    if no_parallel {
        g.gen_fns()
        g.gen_synthetic_main_after_fns()
        return
    }
    items := g.collect_fn_gen_items()
    n_items := items.len
    n_jobs := flat_cgen_job_count(runtime.nr_jobs(), n_items)
    $if windows {
        g.gen_fn_items(items)
        g.gen_synthetic_main_after_fns()
        return
    } $else {
        if n_items < min_flat_cgen_parallel_items || n_jobs <= 1 {
            g.gen_fn_items(items)
            g.gen_synthetic_main_after_fns()
            return
        }
        g.parallel_used = true
        g.prepare_parallel_items(items)
        mut chunk_items := split_flat_cgen_items(items, n_jobs)
        chunk_count := chunk_items.len
        // chunk[0] is emitted by the master (this thread) directly into its own builder
        // — no worker clone. Only chunks[1..] get helper threads with a cloned FlatGen.
        // This drops one full FlatGen clone from the peak and uses the master thread that
        // would otherwise just block in join.
        thread_count := chunk_count - 1
        mut thread_ids := []C.pthread_t{len: thread_count}
        mut args := []FlatCgenChunkArgs{cap: thread_count}
        mut workers := []voidptr{cap: thread_count}

        // Helper workers keep the same temp-name base they had when every chunk was a
        // worker (worker_id ci+1 -> base (ci+2)*100_000), and the master adopts what was
        // worker 0's base. This keeps each chunk in its own disjoint _tN range AND makes
        // the output byte-identical to the all-workers version.
        for ci := 0; ci < thread_count; ci++ {
            w := g.new_parallel_worker(ci + 1)
            workers << voidptr(w)
        }
        for ci := 0; ci < thread_count; ci++ {
            args << FlatCgenChunkArgs{
                worker:         workers[ci]
                work_items_ptr: unsafe { voidptr(&chunk_items[ci + 1]) }
            }
        }

        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 < thread_count; ci++ {
            C.pthread_create(unsafe { &thread_ids[ci] }, attr, flat_cgen_chunk_thread,
                unsafe { voidptr(&args[ci]) })
        }
        C.pthread_attr_destroy(attr)
        // Master emits chunk[0] into g.sb while the helper threads run, using worker 0's
        // old temp base so its emitted temps match the all-workers numbering.
        g.tmp_count = 100_000
        g.gen_fn_items(chunk_items[0])
        for ci := 0; ci < thread_count; ci++ {
            C.pthread_join(thread_ids[ci], unsafe { nil })
        }
        // Merge helper output after the master's chunk[0], in fixed order.
        for ci := 0; ci < thread_count; ci++ {
            w := unsafe { &FlatGen(workers[ci]) }
            g.merge_parallel_worker(w)
        }
        g.gen_synthetic_main_after_fns()
    }
}

// flat_cgen_job_count supports flat cgen job count handling for c.
fn flat_cgen_job_count(n_runtime_jobs int, n_items int) int {
    if n_runtime_jobs <= 0 || n_items <= 0 {
        return 0
    }
    mut n_jobs := n_runtime_jobs
    if n_jobs > max_flat_cgen_jobs {
        n_jobs = max_flat_cgen_jobs
    }
    if n_jobs > n_items {
        n_jobs = n_items
    }
    return n_jobs
}

// split_flat_cgen_items supports split flat cgen items handling for c.
fn split_flat_cgen_items(items []FlatFnGenItem, n_jobs int) [][]FlatFnGenItem {
    mut chunks := [][]FlatFnGenItem{}
    if n_jobs <= 0 || items.len == 0 {
        return chunks
    }
    mut total_cost := 0
    for item in items {
        total_cost += item.cost
    }
    mut target_cost := total_cost / n_jobs
    if total_cost % n_jobs != 0 {
        target_cost++
    }
    if target_cost < 1 {
        target_cost = 1
    }
    mut current := []FlatFnGenItem{}
    mut current_cost := 0
    mut chunks_left := n_jobs
    for idx, item in items {
        remaining_items := items.len - idx
        if current.len > 0 && current_cost >= target_cost && chunks_left > 1
            && remaining_items >= chunks_left {
            chunks << current
            current = []FlatFnGenItem{}
            current_cost = 0
            chunks_left--
        }
        current << item
        current_cost += item.cost
    }
    if current.len > 0 {
        chunks << current
    }
    return chunks
}

// collect_fn_gen_items updates collect fn gen items state for c.
fn (mut g FlatGen) collect_fn_gen_items() []FlatFnGenItem {
    mut items := []FlatFnGenItem{}
    mut cur_module := ''
    mut cur_file := ''
    for i in 0 .. g.a.nodes.len {
        node := g.a.nodes[i]
        kind_id := node_kind_id(node)
        if kind_id == 77 {
            cur_file = node.value
            g.tc.cur_file = cur_file
            cur_module = ''
            g.tc.cur_module = cur_module
            continue
        }
        if kind_id == 73 {
            cur_module = node.value
            g.tc.cur_file = cur_file
            g.tc.cur_module = cur_module
            continue
        }

        if kind_id != 61 {
            continue
        }
        if !g.should_emit_fn_node_in_module(node, i, cur_module) {
            continue
        }
        qfn := qualified_fn_name_in_module(cur_module, node.value)
        if g.emitted_fn_contains(qfn) {
            continue
        }
        g.emitted_fns[qfn] = true
        items << FlatFnGenItem{
            node_id: flat.NodeId(i)
            file:    cur_file
            module:  cur_module
            cost:    node.children_count + 1
        }
    }
    return items
}

// gen_fn_items emits fn items output for c.
fn (mut g FlatGen) gen_fn_items(items []FlatFnGenItem) {
    for item in items {
        if int(item.node_id) < 0 || int(item.node_id) >= g.a.nodes.len {
            continue
        }
        g.tc.cur_file = item.file
        g.tc.cur_module = item.module
        node := g.a.nodes[int(item.node_id)]
        g.gen_fn_in_module(node, item.module)
    }
}

// prepare_parallel_items supports prepare parallel items handling for FlatGen.
fn (mut g FlatGen) prepare_parallel_items(items []FlatFnGenItem) {
    for item in items {
        g.tc.cur_file = item.file
        g.tc.cur_module = item.module
        g.prepare_parallel_node(item.node_id)
    }
    g.register_interface_strings()
}

// prepare_parallel_node supports prepare parallel node handling for FlatGen.
fn (mut g FlatGen) prepare_parallel_node(id flat.NodeId) {
    if int(id) < 0 || int(id) >= g.a.nodes.len {
        return
    }
    node := g.a.nodes[int(id)]
    if node.kind == .string_literal {
        g.intern_string(node.value)
    }
    if g.should_preseed_parallel_type_text(node.typ) {
        g.preseed_parallel_fn_ptr_type(g.tc.parse_type(node.typ))
    }
    if expr_type := g.tc.expr_type(id) {
        g.preseed_parallel_fn_ptr_type(expr_type)
    }
    for i in 0 .. node.children_count {
        g.prepare_parallel_node(g.a.child(&node, i))
    }
}

// should_preseed_parallel_type_text reports whether should preseed parallel type text applies in c.
fn (g &FlatGen) should_preseed_parallel_type_text(typ string) bool {
    if typ.len == 0 {
        return false
    }
    clean := g.parallel_base_type_text(typ)
    if clean.starts_with('fn(') || clean.starts_with('fn (') {
        return true
    }
    if clean in g.tc.type_aliases {
        return true
    }
    qtyp := g.tc.qualify_name(clean)
    return qtyp in g.tc.type_aliases
}

// parallel_base_type_text supports parallel base type text handling for FlatGen.
fn (g &FlatGen) parallel_base_type_text(typ string) string {
    mut clean := typ.trim_space()
    for clean.len > 0 {
        if clean.starts_with('shared ') {
            clean = clean[7..].trim_space()
        } else if clean[0] == `&` || clean[0] == `?` || clean[0] == `!` {
            clean = clean[1..].trim_space()
        } else if clean.starts_with('...') {
            clean = clean[3..].trim_space()
        } else if clean.starts_with('[]') {
            clean = clean[2..].trim_space()
        } else {
            break
        }
    }
    return clean
}

// preseed_parallel_fn_ptr_type supports preseed parallel fn ptr type handling for FlatGen.
fn (mut g FlatGen) preseed_parallel_fn_ptr_type(typ types.Type) {
    if typ is types.FnType {
        g.resolve_fn_ptr_type(g.fn_ptr_type_key(typ))
        for param in typ.params {
            g.preseed_parallel_fn_ptr_type(param)
        }
        g.preseed_parallel_fn_ptr_type(typ.return_type)
    } else if typ is types.Pointer {
        g.preseed_parallel_fn_ptr_type(typ.base_type)
    } else if typ is types.Array {
        g.preseed_parallel_fn_ptr_type(typ.elem_type)
    } else if typ is types.ArrayFixed {
        g.preseed_parallel_fn_ptr_type(typ.elem_type)
    } else if typ is types.Map {
        g.preseed_parallel_fn_ptr_type(typ.key_type)
        g.preseed_parallel_fn_ptr_type(typ.value_type)
    } else if typ is types.OptionType {
        g.preseed_parallel_fn_ptr_type(typ.base_type)
    } else if typ is types.ResultType {
        g.preseed_parallel_fn_ptr_type(typ.base_type)
    } else if typ is types.Alias {
        g.preseed_parallel_fn_ptr_type(typ.base_type)
    } else if typ is types.MultiReturn {
        for item in typ.types {
            g.preseed_parallel_fn_ptr_type(item)
        }
    }
}

// fn_ptr_type_key supports fn ptr type key handling for FlatGen.
fn (mut g FlatGen) fn_ptr_type_key(typ types.FnType) string {
    ret := if typ.return_type is types.Void { 'void' } else { g.tc.c_type(typ.return_type) }
    if typ.params.len == 0 {
        return 'fn_ptr:${ret}|void'
    }
    mut params := []string{}
    for param in typ.params {
        params << g.tc.c_type(param)
    }
    return 'fn_ptr:${ret}|${params.join(', ')}'
}

// new_parallel_worker builds a per-worker FlatGen for parallel codegen.
//
// The lookup tables populated before gen_fns_dispatch (in collect_gen_info,
// collect_interface_impls and the precompute_* passes) are READ-ONLY during codegen, so
// they are SHARED by reference instead of cloned — V maps/arrays are reference types and
// concurrent readers are safe. Only the state a worker actually mutates while emitting is
// kept private: the output builder; the string-literal table (interned during gen); the
// fn_ptr_types / needed_optional_types / emitted_* sets and the param_types_cache /
// array_method_cache memoization caches (all written during gen); the per-function
// cur_param_* scratch; and runtime_inits (kept private out of caution). This drops the
// bulk of each worker's clone cost — previously the whole table set was duplicated per
// worker and, under -gc none, never freed.
fn (g &FlatGen) new_parallel_worker(worker_id int) &FlatGen {
    return &FlatGen{
        sb:                       strings.new_builder(64_000)
        a:                        unsafe { g.a }
        used_fns:                 g.used_fns
        used_fn_names:            g.used_fn_names
        test_files:               g.test_files.clone()
        str_lits:                 g.str_lits.clone()
        str_lit_ids:              g.str_lit_ids.clone()
        global_types:             g.global_types
        enum_vals:                g.enum_vals
        interfaces:               g.interfaces
        const_vals:               g.const_vals
        const_modules:            g.const_modules
        const_init_order:         g.const_init_order
        global_modules:           g.global_modules
        global_inits:             g.global_inits
        global_init_order:        g.global_init_order
        iface_impls:              g.iface_impls
        iface_type_ids:           g.iface_type_ids
        module_init_fns:          g.module_init_fns
        module_init_fn_modules:   g.module_init_fn_modules
        module_imports:           g.module_imports
        libc_compat_fns:          g.libc_compat_fns.clone()
        tc:                       g.clone_parallel_type_checker()
        has_builtins:             g.has_builtins
        tmp_count:                (worker_id + 1) * 100_000
        line_start:               true
        modules:                  g.modules
        fn_ptr_types:             g.fn_ptr_types.clone()
        fixed_array_ret_wrappers: g.fixed_array_ret_wrappers
        fn_decl_param_types:      g.fn_decl_param_types
        fn_decl_ret_types:        g.fn_decl_ret_types
        struct_decl_infos:        g.struct_decl_infos
        struct_decl_short_infos:  g.struct_decl_short_infos
        runtime_inits:            g.runtime_inits.clone()
        compiler_vroot:           g.compiler_vroot
        cur_param_names:          g.cur_param_names.clone()
        cur_param_type_values:    g.cur_param_type_values.clone()
        cur_param_types:          g.cur_param_types.clone()
        cur_fn_ret:               g.cur_fn_ret
        cur_fn_ret_is_optional:   g.cur_fn_ret_is_optional
        cur_fn_ret_base:          g.cur_fn_ret_base
        expected_expr_type:       g.expected_expr_type
        expected_enum:            g.expected_enum
        needed_optional_types:    g.needed_optional_types.clone()
        emitted_optional_types:   g.emitted_optional_types.clone()
        emitted_fns:              g.emitted_fns.clone()
        array_method_cache:       g.array_method_cache.clone()
        param_types_cache:        g.param_types_cache.clone()
        embedded_fields_by_type:  g.embedded_fields_by_type
        param_types_by_short:     g.param_types_by_short
        spawn_wrapper_names:      g.spawn_wrapper_names.clone()
        spawn_wrapper_defs:       g.spawn_wrapper_defs.clone()
        callback_wrapper_names:   g.callback_wrapper_names.clone()
        callback_wrapper_defs:    g.callback_wrapper_defs.clone()
    }
}

// clone_parallel_type_checker builds a per-worker TypeChecker for parallel codegen.
//
// During codegen the checker's lookup tables are READ-ONLY: cgen only ever assigns the
// scalar `cur_file`/`cur_module` fields, and the read paths it uses (expr_type, c_type,
// parse_type, resolve_type, cached_resolved_call) never write into the big maps — the only
// memoizing write is into `type_cache`, which is left nil here so workers take the uncached
// path. V maps and arrays are reference types, so the read-only tables are SHARED by
// reference (no `.clone()`), exactly like the already-shared `a` FlatAst. This avoids
// deep-copying the program-wide `expr_type_*`/`structs`/signature tables once per worker,
// which was the bulk of parallel cgen's extra RAM and serial setup time.
//
// Only genuinely per-worker mutable state is given its own copy: the scope chain (gen pushes
// child scopes) and `errors` (avoid a concurrent append race, though gen does not emit any).
fn (g &FlatGen) clone_parallel_type_checker() &types.TypeChecker {
    mut fs := types.new_scope(unsafe { nil })
    fs.names = g.tc.file_scope.names.clone()
    fs.types = g.tc.file_scope.types.clone()
    return &types.TypeChecker{
        a:                             unsafe { g.tc.a }
        fn_ret_types:                  g.tc.fn_ret_types
        fn_param_types:                g.tc.fn_param_types
        fn_ret_type_texts:             g.tc.fn_ret_type_texts
        fn_param_type_texts:           g.tc.fn_param_type_texts
        fn_type_files:                 g.tc.fn_type_files
        fn_type_modules:               g.tc.fn_type_modules
        fn_variadic:                   g.tc.fn_variadic
        fn_implicit_veb_ctx:           g.tc.fn_implicit_veb_ctx
        c_variadic_fns:                g.tc.c_variadic_fns
        structs:                       g.tc.structs
        struct_generic_params:         g.tc.struct_generic_params
        struct_field_c_abi_fns:        g.tc.struct_field_c_abi_fns
        unions:                        g.tc.unions
        type_aliases:                  g.tc.type_aliases
        type_alias_c_abi_fns:          g.tc.type_alias_c_abi_fns
        sum_types:                     g.tc.sum_types
        enum_names:                    g.tc.enum_names
        enum_fields:                   g.tc.enum_fields
        flag_enums:                    g.tc.flag_enums
        interface_names:               g.tc.interface_names
        interface_fields:              g.tc.interface_fields
        interface_embeds:              g.tc.interface_embeds
        interface_abstract_methods:    g.tc.interface_abstract_methods
        c_globals:                     g.tc.c_globals
        const_types:                   g.tc.const_types
        const_exprs:                   g.tc.const_exprs
        const_modules:                 g.tc.const_modules
        const_suffixes:                g.tc.const_suffixes
        imports:                       g.tc.imports
        file_imports:                  g.tc.file_imports
        file_selective_imports:        g.tc.file_selective_imports
        file_modules:                  g.tc.file_modules
        file_scope:                    fs
        cur_scope:                     fs
        scope_pool:                    []&types.Scope{}
        has_builtins:                  g.tc.has_builtins
        cur_module:                    g.tc.cur_module
        cur_file:                      g.tc.cur_file
        errors:                        g.tc.errors.clone()
        resolved_call_names:           g.tc.resolved_call_names
        resolved_call_set:             g.tc.resolved_call_set
        resolved_fn_value_names:       g.tc.resolved_fn_value_names
        resolved_fn_value_set:         g.tc.resolved_fn_value_set
        expr_type_values:              g.tc.expr_type_values
        expr_type_set:                 g.tc.expr_type_set
        checking_nodes:                g.tc.checking_nodes
        diagnose_unknown_calls:        g.tc.diagnose_unknown_calls
        reject_unlowered_map_mutation: g.tc.reject_unlowered_map_mutation
        diagnostic_files:              g.tc.diagnostic_files
        cur_fn_ret_type:               g.tc.cur_fn_ret_type
        smartcasts:                    g.tc.smartcasts
        // Read-only map cgen uses to recover substituted signatures for generic-receiver
        // method values (`Box[int].method` as a callback); without it a parallel worker
        // sees an empty map and gen_method_value_closure falls through.
        generic_method_value_info: g.tc.generic_method_value_info
    }
}

// merge_parallel_worker supports merge parallel worker handling for FlatGen.
fn (mut g FlatGen) merge_parallel_worker(w &FlatGen) {
    mut ww := unsafe { w }
    worker_output := ww.sb.str()
    if worker_output.len > 0 {
        g.sb.write_string(worker_output)
    }
    // The master builder has copied the worker output; release the worker buffers.
    unsafe {
        worker_output.free()
        ww.sb.free()
    }
    for opt_name, val_type in w.needed_optional_types {
        g.needed_optional_types[opt_name] = val_type
    }
    for encoded, name in w.fn_ptr_types {
        if encoded !in g.fn_ptr_types {
            g.fn_ptr_types[encoded] = name
        }
    }
    for name, enabled in w.libc_compat_fns {
        if enabled {
            g.libc_compat_fns[name] = true
        }
    }
    // Spawn wrappers (thread arg structs + trampoline fns) are generated on demand
    // inside fn bodies, so a worker that emits a `spawn` produces wrapper defs the
    // master must also emit. Deduplicate by their deterministic key/def.
    for key, name in w.spawn_wrapper_names {
        if key !in g.spawn_wrapper_names {
            g.spawn_wrapper_names[key] = name
        }
    }
    for def in w.spawn_wrapper_defs {
        if def !in g.spawn_wrapper_defs {
            g.spawn_wrapper_defs << def
        }
    }
    for key, name in w.callback_wrapper_names {
        if key !in g.callback_wrapper_names {
            g.callback_wrapper_names[key] = name
        }
    }
    for def in w.callback_wrapper_defs {
        if def !in g.callback_wrapper_defs {
            g.callback_wrapper_defs << def
        }
    }
}