// 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 optimize

import v2.ssa

// --- CFG Construction ---
// Flat CFG data: succs and preds stored outside BasicBlock to avoid struct field access issues
// in v3 (ARM64-compiled binary). Accessing m.blocks[i].succs returns garbage for large structs.
struct CfgData {
mut:
	succs [][]int
	preds [][]int
}

// Helper: check if value is already in a small array (avoids map allocation)
fn arr_contains(arr []int, val int) bool {
	for i in 0 .. arr.len {
		if arr[i] == val {
			return true
		}
	}
	return false
}

pub fn build_cfg(mut m ssa.Module) CfgData {
	n_blocks := m.blocks.len
	n_values := m.values.len
	n_funcs := m.funcs.len
	n_instrs_total := m.instrs.len

	mut cfg := CfgData{
		succs: [][]int{len: n_blocks}
		preds: [][]int{len: n_blocks}
	}

	for fi in 0 .. n_funcs {
		func := m.funcs[fi]
		n_func_blocks := func.blocks.len

		for fbi2 in 0 .. n_func_blocks {
			blk_id := func.blocks[fbi2]
			blk := m.blocks[blk_id]
			n_instrs := blk.instrs.len
			if n_instrs == 0 {
				continue
			}
			term_val_id := blk.instrs[n_instrs - 1]
			if term_val_id < 0 || term_val_id >= n_values {
				continue
			}
			term_val := m.values[term_val_id]
			if term_val.index < 0 || term_val.index >= n_instrs_total {
				continue
			}
			term := m.instrs[term_val.index]

			n_operands := term.operands.len
			match term.op {
				.br {
					if n_operands >= 3 {
						op1 := term.operands[1]
						op2 := term.operands[2]
						mut s1 := -1
						if op1 >= 0 {
							if op1 < n_values {
								v1 := m.values[op1]
								s1 = v1.index
							}
						}
						mut s2 := -1
						if op2 >= 0 {
							if op2 < n_values {
								v2 := m.values[op2]
								s2 = v2.index
							}
						}
						if s1 >= 0 {
							if s1 < n_blocks {
								if !arr_contains(cfg.succs[blk_id], s1) {
									cfg.succs[blk_id] << s1
								}
							}
						}
						if s2 >= 0 {
							if s2 < n_blocks {
								if !arr_contains(cfg.succs[blk_id], s2) {
									cfg.succs[blk_id] << s2
								}
							}
						}
					}
				}
				.jmp {
					if n_operands >= 1 {
						op0 := term.operands[0]
						mut s := -1
						if op0 >= 0 {
							if op0 < n_values {
								v0 := m.values[op0]
								s = v0.index
							}
						}
						if s >= 0 {
							if s < n_blocks {
								cfg.succs[blk_id] << s
							}
						}
					}
				}
				.switch_ {
					if n_operands >= 2 {
						op_def := term.operands[1]
						mut s := -1
						if op_def >= 0 {
							if op_def < n_values {
								vd := m.values[op_def]
								s = vd.index
							}
						}
						if s >= 0 {
							if s < n_blocks {
								if !arr_contains(cfg.succs[blk_id], s) {
									cfg.succs[blk_id] << s
								}
							}
						}
						for i := 3; i < n_operands; i += 2 {
							op_case := term.operands[i]
							mut cs := -1
							if op_case >= 0 {
								if op_case < n_values {
									vc := m.values[op_case]
									cs = vc.index
								}
							}
							if cs >= 0 {
								if cs < n_blocks {
									if !arr_contains(cfg.succs[blk_id], cs) {
										cfg.succs[blk_id] << cs
									}
								}
							}
						}
					}
				}
				else {}
			}

			// Build predecessors from succs
			n_succs := cfg.succs[blk_id].len
			for si in 0 .. n_succs {
				s := cfg.succs[blk_id][si]
				if s < 0 || s >= n_blocks {
					continue
				}
				if !arr_contains(cfg.preds[s], blk_id) {
					cfg.preds[s] << blk_id
				}
			}
		}
	}

	// Also write back to m.blocks for compatibility with other passes
	for bi in 0 .. n_blocks {
		// Avoid m.blocks[X].succs/preds = ... -- chained field assign broken in ARM64 self-hosted
		mut blk := m.blocks[bi]
		blk.succs = cfg.succs[bi]
		blk.preds = cfg.preds[bi]
		m.blocks[bi] = blk
	}

	return cfg
}