module c

import v3.flat
import v3.types

struct MultiReturnTailParts {
    prefix_count int
    values       []flat.NodeId
}

// gen_if emits if output for c.
fn (mut g FlatGen) gen_if(node flat.Node) {
    // Iterate the `else if` chain rather than recursing through gen_if/gen_if_else for
    // each link. A lowered match can produce hundreds of chained `if_expr` nodes (one
    // per arm); recursing once per arm overflows the stack on big matches. The emitted
    // C is identical — only the generation is flattened into a loop.
    mut cur := node
    for {
        if cur.children_count < 2 {
            return
        }
        cond_id := g.a.child(&cur, 0)
        if !g.valid_node_id(cond_id) {
            return
        }
        cond := g.a.nodes[int(cond_id)]
        if cond.kind == .decl_assign {
            g.gen_if_guard(cur, cond)
            return
        }
        if cond.kind != .empty {
            g.write('if (')
            g.gen_expr(cond_id)
            g.writeln(') {')
        } else {
            g.writeln('{')
        }
        g.tc.push_scope()
        defer_start := g.defers.len
        g.indent++
        if cond.kind == .is_expr {
            g.smartcast_is_expr(&cond)
        }
        then_id := g.a.child(&cur, 1)
        if g.valid_node_id(then_id) {
            then_block := g.a.nodes[int(then_id)]
            for i in 0 .. then_block.children_count {
                child_id := g.a.child(&then_block, i)
                if g.valid_node_id(child_id) {
                    g.gen_node(child_id)
                }
            }
        }
        g.gen_defers_from(defer_start)
        g.trim_defers(defer_start)
        g.indent--
        g.tc.pop_scope()
        // else handling — continue the loop for a plain `else if`, recurse only for the
        // rare guard-else (`else if x := ...`).
        if cur.children_count <= 2 {
            g.writeln('}')
            return
        }
        else_id := g.a.child(&cur, 2)
        if !g.valid_node_id(else_id) {
            g.writeln('}')
            return
        }
        else_node := g.a.nodes[int(else_id)]
        if else_node.kind == .if_expr {
            else_cond_id := g.a.child(&else_node, 0)
            else_cond_is_guard := if g.valid_node_id(else_cond_id) {
                g.a.nodes[int(else_cond_id)].kind == .decl_assign
            } else {
                false
            }
            if else_cond_is_guard {
                g.writeln('} else {')
                g.tc.push_scope()
                g.indent++
                g.gen_if(else_node)
                g.indent--
                g.tc.pop_scope()
                g.writeln('}')
                return
            }
            g.write('} else ')
            cur = else_node
            continue
        } else if else_node.kind == .block {
            g.writeln('} else {')
            g.tc.push_scope()
            else_defer_start := g.defers.len
            g.indent++
            for i in 0 .. else_node.children_count {
                child_id := g.a.child(&else_node, i)
                if g.valid_node_id(child_id) {
                    g.gen_node(child_id)
                }
            }
            g.gen_defers_from(else_defer_start)
            g.trim_defers(else_defer_start)
            g.indent--
            g.tc.pop_scope()
            g.writeln('}')
            return
        } else {
            g.writeln('}')
            return
        }
    }
}

