module optimize

import v3.ssa

// remove_unreachable_blocks updates remove unreachable blocks state for optimize.
fn remove_unreachable_blocks(mut m ssa.Module) {
    build_cfg(mut m)
    for fi in 0 .. m.funcs.len {
        if m.funcs[fi].blocks.len == 0 {
            continue
        }
        mut reachable := map[int]bool{}
        mut q := []int{}
        q << m.funcs[fi].blocks[0]
        reachable[m.funcs[fi].blocks[0]] = true

        for q.len > 0 {
            curr := q.last()
            q.delete_last()
            for succ in m.blocks[curr].succs {
                if !reachable[succ] {
                    reachable[succ] = true
                    q << succ
                }
            }
        }

        mut new_blocks := []int{}
        for blk in m.funcs[fi].blocks {
            if reachable[blk] {
                new_blocks << blk
            }
        }
        mut func := m.funcs[fi]
        func.blocks = new_blocks
        m.funcs[fi] = func
    }
}

// merge_blocks supports merge blocks handling for optimize.
fn merge_blocks(mut m ssa.Module) {
    mut changed := true
    mut first := true
    for changed {
        changed = false
        if first {
            build_cfg(mut m)
            first = false
        }

        for fi in 0 .. m.funcs.len {
            mut merged := map[int]bool{}

            for blk_id in m.funcs[fi].blocks {
                if merged[blk_id] {
                    continue
                }
                if m.blocks[blk_id].instrs.len == 0 {
                    continue
                }
                last_val := m.blocks[blk_id].instrs.last()
                last_instr := m.instrs[m.values[last_val].index]
                if last_instr.op != .jmp || last_instr.operands.len < 1 {
                    continue
                }
                target_id := int(last_instr.operands[0])
                if target_id < 0 || target_id >= m.blocks.len || target_id == blk_id {
                    continue
                }
                if m.blocks[target_id].preds.len != 1 || m.blocks[target_id].preds[0] != blk_id {
                    continue
                }

                // Phi-safety: don't merge into a block that holds phi nodes. Its phis
                // reference predecessors by block id; collapsing the edge would leave
                // dangling predecessor operands.
                mut target_has_phi := false
                for vid in m.blocks[target_id].instrs {
                    if vid > 0 && vid < m.values.len && m.values[vid].kind == .instruction {
                        if m.instrs[m.values[vid].index].op == .phi {
                            target_has_phi = true
                            break
                        }
                    }
                }
                if target_has_phi {
                    continue
                }

                // Merge: remove jmp from A, append B's instrs (and reparent them).
                mut blk := m.blocks[blk_id]
                blk.instrs.delete_last()
                for moved_val in m.blocks[target_id].instrs {
                    blk.instrs << moved_val
                    if moved_val > 0 && moved_val < m.values.len
                        && m.values[moved_val].kind == .instruction {
                        instr_idx := m.values[moved_val].index
                        if instr_idx >= 0 && instr_idx < m.instrs.len {
                            mut instr := m.instrs[instr_idx]
                            instr.block = blk_id
                            m.instrs[instr_idx] = instr
                        }
                    }
                }
                m.blocks[blk_id] = blk

                // B's successors now have A as a predecessor instead of B. Rewrite any
                // phi predecessor operands that named B (raw block id) to name A.
                for succ_id in m.blocks[target_id].succs {
                    if succ_id < 0 || succ_id >= m.blocks.len {
                        continue
                    }
                    for iv in m.blocks[succ_id].instrs {
                        if iv <= 0 || iv >= m.values.len || m.values[iv].kind != .instruction {
                            continue
                        }
                        idx := m.values[iv].index
                        if m.instrs[idx].op != .phi {
                            continue
                        }
                        mut phi_ins := m.instrs[idx]
                        mut phi_modified := false
                        for i := 1; i < phi_ins.operands.len; i += 2 {
                            if int(phi_ins.operands[i]) == target_id {
                                phi_ins.operands[i] = ssa.ValueID(blk_id)
                                phi_modified = true
                            }
                        }
                        if phi_modified {
                            m.instrs[idx] = phi_ins
                        }
                    }
                }

                merged[target_id] = true
                changed = true
            }

            if merged.len > 0 {
                mut new_blks := []int{}
                for b in m.funcs[fi].blocks {
                    if !merged[b] {
                        new_blks << b
                    }
                }
                mut func := m.funcs[fi]
                func.blocks = new_blks
                m.funcs[fi] = func
            }
        }
        if changed {
            build_cfg(mut m)
        }
    }
}