import v3.ssa
import v3.ssa.optimize

// --- helpers ---------------------------------------------------------------

// count_op supports count op handling for v3 tests.
fn count_op(m &ssa.Module, func_id int, op ssa.OpCode) int {
    mut n := 0
    for blk_id in m.funcs[func_id].blocks {
        for val_id in m.blocks[blk_id].instrs {
            val := m.values[val_id]
            if val.kind == .instruction && m.instrs[val.index].op == op {
                n++
            }
        }
    }
    return n
}

// --- TypeStore: arrays, tuples, unsigned ----------------------------------

// test_type_store_arrays_tuples_unsigned validates this v3 regression case.
fn test_type_store_arrays_tuples_unsigned() {
    mut ts := ssa.TypeStore.new()
    s32 := ts.get_int(32)
    un32 := ts.get_uint(32)
    // Signed and unsigned of the same width must be distinct types.
    assert s32 != un32
    assert !ts.types[s32].is_unsigned
    assert ts.types[un32].is_unsigned

    arr := ts.get_array(s32, 4)
    arr2 := ts.get_array(s32, 4)
    assert arr == arr2 // cached
    assert ts.types[arr].kind == .array_t
    assert ts.types[arr].len == 4
    assert ts.types[arr].elem_type == s32

    tup := ts.get_tuple([s32, un32])
    assert ts.types[tup].kind == .struct_t
    assert ts.types[tup].fields == [s32, un32]
}

// test_array_type_sizing validates array type sizing behavior in v3 tests.
fn test_array_type_sizing() {
    mut m := ssa.Module.new()
    s32 := m.type_store.get_int(32)
    arr := m.type_store.get_array(s32, 5)
    // Fixed array of 5 x i32 = 20 bytes, aligned to element alignment (4).
    assert m.type_size(arr) == 20
    assert m.type_align(arr) == 4
}

// --- algebraic simplification ---------------------------------------------

// test_algebraic_add_zero validates algebraic add zero behavior in v3 tests.
fn test_algebraic_add_zero() {
    mut m := ssa.Module.new()
    i64t := m.type_store.get_int(64)
    func_id := m.new_function('add_zero', i64t)
    x := m.add_value(.argument, i64t, 'x', 0)
    m.func_add_param(func_id, x)
    entry := m.add_block(func_id, 'entry')
    zero := m.get_or_add_const(i64t, '0')
    r := m.add_instr(.add, entry, i64t, [x, zero])
    m.add_instr(.ret, entry, ssa.TypeID(0), [r])

    optimize.optimize(mut m)

    // x + 0 -> x, so the add is gone and ret returns the argument directly.
    assert count_op(m, func_id, .add) == 0
    ret_id := m.blocks[m.funcs[func_id].blocks[0]].instrs.last()
    ret := m.instrs[m.values[ret_id].index]
    assert m.values[ret.operands[0]].kind == .argument
}

// test_algebraic_mul_two_to_shift validates algebraic mul two to shift behavior in v3 tests.
fn test_algebraic_mul_two_to_shift() {
    mut m := ssa.Module.new()
    i64t := m.type_store.get_int(64)
    func_id := m.new_function('mul2', i64t)
    x := m.add_value(.argument, i64t, 'x', 0)
    m.func_add_param(func_id, x)
    entry := m.add_block(func_id, 'entry')
    two := m.get_or_add_const(i64t, '2')
    r := m.add_instr(.mul, entry, i64t, [x, two])
    m.add_instr(.ret, entry, ssa.TypeID(0), [r])

    optimize.optimize(mut m)

    // x * 2 -> x << 1
    assert count_op(m, func_id, .mul) == 0
    assert count_op(m, func_id, .shl) == 1
}

// test_algebraic_sub_self_is_zero validates algebraic sub self is zero behavior in v3 tests.
fn test_algebraic_sub_self_is_zero() {
    mut m := ssa.Module.new()
    i64t := m.type_store.get_int(64)
    func_id := m.new_function('sub_self', i64t)
    x := m.add_value(.argument, i64t, 'x', 0)
    m.func_add_param(func_id, x)
    entry := m.add_block(func_id, 'entry')
    r := m.add_instr(.sub, entry, i64t, [x, x])
    m.add_instr(.ret, entry, ssa.TypeID(0), [r])

    optimize.optimize(mut m)

    assert count_op(m, func_id, .sub) == 0
    ret_id := m.blocks[m.funcs[func_id].blocks[0]].instrs.last()
    ret := m.instrs[m.values[ret_id].index]
    ret_operand := m.values[ret.operands[0]]
    assert ret_operand.kind == .constant
    assert ret_operand.name == '0'
}

