import v3.ssa
import v3.ssa.optimize

// Build a function body inside a worker module and merge it back, exercising the
// raw-block-id operand remapping (branch/phi block operands must shift by the
// block offset, value operands by the value offset).
fn test_worker_clone_merge_remaps_block_and_value_operands() {
	mut m := ssa.Module.new()
	i64t := m.type_store.get_int(64)
	// A pre-existing (seed) constant and function registered serially.
	_ := m.get_or_add_const(i64t, '111')
	fidx := m.new_function('compute', i64t)

	// Clone a worker and snapshot the seed sizes.
	mut w := m.new_worker_module()
	seed_values := m.values.len
	seed_instrs := m.instrs.len
	seed_blocks := m.blocks.len
	seed_types := m.type_store.types.len
	seed_funcs := m.funcs.len

	// Build a diamond + merge phi entirely inside the worker.
	entry := w.add_block(fidx, 'entry')
	then_b := w.add_block(fidx, 'then')
	else_b := w.add_block(fidx, 'else')
	merge := w.add_block(fidx, 'merge')

	cond := w.get_or_add_const(w.type_store.get_int(1), '1')
	w.add_instr(.br, entry, ssa.TypeID(0), [cond, ssa.ValueID(then_b), ssa.ValueID(else_b)])

	ten := w.get_or_add_const(i64t, '10')
	w.add_instr(.jmp, then_b, ssa.TypeID(0), [ssa.ValueID(merge)])
	twenty := w.get_or_add_const(i64t, '20')
	w.add_instr(.jmp, else_b, ssa.TypeID(0), [ssa.ValueID(merge)])

	// phi: [ten, then_b, twenty, else_b]  (odd operands are raw block ids)
	phi := w.add_instr(.phi, merge, i64t, [ten, ssa.ValueID(then_b), twenty, ssa.ValueID(else_b)])
	w.add_instr(.ret, merge, ssa.TypeID(0), [phi])

	fd := ssa.FuncSSAData{
		func_idx: fidx
		blocks:   w.funcs[fidx].blocks
		params:   w.funcs[fidx].params
	}

	m.merge_worker_module(w, [fd], seed_values, seed_instrs, seed_blocks, seed_types, seed_funcs)

	// The function now has its 4 blocks, all parented correctly.
	assert m.funcs[fidx].blocks.len == 4
	for blk_id in m.funcs[fidx].blocks {
		assert blk_id >= 0 && blk_id < m.blocks.len
		assert m.blocks[blk_id].parent == fidx
	}

	// The merged branch must target real blocks inside the function (this fails if
	// block operands were remapped as values).
	entry_id := m.funcs[fidx].blocks[0]
	term_id := m.blocks[entry_id].instrs.last()
	term := m.instrs[m.values[term_id].index]
	assert term.op == .br
	for oi in [1, 2] {
		tgt := int(term.operands[oi])
		assert tgt >= 0 && tgt < m.blocks.len
		assert tgt in m.funcs[fidx].blocks
	}

	// The whole thing must verify and optimize cleanly (optimize() panics on a
	// broken CFG / dangling phi predecessor, so reaching the asserts proves the
	// remapping is consistent).
	optimize.optimize_with_options(mut m, optimize.OptimizeOptions{
		mem2reg:        false
		eliminate_phis: true
	})
	errors := optimize.verify(m)
	for e in errors {
		assert !e.msg.contains('invalid')
		assert !e.msg.contains('outside function')
	}
}