/* ===== 复杂类型嵌套综合测试 =====
 * test20_complex — 结构体嵌套、切片、数组、方法、类型别名、枚举等
 * 难度：5/5
 */
/* ---- 基础结构体 ---- */
type Point = struct {
    var x: i32;
    var y: i32;
}

/* ---- 嵌套结构体 ---- */
type Rect = struct {
    var min: Point;
    var max: Point;
}

/* ---- 含切片字段的结构体 (核心 bug 测试) ---- */
type Buffer = struct {
    var data: []u8;
    var len: usize;
}

/* ---- 含数组字段的结构体 ---- */
type MatrixRow = struct {
    var items: [4]i32;
}

/* ---- 含指针字段的结构体 ---- */
type Node = struct {
    var ptr: *i32;
    var val: i32;
}

/* ---- 多层级嵌套：结构体里的结构体里的切片 ---- */
type Bundle = struct {
    var name: *u8;
    var buf: Buffer;
    var row: MatrixRow;
    var pt: Point;
}

/* ---- 枚举含数据 ---- */
type Status = enum {
    Active: i32;
    Inactive;
    Pending: Point;
}

/* ---- 含方法的结构体 (方法定义在结构体内部) ---- */
type Counter = struct {
    var val: i32;

    fn inc(self: *Counter) i32 {
        self.val = self.val + 1;
        ret self.val;
    }

    fn add(self: *Counter, n: i32) i32 {
        self.val = self.val + n;
        ret self.val;
    }

    fn reset(self: *Counter) {
        self.val = 0;
    }

    fn get(self: *Counter) i32 {
        ret self.val;
    }
}

/* ============================================================
 * 测试 1: 切片在结构体内部初始化 (修复的核心 bug)
 * ============================================================ */

fn test_slice_in_struct() i32 {
    var raw: [4]u8;
    raw[0] = 65; raw[1] = 66; raw[2] = 67; raw[3] = 68;

    /* Bug fix: { .ptr = ..., .len = ... } inside struct literal */
    var b: Buffer = Buffer { .data = { .ptr = &raw[0], .len = 4 }, .len = 4 };

    if b.len != 4 { ret 1; }
    if b.data[0] != 65 { ret 2; }
    if b.data[1] != 66 { ret 3; }
    if b.data[3] != 68 { ret 4; }

    /* Modify through slice — verify reflection */
    b.data[0] = 90;
    if raw[0] != 90 { ret 5; }

    /* Initialize with shorter slice */
    var b2: Buffer = Buffer { .data = { .ptr = &raw[2], .len = 2 }, .len = 2 };
    if b2.len != 2 { ret 6; }
    if b2.data[0] != 67 { ret 7; }

    /* Slice field assignment via field access */
    b2.data.ptr = &raw[0];
    b2.data.len = 4;
    if b2.data[0] != 90 { ret 8; }
    if b2.data.len != 4 { ret 9; }

    ret 0;
}

/* ============================================================
 * 测试 2: 结构体含数组字段
 * ============================================================ */

fn test_struct_with_array() i32 {
    var mr: MatrixRow = MatrixRow { .items = [4]i32{10, 20, 30, 40} };

    if mr.items[0] != 10 { ret 1; }
    if mr.items[1] != 20 { ret 2; }
    if mr.items[2] != 30 { ret 3; }
    if mr.items[3] != 40 { ret 4; }

    /* 修改数组元素 */
    mr.items[2] = 99;
    if mr.items[2] != 99 { ret 5; }

    ret 0;
}

/* ============================================================
 * 测试 3: 嵌套结构体初始化
 * ============================================================ */

fn test_nested_struct() i32 {
    var p: Point = Point { .x = 5, .y = 10 };
    if p.x != 5 { ret 1; }
    if p.y != 10 { ret 2; }

    /* 嵌套结构体字面量 */
    var r: Rect = Rect {
        .min = Point { .x = 1, .y = 2 },
        .max = Point { .x = 3, .y = 4 }
    };
    if r.min.x != 1 { ret 3; }
    if r.min.y != 2 { ret 4; }
    if r.max.x != 3 { ret 5; }
    if r.max.y != 4 { ret 6; }

    /* 修改嵌套字段 */
    r.min.x = 100;
    if r.min.x != 100 { ret 7; }
    if r.min.y != 2 { ret 8; }  /* unchanged */

    ret 0;
}

/* ============================================================
 * 测试 4: 结构体成员方法 (实例方法调用)
 * ============================================================ */