// smartcast_is_expr supports smartcast is expr handling for FlatGen.
fn (mut g FlatGen) smartcast_is_expr(cond &flat.Node) {
    expr_id := g.a.child(cond, 0)
    expr_node := g.a.nodes[int(expr_id)]
    if expr_node.kind == .ident {
        sum_type := g.tc.resolve_type(expr_id)
        clean_sum0 := types.unwrap_pointer(sum_type)
        mut clean_sum := clean_sum0
        if clean_sum0 is types.Alias {
            clean_sum = clean_sum0.base_type
        }
        if clean_sum is types.SumType {
            variant_name := g.resolve_variant(clean_sum.name, cond.value)
            variant_type := g.tc.parse_type(variant_name)
            if variant_type is types.Void {
                return
            }
            variant_ct := g.tc.c_type(variant_type)
            field_name := g.sum_field_name(variant_name)
            is_ptr_variant := g.variant_references_sum(variant_name, clean_sum.name)
            var_name := c_name(expr_node.value)
            tmp := g.tmp_name()
            if is_ptr_variant {
                g.writeln('${variant_ct} ${tmp} = *${var_name}.${field_name};')
            } else {
                g.writeln('${variant_ct} ${tmp} = ${var_name}.${field_name};')
            }
            g.writeln('${variant_ct} ${var_name} = ${tmp};')
            g.tc.cur_scope.insert(expr_node.value, variant_type)
        }
    }
}

// expr_key supports expr key handling for FlatGen.
fn (g &FlatGen) expr_key(id flat.NodeId) string {
    node := g.a.nodes[int(id)]
    if node.kind == .ident {
        return node.value
    }
    if node.kind == .selector && node.children_count > 0 {
        base_key := g.expr_key(g.a.child(&node, 0))
        if base_key.len > 0 {
            return '${base_key}.${node.value}'
        }
    }
    return ''
}

// gen_if_guard emits if guard output for c.
fn (mut g FlatGen) gen_if_guard(node flat.Node, cond flat.Node) {
    if cond.children_count < 2 {
        return
    }
    lhs_id := g.a.child(&cond, 0)
    rhs_id := g.a.child(&cond, 1)
    if !g.valid_node_id(lhs_id) || !g.valid_node_id(rhs_id) {
        return
    }
    lhs := g.a.nodes[int(lhs_id)]
    rhs := g.a.nodes[int(rhs_id)]
    var_name := c_name(lhs.value)
    tmp := g.tmp_name()
    defer_start := g.defers.len
    if rhs.kind == .index {
        base_id := g.a.child(rhs, 0)
        base_type := g.tc.resolve_type(base_id)
        if base_type is types.Map {
            c_val_type := g.tc.c_type(base_type.value_type)
            c_key_type := g.tc.c_type(base_type.key_type)
            g.write('void* ${tmp} = map__get_check(&')
            g.gen_expr(base_id)
            g.write(', &(${c_key_type}[]){')
            g.gen_expr(g.a.child(rhs, 1))
            g.writeln('});')
            g.writeln('if (${tmp} != NULL) {')
            g.tc.push_scope()
            g.indent++
            g.writeln('${c_val_type} ${var_name} = *(${c_val_type}*)${tmp};')
            g.tc.cur_scope.insert(lhs.value, base_type.value_type)
        } else {
            rhs_type := g.tc.resolve_type(rhs_id)
            opt_ct := g.optional_type_name(rhs_type)
            val_ct, val_type := g.optional_value_ct(rhs_type)
            g.write('${opt_ct} ${tmp} = ')
            g.gen_expr(rhs_id)
            g.writeln(';')
            g.writeln('if (${tmp}.ok) {')
            g.tc.push_scope()
            g.indent++
            g.writeln('${val_ct} ${var_name} = ${tmp}.value;')
            g.tc.cur_scope.insert(lhs.value, val_type)
        }
    } else {
        rhs_type := g.tc.resolve_type(rhs_id)
        opt_ct := g.optional_type_name(rhs_type)
        val_ct, val_type := g.optional_value_ct(rhs_type)
        g.write('${opt_ct} ${tmp} = ')
        g.gen_expr(rhs_id)
        g.writeln(';')
        g.writeln('if (${tmp}.ok) {')
        g.tc.push_scope()
        g.indent++
        g.writeln('${val_ct} ${var_name} = ${tmp}.value;')
        g.tc.cur_scope.insert(lhs.value, val_type)
    }
    then_id := g.a.child(&node, 1)
    if g.valid_node_id(then_id) {
        then_block := g.a.nodes[int(then_id)]
        for i in 0 .. then_block.children_count {
            child_id := g.a.child(&then_block, i)
            if g.valid_node_id(child_id) {
                g.gen_node(child_id)
            }
        }
    }
    g.gen_defers_from(defer_start)
    g.trim_defers(defer_start)
    g.indent--
    g.tc.pop_scope()
    g.gen_if_else(node)
}