// --- DCE side-effect preservation -----------------------------------------

// test_dce_preserves_side_effecting_ops validates this v3 regression case.
fn test_dce_preserves_side_effecting_ops() {
    mut m := ssa.Module.new()
    i64t := m.type_store.get_int(64)
    func_id := m.new_function('side_fx', i64t)
    entry := m.add_block(func_id, 'entry')
    // A pure dead add that should be removed.
    a := m.get_or_add_const(i64t, '7')
    b := m.get_or_add_const(i64t, '9')
    m.add_instr(.add, entry, i64t, [a, b])
    // Side-effecting ops with no uses that must be preserved.
    m.add_instr(.fence, entry, ssa.TypeID(0), [])
    m.add_instr(.cmpxchg, entry, i64t, [a])
    m.add_instr(.ret, entry, ssa.TypeID(0), [])

    optimize.optimize(mut m)

    assert count_op(m, func_id, .add) == 0 // dead pure op removed
    assert count_op(m, func_id, .fence) == 1 // preserved
    assert count_op(m, func_id, .cmpxchg) == 1 // preserved
}

// --- structured verifier ---------------------------------------------------

// test_structured_verifier_accepts_valid_module validates this v3 regression case.
fn test_structured_verifier_accepts_valid_module() {
    mut m := ssa.Module.new()
    i64t := m.type_store.get_int(64)
    func_id := m.new_function('valid', i64t)
    entry := m.add_block(func_id, 'entry')
    c := m.get_or_add_const(i64t, '1')
    m.add_instr(.ret, entry, ssa.TypeID(0), [c])

    optimize.optimize(mut m)
    errors := optimize.verify(m)
    // No structural errors on a well-formed module.
    for e in errors {
        assert !e.msg.contains('invalid')
        assert !e.msg.contains('not in its')
    }
}

// test_structured_verifier_accepts_prototype_declaration validates this v3 regression case.
fn test_structured_verifier_accepts_prototype_declaration() {
    mut m := ssa.Module.new()
    i64t := m.type_store.get_int(64)
    // A prototype/extern function with no body must be accepted (not fatal).
    proto := m.new_function('extern_decl', i64t)
    m.func_set_prototype(proto, true)
    m.func_set_c_extern(proto, true)
    // Should not panic.
    optimize.verify_and_panic(m, 'prototype test')
    assert true
}

// --- mem2reg + phi elimination (IR level) ---------------------------------

// test_mem2reg_promotes_diamond_slot validates this v3 regression case.
fn test_mem2reg_promotes_diamond_slot() {
    mut m := ssa.Module.new()
    i64t := m.type_store.get_int(64)
    i1 := m.type_store.get_int(1)
    ptr_i64 := m.type_store.get_ptr(i64t)
    func_id := m.new_function('diamond', i64t)
    cond := m.add_value(.argument, i1, 'cond', 0)
    m.func_add_param(func_id, cond)

    entry := m.add_block(func_id, 'entry')
    then_blk := m.add_block(func_id, 'then')
    else_blk := m.add_block(func_id, 'else')
    merge := m.add_block(func_id, 'merge')

    slot := m.add_instr(.alloca, entry, ptr_i64, [])
    m.add_instr(.br, entry, ssa.TypeID(0), [cond, ssa.ValueID(then_blk), ssa.ValueID(else_blk)])

    ten := m.get_or_add_const(i64t, '10')
    m.add_instr(.store, then_blk, ssa.TypeID(0), [ten, slot])
    m.add_instr(.jmp, then_blk, ssa.TypeID(0), [ssa.ValueID(merge)])

    twenty := m.get_or_add_const(i64t, '20')
    m.add_instr(.store, else_blk, ssa.TypeID(0), [twenty, slot])
    m.add_instr(.jmp, else_blk, ssa.TypeID(0), [ssa.ValueID(merge)])

    loaded := m.add_instr(.load, merge, i64t, [slot])
    m.add_instr(.ret, merge, ssa.TypeID(0), [loaded])

    optimize.optimize_with_options(mut m, optimize.OptimizeOptions{
        mem2reg:        true
        eliminate_phis: true
    })

    // The scalar slot is fully promoted: no alloca/load/store remain.
    assert count_op(m, func_id, .alloca) == 0
    assert count_op(m, func_id, .load) == 0
    assert count_op(m, func_id, .store) == 0
    // Phi was lowered to assign copies in the predecessor blocks.
    assert count_op(m, func_id, .assign) >= 1
    // And no phi survives after elimination.
    assert count_op(m, func_id, .phi) == 0
}