fn test_struct_method() i32 {
    var c: Counter = Counter { .val = 0 };

    /* 实例方法调用 c.inc() */
    var r1: i32 = c.inc();
    if r1 != 1 { ret 1; }
    if c.val != 1 { ret 2; }

    /* 带参数方法调用 c.add(n) */
    var r2: i32 = c.add(5);
    if r2 != 6 { ret 3; }
    if c.val != 6 { ret 4; }

    /* 连续调用 */
    c.reset();
    if c.val != 0 { ret 5; }

    c.add(10);
    c.inc();
    var r3: i32 = c.get();
    if r3 != 11 { ret 6; }

    ret 0;
}

/* ============================================================
 * 测试 5: 结构体含指针字段
 * ============================================================ */

fn test_ptr_in_struct() i32 {
    var v: i32 = 42;
    var n: Node = Node { .ptr = &v, .val = 99 };

    if n.val != 99 { ret 1; }
    if n.ptr[0] != 42 { ret 2; }

    /* 通过指针修改 */
    v = 100;
    if n.ptr[0] != 100 { ret 3; }

    /* 通过指针在结构体内修改 */
    n.ptr[0] = 200;
    if v != 200 { ret 4; }

    ret 0;
}

/* ============================================================
 * 测试 6: 多层级复杂嵌套
 * ============================================================ */

fn test_complex_nesting() i32 {
    var str_data: [5]u8;
    str_data[0] = 72; str_data[1] = 101;
    str_data[2] = 108; str_data[3] = 108; str_data[4] = 111;

    var bundle: Bundle = Bundle {
        .name = &str_data[0],
        .buf = Buffer { .data = { .ptr = &str_data[1], .len = 3 }, .len = 3 },
        .row = MatrixRow { .items = [4]i32{1, 2, 3, 4} },
        .pt = Point { .x = -5, .y = 15 }
    };

    /* Verify name */
    if bundle.name[0] != 72 { ret 1; }
    if bundle.name[4] != 111 { ret 2; }

    /* Verify nested slice */
    if bundle.buf.len != 3 { ret 3; }
    if bundle.buf.data[0] != 101 { ret 4; }
    if bundle.buf.data[2] != 108 { ret 5; }

    /* Verify array field */
    if bundle.row.items[0] != 1 { ret 6; }
    if bundle.row.items[3] != 4 { ret 7; }

    /* Verify nested struct field */
    if bundle.pt.x != -5 { ret 8; }
    if bundle.pt.y != 15 { ret 9; }

    /* Modify nested slice */
    bundle.buf.data[1] = 87; /* 'W' */
    if str_data[2] != 87 { ret 10; }

    /* Modify nested array */
    bundle.row.items[2] = 33;
    if bundle.row.items[2] != 33 { ret 11; }

    ret 0;
}

/* ============================================================
 * 测试 7: 枚举含结构体数据
 * ============================================================ */

fn test_enum_complex() i32 {
    var s: Status = Status { .Active = 42 };

    /* Verify active variant */
    match s {
        .Active(val) => {
            if val != 42 { ret 1; }
        },
        .Inactive => {
            ret 2;
        },
        .Pending(px, py) => {
            ret 3;
        }
    }

    /* Test Inactive variant */
    var s2: Status = Status { .Inactive };
    var is_inactive: i32 = 0;
    match s2 {
        .Active(val) => {},
        .Inactive => { is_inactive = 1; },
        .Pending(px, py) => {}
    }
    if is_inactive != 1 { ret 4; }

    /* Test Pending variant with struct data */
    var s3: Status = Status { .Pending = Point { .x = 7, .y = 8 } };
    match s3 {
        .Active(val) => { ret 5; },
        .Inactive => { ret 6; },
        .Pending(px, py) => {
            if px != 7 { ret 7; }
            if py != 8 { ret 8; }
        }
    }

    ret 0;
}

/* ============================================================
 * 主函数
 * ============================================================ */

fn main() i32 {
    var r: i32;

    r = test_slice_in_struct();
    if r != 0 { ret r; }

    r = test_struct_with_array();
    if r != 0 { ret r + 100; }

    r = test_nested_struct();
    if r != 0 { ret r + 200; }

    r = test_struct_method();
    if r != 0 { ret r + 300; }

    r = test_ptr_in_struct();
    if r != 0 { ret r + 400; }

    r = test_complex_nesting();
    if r != 0 { ret r + 500; }

    r = test_enum_complex();
    if r != 0 { ret r + 600; }

    ret 0;
}