// gen_if_else emits if else output for c.
fn (mut g FlatGen) gen_if_else(node flat.Node) {
    if node.children_count > 2 {
        else_id := g.a.child(&node, 2)
        if !g.valid_node_id(else_id) {
            g.writeln('}')
            return
        }
        else_node := g.a.nodes[int(else_id)]
        if else_node.kind == .if_expr {
            else_cond_id := g.a.child(&else_node, 0)
            else_cond_is_guard := if g.valid_node_id(else_cond_id) {
                g.a.nodes[int(else_cond_id)].kind == .decl_assign
            } else {
                false
            }
            if else_cond_is_guard {
                g.writeln('} else {')
                g.tc.push_scope()
                g.indent++
                g.gen_if(else_node)
                g.indent--
                g.tc.pop_scope()
                g.writeln('}')
            } else {
                g.write('} else ')
                g.gen_if(else_node)
            }
        } else if else_node.kind == .block {
            g.writeln('} else {')
            g.tc.push_scope()
            defer_start := g.defers.len
            g.indent++
            for i in 0 .. else_node.children_count {
                child_id := g.a.child(&else_node, i)
                if g.valid_node_id(child_id) {
                    g.gen_node(child_id)
                }
            }
            g.gen_defers_from(defer_start)
            g.trim_defers(defer_start)
            g.indent--
            g.tc.pop_scope()
            g.writeln('}')
        } else {
            g.writeln('}')
        }
    } else {
        g.writeln('}')
    }
}

// gen_if_expr emits if expr output for c.
fn (mut g FlatGen) gen_if_expr(node flat.Node) {
    then_block := g.a.child_node(&node, 1)
    mut needs_stmt_expr := then_block.children_count > 1
    if !needs_stmt_expr && node.children_count > 2 {
        else_node := g.a.child_node(&node, 2)
        if else_node.kind == .block && else_node.children_count > 1 {
            needs_stmt_expr = true
        } else if else_node.kind == .if_expr {
            needs_stmt_expr = true
        }
    }
    if needs_stmt_expr {
        g.gen_if_expr_stmt(node)
        return
    }
    g.write('(')
    g.gen_expr(g.a.child(&node, 0))
    g.write(' ? ')
    if then_block.children_count > 0 {
        last := g.a.child_node(then_block, then_block.children_count - 1)
        if last.kind == .expr_stmt {
            g.gen_expr(g.a.child(last, 0))
        } else {
            g.gen_expr(g.a.child(then_block, then_block.children_count - 1))
        }
    }
    g.write(' : ')
    if node.children_count > 2 {
        else_node := g.a.child_node(&node, 2)
        if else_node.kind == .if_expr {
            g.gen_if_expr(*else_node)
        } else if else_node.kind == .block {
            if else_node.children_count > 0 {
                last := g.a.child_node(else_node, else_node.children_count - 1)
                if last.kind == .expr_stmt {
                    g.gen_expr(g.a.child(last, 0))
                } else {
                    g.gen_expr(g.a.child(else_node, else_node.children_count - 1))
                }
            } else {
                g.write('0')
            }
        }
    } else {
        g.write('0')
    }
    g.write(')')
}

