// 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 os
import v2.ssa

fn gate4_has_error(errors []VerifyError, op string, needle string) bool {
	for err in errors {
		if err.msg.contains(op) && err.msg.contains(needle) {
			return true
		}
	}
	return false
}

fn gate4_corrupt_uses_list_module() &ssa.Module {
	mut m := ssa.Module.new('gate4_corrupt_uses_list')
	i64_t := m.type_store.get_int(64)
	func_id := m.new_function('main', i64_t, [])
	entry := m.add_block(func_id, 'entry')
	lhs := m.get_or_add_const(i64_t, '1')
	rhs := m.get_or_add_const(i64_t, '2')
	sum := m.add_instr(.add, entry, i64_t, [lhs, rhs])
	m.add_instr(.ret, entry, 0, [sum])
	mut lhs_val := m.values[lhs]
	lhs_val.uses.clear()
	m.values[lhs] = lhs_val
	return m
}

fn test_verify_rejects_call_sret_without_target() {
	mut m := ssa.Module.new('gate4_verify_call_sret')
	i64_t := m.type_store.get_int(64)
	func_id := m.new_function('caller', i64_t, [])
	entry := m.add_block(func_id, 'entry')
	m.add_instr(.call_sret, entry, i64_t, [])
	zero := m.get_or_add_const(i64_t, '0')
	m.add_instr(.ret, entry, 0, [zero])

	errors := verify(m)
	assert gate4_has_error(errors, 'call_sret', 'no operands'), 'expected call_sret without target to fail verification'
}

fn test_verify_rejects_concurrency_calls_without_target() {
	for op in [ssa.OpCode.go_call, .spawn_call] {
		mut m := ssa.Module.new('gate4_verify_concurrency_call')
		func_id := m.new_function('caller', 0, [])
		entry := m.add_block(func_id, 'entry')
		m.add_instr(op, entry, 0, [])
		m.add_instr(.ret, entry, 0, [])

		errors := verify(m)
		assert gate4_has_error(errors, op.str(), 'no operands'), 'expected ${op} without target to fail verification'
	}
}

fn test_dce_preserves_global_initializer_store() {
	mut m := ssa.Module.new('gate4_dce_global_store')
	i64_t := m.type_store.get_int(64)
	global_id := m.add_global('module__state', i64_t, false)
	value := m.get_or_add_const(i64_t, '7')
	func_id := m.new_function('_vinit', 0, [])
	entry := m.add_block(func_id, 'entry')
	store_id := m.add_instr(.store, entry, 0, [value, global_id])
	m.add_instr(.ret, entry, 0, [])

	changed := dead_code_elimination(mut m)

	assert !changed
	assert store_id in m.blocks[entry].instrs
	assert m.values[global_id].uses.len == 1
	assert m.values[global_id].uses[0] == store_id
}

fn test_dce_preserves_imported_const_initializer_store() {
	mut m := ssa.Module.new('gate4_dce_imported_const_init')
	i64_t := m.type_store.get_int(64)
	global_id := m.add_global('dep__runtime_value', i64_t, false)
	value := m.get_or_add_const(i64_t, '11')
	func_id := m.new_function('dep____v_init_consts_dep', 0, [])
	entry := m.add_block(func_id, 'entry')
	store_id := m.add_instr(.store, entry, 0, [value, global_id])
	m.add_instr(.ret, entry, 0, [])

	changed := dead_code_elimination(mut m)

	assert !changed
	assert store_id in m.blocks[entry].instrs
	assert m.values[global_id].uses.len == 1
	assert m.values[global_id].uses[0] == store_id
}

fn test_optimize_can_verify_each_pipeline_checkpoint() {
	mut m := ssa.Module.new('gate4_verify_each_pipeline_checkpoint')
	i64_t := m.type_store.get_int(64)
	func_id := m.new_function('main', i64_t, [])
	entry := m.add_block(func_id, 'entry')
	zero := m.get_or_add_const(i64_t, '0')
	ret_id := m.add_instr(.ret, entry, 0, [zero])

	optimize_with_options(mut m, OptimizeOptions{
		verify_each_pass: true
	})

	assert ret_id in m.blocks[entry].instrs
	assert verify(m).len == 0
}

