//! returns: 0

//! Test suite for stack memory allocation and aliasing behavior.

//! Tests variable aliasing, mutations, and stack frame management.

record Person {

    age: i32,

    score: i32,

}

record Container {

    values: [i32; 3],

    count: i32,

}

/// Basic variable aliasing and mutation.

fn testBasicAliasing() -> i32 {

    let mut x: i32 = 10;

    let mut y: i32 = x;  // y aliases x's value

    x = 20;          // Modify x

    y += 5;       // Modify y independently

    return x + y;    // Should be 20 + 15 = 35

}

/// Struct aliasing and field mutation.

fn testStructAliasing() -> i32 {

    let mut p1: Person = Person { age: 25, score: 100 };

    let mut p2: Person = p1;     // Copy record

    p1.age = 30;             // Modify original

    p2.score = 0;            // Modify copy

    return p1.age + p1.score + p2.age + p2.score; // 30+100+25+0 = 155

}

/// Array aliasing and element mutation.

fn testArrayAliasing() -> i32 {

    let mut arr1: [i32; 3] = [1, 2, 3];

    let mut arr2: [i32; 3] = arr1;  // Copy array

    arr1[0] = 10;               // Modify original

    arr2[1] = 20;               // Modify copy

    // Arrays should be independent

    return arr1[0] + arr1[1] + arr2[0] + arr2[1]; // 10+2+1+20 = 33

}

/// Test 4: Nested record with array mutation.

fn testNestedStructArrayMutation() -> i32 {

    let mut container1: Container = Container {

        values: [1, 2, 3],

        count: 3

    };

    let mut container2: Container = container1;  // Copy entire record

    container1.values[0] = 50;              // Modify nested array in original

    container1.count = 5;                   // Modify field in original

    container2.values[2] = 60;              // Modify nested array in copy

    container2.count = 7;                   // Modify field in copy

    return container1.values[0] + container1.count +

           container2.values[2] + container2.count; // 50+5+60+7 = 122

}

/// Variable overwriting with different types/scopes.

fn testVariableOverwriting() -> i32 {

    let mut result: i32 = 0;

    let mut temp: i32 = 10;

    result = temp;      // First assignment

    temp = 20;          // Overwrite temp

    result += temp; // result = 10 + 20 = 30

    // Create new scope with same variable name

    if true {

        let mut temp: i32 = 50;   // Shadow outer temp

        result += temp; // result = 30 + 50 = 80

        temp = 60;        // Modify inner temp

        result += temp; // result = 80 + 60 = 140

    }

    result += temp;   // Should use outer temp (20)

    return result;            // 140 + 20 = 160

}

/// Array of structs with aliasing.

fn testArrayOfStructsAliasing() -> i32 {

    let mut people: [Person; 2] = [

        Person { age: 10, score: 20 },

        Person { age: 15, score: 25 }

    ];

    let mut backup: [Person; 2] = people;  // Copy array of structs

    people[0].age = 12;        // Modify original

    people[1].score = 30;      // Modify original

    backup[0].score = 22;      // Modify copy

    backup[1].age = 18;        // Modify copy

    return people[0].age + people[0].score + people[1].age + people[1].score +

           backup[0].age + backup[0].score + backup[1].age + backup[1].score;

}

/// Complex mutation chain.

fn testMutationChain() -> i32 {

    let mut a: i32 = 1;

    let mut b: i32 = 2;

    let mut c: i32 = 3;

    a = b;          // a = 2

    b = c;          // b = 3

    c = a + b;      // c = 2 + 3 = 5

    a = c - b;      // a = 5 - 3 = 2

    b = a * c;      // b = 2 * 5 = 10

    return a + b + c; // 2 + 10 + 5 = 17

}

/// Struct field reassignment with aliasing.

fn testStructFieldReassignment() -> i32 {

    let mut original: Person = Person { age: 30, score: 40 };

    let mut copied: Person = original;

    // Swap fields in original

    let mut temp: i32 = original.age;

    original.age = original.score;

    original.score = temp;

    // Different swap in copy

    temp = copied.score;

    copied.score = copied.age;

    copied.age = temp;

    return original.age + original.score + copied.age + copied.score;

    // 40+30 + 40+30 = 140

}

/// Array index mutation with aliasing.

fn testArrayIndexMutation() -> i32 {

    let mut indices: [u32; 3] = [0, 1, 2];

    let mut values: [i32; 3] = [10, 20, 30];

    let mut backup: [i32; 3] = values;

    // Use indices to modify values

    values[indices[0]] = 25;     // values[0] = 25

    values[indices[1]] = 35;     // values[1] = 35

    // Modify indices

    indices[0] = 2;

    indices[2] = 0;

    // Use new indices on backup

    backup[indices[0]] = 40;   // backup[2] = 40

    backup[indices[2]] = 45;   // backup[0] = 45

    return values[0] + values[1] + values[2] +

           backup[0] + backup[1] + backup[2];

    // 25+35+30 + 45+20+40 = 195

}

/// Multiple assignment levels.

fn testMultipleAssignmentLevels() -> i32 {

    let mut level1: Person = Person { age: 10, score: 20 };

    let mut level2: Person = level1;

    let mut level3: Person = level2;

    let mut level4: Person = level3;

    // Modify each level

    level1.age = 11;

    level2.age = 12;

    level3.age = 13;

    level4.age = 14;

    level1.score = 21;

    level2.score = 22;

    level3.score = 23;

    level4.score = 24;

    return (level1.age + level1.score) +

           (level2.age + level2.score) +

           (level3.age + level3.score) +

           (level4.age + level4.score);

    // (11+21) + (12+22) + (13+23) + (14+24) = 32+34+36+38 = 140

}

@default fn main() -> i32 {

    if (testBasicAliasing() != 35) {

        return 1; // Failure

    }

    if (testStructAliasing() != 155) {

        return 1; // Failure

    }

    if (testArrayAliasing() != 33) {

        return 1; // Failure

    }

    if (testNestedStructArrayMutation() != 122) {

        return 1; // Failure

    }

    if (testVariableOverwriting() != 160) {

        return 1; // Failure

    }

    if (testArrayOfStructsAliasing() != 152) {

        return 1; // Failure

    }

    if (testMutationChain() != 17) {

        return 1; // Failure

    }

    if (testStructFieldReassignment() != 140) {

        return 1; // Failure

    }

    if (testArrayIndexMutation() != 195) {

        return 1; // Failure

    }

    if (testMultipleAssignmentLevels() != 140) {

        return 1; // Failure

    }

    return 0; // Success

}