// gen_if_expr_block emits if expr block output for c.
fn (mut g FlatGen) gen_if_expr_block(block &flat.Node, ret_type types.Type) {
    if ret_type is types.MultiReturn {
        if g.gen_if_expr_multi_return_block(block, ret_type) {
            return
        }
    }
    for i in 0 .. block.children_count {
        child_id := g.a.child(block, i)
        child := g.a.nodes[int(child_id)]
        if i == block.children_count - 1 {
            if child.kind == .expr_stmt {
                g.write('_ifexpr = ')
                g.gen_expr(g.a.child(child, 0))
                g.writeln(';')
            } else if child.kind == .if_expr {
                g.write('_ifexpr = ')
                g.gen_if_expr(child)
                g.writeln(';')
            } else if g.is_expr_kind(child.kind) {
                g.write('_ifexpr = ')
                g.gen_expr(child_id)
                g.writeln(';')
            } else {
                g.gen_node(child_id)
            }
        } else {
            g.gen_node(child_id)
        }
    }
}

fn (g &FlatGen) multi_return_tail_parts(block &flat.Node, count int) ?MultiReturnTailParts {
    if block.kind != .block || count <= 0 || block.children_count == 0 {
        return none
    }
    last_id := g.a.child(block, block.children_count - 1)
    last := g.a.nodes[int(last_id)]
    if last.kind == .block {
        if nested := g.multi_return_tail_parts(&last, count) {
            if nested.prefix_count == 0 {
                return MultiReturnTailParts{
                    prefix_count: int(block.children_count) - 1
                    values:       nested.values.clone()
                }
            }
        }
    }
    mut values := []flat.NodeId{}
    for i := int(block.children_count) - 1; i >= 0; i-- {
        child_id := g.a.child(block, i)
        child := g.a.nodes[int(child_id)]
        if child.kind != .expr_stmt || child.children_count != 1 {
            break
        }
        values.prepend(g.a.child(&child, 0))
        if values.len == count {
            return MultiReturnTailParts{
                prefix_count: i
                values:       values.clone()
            }
        }
    }
    return none
}

fn (mut g FlatGen) gen_if_expr_multi_return_block(block &flat.Node, ret_type types.MultiReturn) bool {
    parts := g.multi_return_tail_parts(block, ret_type.types.len) or { return false }
    for i in 0 .. parts.prefix_count {
        g.gen_node(g.a.child(block, i))
    }
    g.write('_ifexpr = (${g.tc.c_type(types.Type(ret_type))}){')
    for i, value_id in parts.values {
        if i > 0 {
            g.write(', ')
        }
        g.write('.arg${i} = ')
        g.gen_expr(value_id)
    }
    g.writeln('};')
    return true
}

// is_expr_kind reports whether is expr kind applies in c.
fn (g &FlatGen) is_expr_kind(kind flat.NodeKind) bool {
    return match kind {
        .int_literal, .float_literal, .bool_literal, .char_literal, .string_literal,
        .string_interp, .ident, .infix, .prefix, .postfix, .paren, .call, .selector, .index,
        .if_expr, .struct_init, .field_init, .array_literal, .array_init, .map_init, .fn_literal,
        .or_expr, .cast_expr, .as_expr, .enum_val, .assoc, .range, .nil_literal, .none_expr,
        .spawn_expr, .lock_expr, .lambda_expr, .sizeof_expr, .typeof_expr, .dump_expr,
        .offsetof_expr, .is_expr, .in_expr {
            true
        }
        else {
            false
        }
    }
}

// seed_scope_from_decl converts seed scope from decl data for c.
fn (mut g FlatGen) seed_scope_from_decl(node flat.Node) {
    if node.kind != .decl_assign || node.children_count < 2 {
        return
    }
    lhs := g.a.child_node(&node, 0)
    if lhs.kind != .ident || lhs.value.len == 0 {
        return
    }
    rhs_id := g.a.child(&node, 1)
    g.tc.cur_scope.insert(lhs.value, g.tc.resolve_type(rhs_id))
}