fn test_optimize_can_verify_strict_each_pipeline_checkpoint() {
	mut m := ssa.Module.new('gate4_strict_verify_each_pipeline_checkpoint')
	i64_t := m.type_store.get_int(64)
	func_id := m.new_function('main', i64_t, [])
	entry := m.add_block(func_id, 'entry')
	zero := m.get_or_add_const(i64_t, '0')
	ret_id := m.add_instr(.ret, entry, 0, [zero])

	optimize_with_options(mut m, OptimizeOptions{
		strict_verify: true
	})

	assert ret_id in m.blocks[entry].instrs
	assert verify(m).len == 0
}

fn test_optimize_runs_dead_code_elimination_pass() {
	mut m := ssa.Module.new('gate4_optimize_runs_dce')
	i64_t := m.type_store.get_int(64)
	func_id := m.new_function('main', i64_t, [])
	entry := m.add_block(func_id, 'entry')
	lhs := m.get_or_add_const(i64_t, '20')
	rhs := m.get_or_add_const(i64_t, '22')
	dead_add := m.add_instr(.add, entry, i64_t, [lhs, rhs])
	zero := m.get_or_add_const(i64_t, '0')
	ret_id := m.add_instr(.ret, entry, 0, [zero])

	optimize_with_options(mut m, OptimizeOptions{
		verify_each_pass: true
	})

	assert dead_add !in m.blocks[entry].instrs
	assert ret_id in m.blocks[entry].instrs
}

fn test_public_optimize_uses_v2_verify_pipeline_checkpoints() {
	old_verify := os.getenv_opt('V2_VERIFY')
	os.setenv('V2_VERIFY', '1', true)
	defer {
		if old := old_verify {
			os.setenv('V2_VERIFY', old, true)
		} else {
			os.unsetenv('V2_VERIFY')
		}
	}

	mut m := ssa.Module.new('gate4_public_optimize_v2_verify')
	i64_t := m.type_store.get_int(64)
	func_id := m.new_function('main', i64_t, [])
	entry := m.add_block(func_id, 'entry')
	lhs := m.get_or_add_const(i64_t, '100')
	rhs := m.get_or_add_const(i64_t, '23')
	dead_add := m.add_instr(.add, entry, i64_t, [lhs, rhs])
	zero := m.get_or_add_const(i64_t, '0')
	ret_id := m.add_instr(.ret, entry, 0, [zero])

	optimize_with_options(mut m, OptimizeOptions{})

	assert dead_add !in m.blocks[entry].instrs
	assert ret_id in m.blocks[entry].instrs
	assert verify(m).len == 0
}

fn test_public_optimize_uses_v2_verify_strict_pipeline_checkpoints() {
	old_verify := os.getenv_opt('V2_VERIFY')
	old_strict := os.getenv_opt('V2_VERIFY_STRICT')
	os.unsetenv('V2_VERIFY')
	os.setenv('V2_VERIFY_STRICT', '1', true)
	defer {
		if old := old_verify {
			os.setenv('V2_VERIFY', old, true)
		} else {
			os.unsetenv('V2_VERIFY')
		}
		if old := old_strict {
			os.setenv('V2_VERIFY_STRICT', old, true)
		} else {
			os.unsetenv('V2_VERIFY_STRICT')
		}
	}

	mut m := ssa.Module.new('gate4_public_optimize_v2_verify_strict')
	i64_t := m.type_store.get_int(64)
	func_id := m.new_function('main', i64_t, [])
	entry := m.add_block(func_id, 'entry')
	zero := m.get_or_add_const(i64_t, '0')
	ret_id := m.add_instr(.ret, entry, 0, [zero])

	optimize(mut m)

	assert ret_id in m.blocks[entry].instrs
	assert verify(m).len == 0
}

fn test_optimize_rebuilds_uses_before_mem2reg_promotability() {
	mut m := ssa.Module.new('gate4_mem2reg_rebuilds_escaped_alloca_uses')
	i8_t := m.type_store.get_int(8)
	ptr_i8_t := m.type_store.get_ptr(i8_t)
	func_id := m.new_function('main', 0, [])
	entry := m.add_block(func_id, 'entry')
	alloca_id := m.add_instr(.alloca, entry, ptr_i8_t, [])
	ten := m.get_or_add_const(i8_t, '10')
	m.add_instr(.store, entry, 0, [ten, alloca_id])
	callee := m.add_value_node(.unknown, 0, 'sink', 0)
	m.add_instr(.call, entry, 0, [callee, alloca_id])
	m.add_instr(.ret, entry, 0, [])

	mut alloca_val := m.values[alloca_id]
	alloca_val.uses = []
	m.values[alloca_id] = alloca_val

	optimize_with_options(mut m, OptimizeOptions{})

	alloca_instr := m.instrs[m.values[alloca_id].index]
	assert alloca_instr.op == .alloca
}

