//! returns: 0
//! Bubble sort.
//! Sort an array of integers and verify the result.

/// Bubble sort the array in ascending order.
fn bubbleSort(data: *mut [i32]) {
    let mut n: u32 = data.len;
    while n > 1 {
        let mut swapped: bool = false;
        let mut i: u32 = 0;
        while i < n - 1 {
            if data[i] > data[i + 1] {
                let tmp: i32 = data[i];
                data[i] = data[i + 1];
                data[i + 1] = tmp;
                swapped = true;
            }
            i += 1;
        }
        if not swapped {
            // Already sorted, early exit.
            return;
        }
        n -= 1;
    }
}

/// Verify the array is sorted in ascending order.
fn isSorted(data: *[i32]) -> bool {
    let mut prev: ?i32 = nil;
    for val in data {
        if let p = prev {
            if p > val {
                return false;
            }
        }
        prev = val;
    }
    return true;
}

/// Compute the sum of all elements.
fn sum(data: *[i32]) -> i32 {
    let mut total: i32 = 0;
    for val in data {
        total += val;
    }
    return total;
}

/// Verify specific positions in the sorted output.
fn verifyPositions(data: *[i32]) -> i32 {
    // Sorted: 3 5 7 12 17 19 28 31 42 50 55 66 71 80 88 93
    assert data[0] == 3;
    assert data[1] == 5;
    assert data[2] == 7;
    assert data[7] == 31;
    assert data[14] == 88;
    assert data[15] == 93;
    return 0;
}

@default fn main() -> i32 {
    let mut data: [i32; 16] = [
        42, 17, 93, 5, 28, 71, 3, 66,
        50, 12, 88, 31, 7, 55, 19, 80
    ];

    // Compute sum before sorting.
    let sumBefore = sum(&data[..]);

    bubbleSort(&mut data[..]);

    // Check the array is sorted.
    assert isSorted(&data[..]);

    // Check sum is preserved (no data corruption).
    let sumAfter = sum(&data[..]);
    assert sumBefore == sumAfter;

    // Check specific element positions.
    let r = verifyPositions(&data[..]);
    if r != 0 {
        return 10 + r;
    }
    return 0;
}