// Test for issue #26777: assert with || and && should properly short-circuit
module main

struct Node {
    name string
mut:
    parent   &Node = unsafe { nil }
    children []Node
}

fn test_assert_or_short_circuit_with_nil_parent() {
    mut p := Node{
        name: 'abc'
    }
    // This should work - the right side of || should not be evaluated
    // when the left side is true (p.parent == nil)
    assert unsafe { p.parent == nil } || !p.parent.children.any(it.name == p.name)
    assert true
}

fn test_assert_and_short_circuit_with_nil_parent() {
    mut p := Node{
        name: 'abc'
    }
    // Test &&: when left is true, right should be evaluated (non-short-circuit path)
    // This tests that the right side IS evaluated when left is true
    assert true && p.name == 'abc'
    // Test && short-circuit: left is false, right should NOT be evaluated
    // With fix, right is short-circuited (no nil access)
    // Without fix, would crash with nil pointer access
    // We use a simple bool expr to avoid assert failure
    _ = false && unsafe { p.parent == nil }
}

fn test_assert_or_with_message() {
    mut p := Node{
        name: 'abc'
    }
    // This should work with a message too
    assert unsafe { p.parent == nil } || !p.parent.children.any(it.name == p.name), 'parent check failed'
    assert true
}

fn test_assert_or_both_sides_need_eval() {
    mut child := Node{
        name: 'child'
    }
    // child.parent is nil by default
    // Left side is false (child.parent == nil, so child.parent != nil is false)
    // Right side must be evaluated - use a simple true to test both sides are evaluated
    assert unsafe { child.parent != nil } || true, 'should evaluate both sides'
}

fn test_nested_or_in_assert() {
    mut p := Node{
        name: 'test'
    }
    // Nested unsafe block with ||
    assert unsafe { p.parent == nil } || unsafe { p.parent != nil }
    assert true
}

fn main() {
    test_assert_or_short_circuit_with_nil_parent()
    test_assert_and_short_circuit_with_nil_parent()
    test_assert_or_with_message()
    test_assert_or_both_sides_need_eval()
    test_nested_or_in_assert()
    println('All short-circuit tests passed!')
}