fn test_verify_and_panic_allows_c_extern_prototype_without_blocks() {
	mut m := ssa.Module.new('gate4_c_extern_prototype')
	func_id := m.new_function('C_puts', 0, [])
	m.func_set_c_extern(func_id, true)

	verify_and_panic(m, 'c extern prototype')
}

fn test_verify_and_panic_allows_marked_prototype_without_blocks() {
	mut m := ssa.Module.new('gate4_marked_prototype')
	func_id := m.new_function('registered_only', 0, [])
	m.func_set_prototype(func_id, true)

	verify_and_panic(m, 'marked prototype')
}

fn test_strict_verify_and_panic_allows_valid_declarations_without_blocks() {
	mut m := ssa.Module.new('gate4_strict_valid_declarations')
	c_func_id := m.new_function('C_puts', 0, [])
	m.func_set_c_extern(c_func_id, true)
	prototype_func_id := m.new_function('registered_only', 0, [])
	m.func_set_prototype(prototype_func_id, true)

	verify_and_panic_with_options(m, 'strict valid declarations', VerifyPanicOptions{
		allow_noncritical: false
	})
}

fn test_verify_and_panic_allows_uses_list_warning_by_default() {
	mut m := gate4_corrupt_uses_list_module()

	errors := verify(m)
	assert gate4_has_error(errors, 'uses list', 'not in uses list'), 'expected uses list warning'

	verify_and_panic(m, 'uses list default warning')
}

fn test_strict_verify_and_panic_rejects_uses_list_warning() {
	tmp_dir := os.join_path(os.temp_dir(), 'v2_gate4_strict_verify_panic_${os.getpid()}')
	os.rmdir_all(tmp_dir) or {}
	os.mkdir_all(tmp_dir) or { panic(err) }
	defer {
		os.rmdir_all(tmp_dir) or {}
	}
	sample_path := os.join_path(tmp_dir, 'strict_verify_panic_sample.v')
	os.write_file(sample_path, 'module main

import v2.ssa
import v2.ssa.optimize

fn main() {
	mut m := ssa.Module.new("gate4_strict_uses_list")
	i64_t := m.type_store.get_int(64)
	func_id := m.new_function("main", i64_t, [])
	entry := m.add_block(func_id, "entry")
	lhs := m.get_or_add_const(i64_t, "1")
	rhs := m.get_or_add_const(i64_t, "2")
	sum := m.add_instr(.add, entry, i64_t, [lhs, rhs])
	m.add_instr(.ret, entry, 0, [sum])
	mut lhs_val := m.values[lhs]
	lhs_val.uses.clear()
	m.values[lhs] = lhs_val
	optimize.verify_and_panic_with_options(m, "strict uses list", optimize.VerifyPanicOptions{
		allow_noncritical: false
	})
}
') or {
		panic(err)
	}

	res := os.execute('${os.quoted_path(@VEXE)} run ${os.quoted_path(sample_path)}')

	assert res.exit_code != 0
	assert res.output.contains('uses list'), res.output
}

fn test_strict_optimize_rejects_uses_list_warning() {
	tmp_dir := os.join_path(os.temp_dir(), 'v2_gate4_strict_optimize_panic_${os.getpid()}')
	os.rmdir_all(tmp_dir) or {}
	os.mkdir_all(tmp_dir) or { panic(err) }
	defer {
		os.rmdir_all(tmp_dir) or {}
	}
	sample_path := os.join_path(tmp_dir, 'strict_optimize_panic_sample.v')
	os.write_file(sample_path, 'module main

import v2.ssa
import v2.ssa.optimize

fn main() {
	mut m := ssa.Module.new("gate4_strict_optimize_uses_list")
	i64_t := m.type_store.get_int(64)
	func_id := m.new_function("main", i64_t, [])
	entry := m.add_block(func_id, "entry")
	lhs := m.get_or_add_const(i64_t, "1")
	rhs := m.get_or_add_const(i64_t, "2")
	sum := m.add_instr(.add, entry, i64_t, [lhs, rhs])
	m.add_instr(.ret, entry, 0, [sum])
	mut lhs_val := m.values[lhs]
	lhs_val.uses.clear()
	m.values[lhs] = lhs_val
	optimize.optimize_with_options(mut m, optimize.OptimizeOptions{
		strict_verify: true
	})
}
') or {
		panic(err)
	}

	res := os.execute('${os.quoted_path(@VEXE)} run ${os.quoted_path(sample_path)}')

	assert res.exit_code != 0
	assert res.output.contains('uses list'), res.output
	assert res.output.contains('input'), res.output
}

