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

struct TestParallelCopy {
    dest int
    src  int
}

fn resolve_test_parallel_copies(mut m ssa.Module, blk_id int, copies []TestParallelCopy) {
    mut dests := []int{cap: copies.len}
    mut srcs := []int{cap: copies.len}
    for copy in copies {
        dests << copy.dest
        srcs << copy.src
    }
    mut src_ref_count := []int{len: m.values.len + copies.len + 8}
    mut touched_ids := []int{cap: copies.len + 4}
    resolve_parallel_copies_flat(mut m, blk_id, dests, srcs, mut src_ref_count, mut touched_ids)
}

fn collect_parallel_assigns(m &ssa.Module, blk_id int) []TestParallelCopy {
    mut assigns := []TestParallelCopy{}
    for val_id in m.blocks[blk_id].instrs {
        if m.values[val_id].kind != .instruction {
            continue
        }
        instr := m.instrs[m.values[val_id].index]
        if instr.op != .assign {
            continue
        }
        assert instr.operands.len == 2
        assert instr.operands[0] != 0
        assert instr.operands[1] != 0
        assigns << TestParallelCopy{
            dest: instr.operands[0]
            src:  instr.operands[1]
        }
    }
    return assigns
}

fn test_parallel_copy_cycle_materializes_temp_in_block() {
    mut m := ssa.Module.new('test_cycle')
    i64_t := m.type_store.get_int(64)
    fn_id := m.new_function('f', 0, [])
    blk_id := m.add_block(fn_id, 'entry')

    c1 := m.get_or_add_const(i64_t, '1')
    c2 := m.get_or_add_const(i64_t, '2')
    a := m.add_instr(.add, blk_id, i64_t, [c1, c2])
    b := m.add_instr(.sub, blk_id, i64_t, [a, c1])
    m.add_instr(.ret, blk_id, 0, [])

    resolve_test_parallel_copies(mut m, blk_id, [
        TestParallelCopy{
            dest: a
            src:  b
        },
        TestParallelCopy{
            dest: b
            src:  a
        },
    ])

    mut temp_ids := []int{}
    for val_id in m.blocks[blk_id].instrs {
        if m.values[val_id].name.starts_with('phi_tmp_') {
            temp_ids << val_id
        }
    }
    assigns := collect_parallel_assigns(m, blk_id)

    assert temp_ids.len > 0
    assert assigns.len == 2

    temp_id := temp_ids[0]
    mut has_temp_src := false
    for copy in assigns {
        if copy.src == temp_id {
            has_temp_src = true
        }
    }
    assert has_temp_src
}

fn test_parallel_copy_acyclic_chain_does_not_create_temp() {
    mut m := ssa.Module.new('test_chain')
    i64_t := m.type_store.get_int(64)
    fn_id := m.new_function('f', 0, [])
    blk_id := m.add_block(fn_id, 'entry')

    c1 := m.get_or_add_const(i64_t, '1')
    c2 := m.get_or_add_const(i64_t, '2')
    b := m.add_instr(.add, blk_id, i64_t, [c1, c2])
    a := m.add_instr(.sub, blk_id, i64_t, [b, c1])
    c := m.add_instr(.mul, blk_id, i64_t, [a, c2])
    m.add_instr(.ret, blk_id, 0, [])

    resolve_test_parallel_copies(mut m, blk_id, [
        TestParallelCopy{
            dest: a
            src:  b
        },
        TestParallelCopy{
            dest: c
            src:  a
        },
    ])

    mut has_temp := false
    for val_id in m.blocks[blk_id].instrs {
        if m.values[val_id].name.starts_with('phi_tmp_') {
            has_temp = true
        }
    }
    assigns := collect_parallel_assigns(m, blk_id)

    assert !has_temp
    assert assigns.len == 2
    assert assigns[0].dest == c
    assert assigns[0].src == a
    assert assigns[1].dest == a
    assert assigns[1].src == b
}

fn test_eliminate_phi_nodes_cycle_assign_dests_are_materialized() {
    mut m := ssa.Module.new('test_phi_elim_cycle')
    i64_t := m.type_store.get_int(64)
    fn_id := m.new_function('f', 0, [])
    entry := m.add_block(fn_id, 'entry')
    join := m.add_block(fn_id, 'join')
    block_val_ids := build_block_val_ids(m)

    join_val := get_block_val_id(m, join, block_val_ids)
    m.add_instr(.jmp, entry, 0, [join_val])

    entry_val := get_block_val_id(m, entry, block_val_ids)
    zero := m.get_or_add_const(i64_t, '0')
    one := m.get_or_add_const(i64_t, '1')

    phi_a := m.add_instr(.phi, join, i64_t, [zero, entry_val])
    phi_b := m.add_instr(.phi, join, i64_t, [phi_a, entry_val])
    // Make it a true cycle: a <- b, b <- a.
    m.instrs[m.values[phi_a].index].operands[0] = phi_b
    m.add_instr(.ret, join, 0, [one])

    eliminate_phi_nodes(mut m)

    mut materialized := map[int]bool{}
    for blk_id in m.funcs[fn_id].blocks {
        for val_id in m.blocks[blk_id].instrs {
            materialized[val_id] = true
        }
    }

    mut saw_assign := false
    mut saw_temp := false
    for blk_id in m.funcs[fn_id].blocks {
        for val_id in m.blocks[blk_id].instrs {
            if m.values[val_id].name.starts_with('phi_tmp_') {
                saw_temp = true
            }
            if m.values[val_id].kind != .instruction {
                continue
            }
            instr := m.instrs[m.values[val_id].index]
            if instr.op == .assign {
                saw_assign = true
                dest := instr.operands[0]
                assert dest in materialized
            }
        }
    }

    assert saw_assign
    assert saw_temp
}