// 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.
// vtest build: macos

module optimize

import v2.ssa

fn test_verify_empty_function() {
    mut m := ssa.Module.new('test')
    func_id := m.new_function('test_fn', 0, [])

    // Function with no blocks should fail
    errors := verify(m)
    assert errors.len > 0
    assert errors[0].msg.contains('no blocks')
}

fn test_verify_missing_terminator() {
    mut m := ssa.Module.new('test')
    func_id := m.new_function('test_fn', 0, [])
    blk_id := m.add_block(func_id, 'entry')

    // Block with no instructions should fail (missing terminator)
    errors := verify(m)
    assert errors.len > 0
    assert errors[0].msg.contains('no instructions') || errors[0].msg.contains('terminator')
}

fn test_verify_valid_function() {
    mut m := ssa.Module.new('test')
    i64_t := m.type_store.get_int(64)
    func_id := m.new_function('test_fn', i64_t, [])
    blk_id := m.add_block(func_id, 'entry')

    // Create a constant
    const_id := m.add_value_node(.constant, i64_t, 'const_42', 0)

    // Add ret instruction with constant operand
    m.add_instr(.ret, blk_id, 0, [const_id])

    errors := verify(m)
    assert errors.len == 0, 'expected no errors, got: ${errors}'
}

fn test_verify_binary_op_operand_count() {
    mut m := ssa.Module.new('test')
    i64_t := m.type_store.get_int(64)
    func_id := m.new_function('test_fn', i64_t, [])
    blk_id := m.add_block(func_id, 'entry')

    // Create constants
    const1 := m.add_value_node(.constant, i64_t, 'const_1', 0)
    const2 := m.add_value_node(.constant, i64_t, 'const_2', 0)
    const3 := m.add_value_node(.constant, i64_t, 'const_3', 0)

    // Add binary op with wrong number of operands (3 instead of 2)
    m.add_instr(.add, blk_id, i64_t, [const1, const2, const3])
    m.add_instr(.ret, blk_id, 0, [])

    errors := verify(m)
    mut found_binary_error := false
    for err in errors {
        if err.msg.contains('binary op') && err.msg.contains('operands') {
            found_binary_error = true
            break
        }
    }
    assert found_binary_error, 'expected binary op operand count error'
}

fn test_verify_load_non_pointer() {
    mut m := ssa.Module.new('test')
    i64_t := m.type_store.get_int(64)
    func_id := m.new_function('test_fn', i64_t, [])
    blk_id := m.add_block(func_id, 'entry')

    // Create a non-pointer constant
    const_id := m.add_value_node(.constant, i64_t, 'const_42', 0)

    // Try to load from non-pointer (should error)
    m.add_instr(.load, blk_id, i64_t, [const_id])
    m.add_instr(.ret, blk_id, 0, [])

    errors := verify(m)
    mut found_load_error := false
    for err in errors {
        if err.msg.contains('load') && err.msg.contains('pointer') {
            found_load_error = true
            break
        }
    }
    assert found_load_error, 'expected load non-pointer error'
}

fn test_verify_phi_odd_operands() {
    mut m := ssa.Module.new('test')
    i64_t := m.type_store.get_int(64)
    func_id := m.new_function('test_fn', i64_t, [])
    blk_id := m.add_block(func_id, 'entry')

    // Create constant
    const_id := m.add_value_node(.constant, i64_t, 'const_1', 0)

    // Add phi with odd number of operands (should be pairs)
    m.add_instr(.phi, blk_id, i64_t, [const_id]) // 1 operand instead of pairs
    m.add_instr(.ret, blk_id, 0, [])

    errors := verify(m)
    mut found_phi_error := false
    for err in errors {
        if err.msg.contains('phi') && err.msg.contains('odd') {
            found_phi_error = true
            break
        }
    }
    assert found_phi_error, 'expected phi odd operands error'
}

fn test_verify_branch_operand_count() {
    mut m := ssa.Module.new('test')
    i64_t := m.type_store.get_int(64)
    func_id := m.new_function('test_fn', i64_t, [])
    blk_id := m.add_block(func_id, 'entry')

    // Create constant for condition
    const_id := m.add_value_node(.constant, i64_t, 'cond', 0)

    // Add br with wrong number of operands (1 instead of 3)
    m.add_instr(.br, blk_id, 0, [const_id])

    errors := verify(m)
    mut found_br_error := false
    for err in errors {
        if err.msg.contains('br') && err.msg.contains('operands') {
            found_br_error = true
            break
        }
    }
    assert found_br_error, 'expected br operand count error'
}

fn test_verify_jump_target_not_block() {
    mut m := ssa.Module.new('test')
    i64_t := m.type_store.get_int(64)
    func_id := m.new_function('test_fn', i64_t, [])
    blk_id := m.add_block(func_id, 'entry')

    // Create constant (not a block)
    const_id := m.add_value_node(.constant, i64_t, 'not_a_block', 0)

    // Add jmp targeting non-block
    m.add_instr(.jmp, blk_id, 0, [const_id])

    errors := verify(m)
    mut found_jmp_error := false
    for err in errors {
        if err.msg.contains('jmp') && err.msg.contains('basic_block') {
            found_jmp_error = true
            break
        }
    }
    assert found_jmp_error, 'expected jmp target not block error'
}

fn test_verify_terminator_not_last() {
    mut m := ssa.Module.new('test')
    i64_t := m.type_store.get_int(64)
    func_id := m.new_function('test_fn', i64_t, [])
    blk_id := m.add_block(func_id, 'entry')

    // Create block for jump target
    target_blk := m.add_block(func_id, 'target')
    target_val := m.blocks[target_blk].val_id

    // Add terminator in middle, then another instruction
    m.add_instr(.ret, blk_id, 0, [])

    // Manually add another instruction after terminator
    const_id := m.add_value_node(.constant, i64_t, 'const', 0)
    m.add_instr(.add, blk_id, i64_t, [const_id, const_id])

    // Add terminator to target block
    m.add_instr(.ret, target_blk, 0, [])

    errors := verify(m)
    mut found_term_error := false
    for err in errors {
        if err.msg.contains('terminator') && err.msg.contains('end') {
            found_term_error = true
            break
        }
    }
    assert found_term_error, 'expected terminator not at end error'
}

fn test_verify_use_def_chain() {
    mut m := ssa.Module.new('test')
    i64_t := m.type_store.get_int(64)
    func_id := m.new_function('test_fn', i64_t, [])
    blk_id := m.add_block(func_id, 'entry')

    // Create constants and use them
    const1 := m.add_value_node(.constant, i64_t, 'const_1', 0)
    const2 := m.add_value_node(.constant, i64_t, 'const_2', 0)

    // Add instruction using both constants
    result := m.add_instr(.add, blk_id, i64_t, [const1, const2])
    m.add_instr(.ret, blk_id, i64_t, [result])

    // Verify use-def chains are correct
    errors := verify(m)
    assert errors.len == 0, 'expected no errors for valid use-def chain, got: ${errors}'

    // Check that uses were registered
    assert result in m.values[const1].uses, 'const1 should have result in uses'
    assert result in m.values[const2].uses, 'const2 should have result in uses'
}