fn test_verify_and_panic_rejects_v_function_without_blocks() {
	tmp_dir := os.join_path(os.temp_dir(), 'v2_gate4_verify_panic_${os.getpid()}')
	os.rmdir_all(tmp_dir) or {}
	os.mkdir_all(tmp_dir) or { panic(err) }
	defer {
		os.rmdir_all(tmp_dir) or {}
	}
	sample_path := os.join_path(tmp_dir, 'verify_panic_sample.v')
	os.write_file(sample_path, 'module main

import v2.ssa
import v2.ssa.optimize

fn main() {
	mut m := ssa.Module.new("gate4_v_prototype")
	m.new_function("v_decl_without_body", 0, [])
	optimize.verify_and_panic(m, "v prototype negative")
}
') or {
		panic(err)
	}

	res := os.execute('${os.quoted_path(@VEXE)} run ${os.quoted_path(sample_path)}')

	assert res.exit_code != 0
	assert res.output.contains('function has no blocks'), res.output
}

fn test_dce_preserves_call_sret_side_effect() {
	mut m := ssa.Module.new('gate4_dce_call_sret')
	i8_t := m.type_store.get_int(8)
	i64_t := m.type_store.get_int(64)
	ptr_t := m.type_store.get_ptr(i8_t)
	result_t := m.type_store.register(ssa.Type{
		kind:   .struct_t
		fields: [i64_t, i64_t]
	})
	callee := m.add_value_node(.func_ref, ptr_t, 'make_pair', 0)
	arg := m.get_or_add_const(i64_t, '3')
	func_id := m.new_function('caller', 0, [])
	entry := m.add_block(func_id, 'entry')
	call_id := m.add_instr(.call_sret, entry, result_t, [callee, arg])
	m.add_instr(.ret, entry, 0, [])

	changed := dead_code_elimination(mut m)

	assert !changed
	assert call_id in m.blocks[entry].instrs
	assert m.values[callee].uses.len == 1
	assert m.values[callee].uses[0] == call_id
}

fn test_dce_preserves_concurrency_call_side_effects() {
	mut m := ssa.Module.new('gate4_dce_concurrency_calls')
	i8_t := m.type_store.get_int(8)
	ptr_t := m.type_store.get_ptr(i8_t)
	go_callee := m.add_value_node(.func_ref, ptr_t, 'launch_go', 0)
	spawn_callee := m.add_value_node(.func_ref, ptr_t, 'launch_spawn', 0)
	func_id := m.new_function('caller', 0, [])
	entry := m.add_block(func_id, 'entry')
	go_id := m.add_instr(.go_call, entry, 0, [go_callee])
	spawn_id := m.add_instr(.spawn_call, entry, 0, [spawn_callee])
	m.add_instr(.ret, entry, 0, [])

	changed := dead_code_elimination(mut m)

	assert !changed
	assert go_id in m.blocks[entry].instrs
	assert spawn_id in m.blocks[entry].instrs
	assert m.values[go_callee].uses[0] == go_id
	assert m.values[spawn_callee].uses[0] == spawn_id
}

fn test_dce_preserves_cmpxchg_side_effect() {
	mut m := ssa.Module.new('gate4_dce_cmpxchg')
	i64_t := m.type_store.get_int(64)
	global_id := m.add_global('module__atomic_state', i64_t, false)
	expected := m.get_or_add_const(i64_t, '0')
	desired := m.get_or_add_const(i64_t, '1')
	func_id := m.new_function('update', 0, [])
	entry := m.add_block(func_id, 'entry')
	cmpxchg_id := m.add_instr(.cmpxchg, entry, i64_t, [global_id, expected, desired])
	m.add_instr(.ret, entry, 0, [])

	changed := dead_code_elimination(mut m)

	assert !changed
	assert cmpxchg_id in m.blocks[entry].instrs
	assert m.values[global_id].uses[0] == cmpxchg_id
}