// if_expr_block_tail_type supports if expr block tail type handling for FlatGen.
fn (mut g FlatGen) if_expr_block_tail_type(block &flat.Node) types.Type {
    if block.children_count == 0 {
        return types.Type(types.void_)
    }
    g.tc.push_scope()
    for i in 0 .. block.children_count - 1 {
        g.seed_scope_from_decl(*g.a.child_node(block, i))
    }
    last := g.a.child_node(block, block.children_count - 1)
    ret := if last.kind == .expr_stmt {
        g.tc.resolve_type(g.a.child(last, 0))
    } else {
        g.tc.resolve_type(g.a.child(block, block.children_count - 1))
    }
    g.tc.pop_scope()
    return ret
}

// if_expr_type supports if expr type handling for FlatGen.
fn (mut g FlatGen) if_expr_type(node &flat.Node) types.Type {
    if node.children_count < 2 {
        return types.Type(types.void_)
    }
    then_block := g.a.child_node(node, 1)
    mut ret_type := g.if_expr_block_tail_type(then_block)
    if ret_type is types.Primitive && node.children_count > 2 {
        else_node := g.a.child_node(node, 2)
        if else_node.kind == .block && else_node.children_count > 0 {
            et := g.if_expr_block_tail_type(else_node)
            if et !is types.Primitive {
                ret_type = et
            }
        } else if else_node.kind == .if_expr && else_node.children_count > 2 {
            inner_else := g.a.child_node(else_node, 2)
            if inner_else.kind == .block && inner_else.children_count > 0 {
                et := g.if_expr_block_tail_type(inner_else)
                if et !is types.Primitive {
                    ret_type = et
                }
            }
        }
    }
    return ret_type
}

// gen_if_expr_stmt emits if expr stmt output for c.
fn (mut g FlatGen) gen_if_expr_stmt(node flat.Node) {
    ret_type := if g.expected_expr_type !is types.Void {
        g.expected_expr_type
    } else if node.typ.len > 0 {
        g.tc.parse_type(node.typ)
    } else {
        g.if_expr_type(&node)
    }
    then_block := g.a.child_node(&node, 1)
    ct := g.tc.c_type(ret_type)
    g.writeln('({${ct} _ifexpr;')
    g.write('if (')
    g.gen_expr(g.a.child(&node, 0))
    g.writeln(') {')
    g.gen_if_expr_block(then_block, ret_type)
    g.write('} else ')
    if node.children_count > 2 {
        else_node := g.a.child_node(&node, 2)
        if else_node.kind == .if_expr {
            g.gen_if_expr_else_if(*else_node, ret_type)
        } else if else_node.kind == .block {
            g.writeln('{')
            g.gen_if_expr_block(else_node, ret_type)
            g.writeln('}')
        }
    } else {
        g.writeln('{ _ifexpr = (${ct}){0}; }')
    }
    g.write('_ifexpr;})')
}

// gen_if_expr_else_if emits if expr else if output for c. The `else if` chain is
// iterated rather than recursed: a lowered match-expression can chain hundreds of
// `if_expr` nodes (one per arm), and recursing once per arm — each frame copying a
// `flat.Node` and a `Type` by value — overflows the stack. The emitted C is identical.
fn (mut g FlatGen) gen_if_expr_else_if(node flat.Node, ret_type types.Type) {
    mut cur := node
    for {
        then_block := g.a.child_node(&cur, 1)
        g.write('if (')
        g.gen_expr(g.a.child(&cur, 0))
        g.writeln(') {')
        g.gen_if_expr_block(then_block, ret_type)
        g.write('} else ')
        if cur.children_count > 2 {
            else_node := g.a.child_node(&cur, 2)
            if else_node.kind == .if_expr {
                cur = *else_node
                continue
            } else if else_node.kind == .block {
                g.writeln('{')
                g.gen_if_expr_block(else_node, ret_type)
                g.writeln('}')
            }
            return
        }
        g.writeln('{ _ifexpr = (typeof(_ifexpr)){0}; }')
        return
    }
}