/* ===== 模块4：match 语句 =====
 * test18_match — match 枚举匹配 + 整数匹配（类似 switch）
 * 难度：3/5
 * 验证点：枚举匹配、带数据绑定、结构体字段绑定、枚举指针、
 *         整数自变量匹配、默认分支 _
 */

/* ---- 简单枚举（无数据） ---- */
type Color = enum {
    Red;
    Green;
    Blue;
}

/* ---- 带 i32 数据的枚举 ---- */
type Optional = enum {
    Some: i32;
    None;
}

/* ---- 带结构体数据的枚举 ---- */
type Point = struct {
    var x: i32;
    var y: i32;
}

type Shape = enum {
    Circle: i32;
    Rect: Point;
}

/* ---- 多变体枚举 ---- */
type ActionResult = enum {
    Success: i32;
    NotFound;
    Timeout: i32;
    Error: *u8;
}

/* ============================================================
 * 测试 1: 无数据枚举匹配
 * ============================================================ */

fn test_color_match() i32 {
    var c: Color = Color { .Red };
    var val: i32 = 0;

    match c {
        .Red => { val = 1; },
        .Green => { val = 2; },
        .Blue => { val = 3; }
    }
    if val != 1 { ret 1; }

    c = Color { .Green };
    match c {
        .Red => { val = 0; },
        .Green => { val = 2; },
        .Blue => { val = 0; }
    }
    if val != 2 { ret 2; }

    c = Color { .Blue };
    match c {
        .Red => { val = 0; },
        .Green => { val = 0; },
        .Blue => { val = 3; }
    }
    if val != 3 { ret 3; }

    ret 0;
}

/* ============================================================
 * 测试 2: 带 i32 数据枚举匹配
 * ============================================================ */

fn test_optional_match() i32 {
    var o: Optional = Optional { .Some = 42 };

    match o {
        .Some(val) => {
            if val != 42 { ret 1; }
        },
        .None => {
            ret 2;
        }
    }

    o = Optional { .None };
    var is_none: i32 = 0;
    match o {
        .Some(val) => {},
        .None => { is_none = 1; }
    }
    if is_none != 1 { ret 3; }

    /* 多次提取不同值 */
    o = Optional { .Some = 99 };
    match o {
        .Some(val) => {
            if val != 99 { ret 4; }
        },
        .None => { ret 5; }
    }

    ret 0;
}

/* ============================================================
 * 测试 3: 带结构体数据枚举匹配（多字段绑定）
 * ============================================================ */

fn test_shape_match() i32 {
    /* Circle: 单数据 */
    var s: Shape = Shape { .Circle = 10 };
    match s {
        .Circle(r) => {
            if r != 10 { ret 1; }
        },
        .Rect(w, h) => {
            ret 2;
        }
    }

    /* Rect: 结构体数据，绑定为 (x, y) 对应 Point 的字段 */
    s = Shape { .Rect = Point { .x = 3, .y = 4 } };
    match s {
        .Circle(r) => { ret 3; },
        .Rect(w, h) => {
            if w != 3 { ret 4; }
            if h != 4 { ret 5; }
        }
    }

    ret 0;
}

/* ============================================================
 * 测试 4: 多数据变体枚举匹配
 * ============================================================ */

fn test_action_result_match() i32 {
    var r: ActionResult = ActionResult { .Success = 200 };
    match r {
        .Success(code) => {
            if code != 200 { ret 1; }
        },
        .NotFound => {
            ret 2;
        },
        .Timeout(ms) => {
            ret 3;
        },
        .Error(msg) => {
            ret 4;
        }
    }

    r = ActionResult { .NotFound };
    var found: i32 = 1;
    match r {
        .Success(code) => { found = 0; },
        .NotFound => { },
        .Timeout(ms) => { found = 0; },
        .Error(msg) => { found = 0; }
    }
    if found != 1 { ret 5; }

    r = ActionResult { .Timeout = 5000 };
    match r {
        .Success(code) => { ret 6; },
        .NotFound => { ret 7; },
        .Timeout(ms) => {
            if ms != 5000 { ret 8; }
        },
        .Error(msg) => { ret 9; }
    }

    ret 0;
}

/* ============================================================
 * 测试 5: 枚举指针匹配
 * ============================================================ */

fn test_ptr_match() i32 {
    var c: Color = Color { .Green };
    var p: *Color = &c;

    match p {
        .Red => { ret 1; },
        .Green => { },
        .Blue => { ret 2; }
    }

    /* 修改后通过指针匹配 */
    c = Color { .Blue };
    match p {
        .Red => { ret 3; },
        .Green => { ret 4; },
        .Blue => { }
    }

    ret 0;
}

/* ============================================================
 * 测试 6: match 作为函数返回值
 * ============================================================ */

fn classify_color(c: Color) i32 {
    match c {
        .Red => { ret 1; },
        .Green => { ret 2; },
        .Blue => { ret 3; }
    }
    ret 0;
}

fn test_match_in_func() i32 {
    var r: i32;

    r = classify_color(Color { .Red });
    if r != 1 { ret 1; }

    r = classify_color(Color { .Green });
    if r != 2 { ret 2; }

    r = classify_color(Color { .Blue });
    if r != 3 { ret 3; }

    ret 0;
}

/* ============================================================
 * 测试 7: match 嵌套在循环中
 * ============================================================ */

fn test_match_in_loop() i32 {
    var i: i32 = 0;
    var sum: i32 = 0;

    while i < 3 {
        var o: Optional;
        if i == 0 {
            o = Optional { .Some = 10 };
        } else if i == 1 {
            o = Optional { .Some = 20 };
        } else {
            o = Optional { .Some = 30 };
        }

        match o {
            .Some(val) => {
                sum = sum + val;
            },
            .None => { }
        }
        i = i + 1;
    }
    if sum != 60 { ret 1; }

    ret 0;
}

/* ============================================================
 * 测试 8: 整数 match（类似 switch）
 * ============================================================ */

fn test_int_match() i32 {
    var x: i32 = 2;
    var result: i32 = 0;

    match x {
        1 => { result = 10; },
        2 => { result = 20; },
        3 => { result = 30; }
    }
    if result != 20 { ret 1; }

    /* 匹配第一个值 */
    x = 1;
    match x {
        1 => { result = 100; },
        2 => { result = 200; },
        3 => { result = 300; }
    }
    if result != 100 { ret 2; }

    /* 匹配最后一个值 */
    x = 3;
    match x {
        1 => { result = 1000; },
        2 => { result = 2000; },
        3 => { result = 3000; }
    }
    if result != 3000 { ret 3; }

    ret 0;
}

/* ============================================================
 * 测试 9: 整数 match 带默认分支 _
 * ============================================================ */

fn test_int_match_default() i32 {
    var x: i32 = 99;
    var result: i32 = 0;

    match x {
        1 => { result = 1; },
        2 => { result = 2; },
        _ => { result = 99; }
    }
    if result != 99 { ret 1; }

    /* 默认分支未触发 */
    x = 1;
    match x {
        1 => { result = 1; },
        2 => { result = 2; },
        _ => { result = 99; }
    }
    if result != 1 { ret 2; }

    ret 0;
}

/* ============================================================
 * 测试 10: 整数 match 多个值跳转到相同逻辑
 * ============================================================ */

fn test_int_match_multi() i32 {
    var x: i32 = 2;
    var result: i32 = 0;

    /* 每个分支独立 */
    match x {
        0 => { result = 0; },
        1 => { result = 1; },
        2 => { result = 2; },
        3 => { result = 3; }
    }
    if result != 2 { ret 1; }

    /* 负数和零 */
    x = -1;
    match x {
        -1 => { result = -1; },
        0 => { result = 0; },
        1 => { result = 1; }
    }
    if result != -1 { ret 2; }

    x = 0;
    match x {
        -1 => { result = -1; },
        0 => { result = 0; },
        1 => { result = 1; }
    }
    if result != 0 { ret 3; }

    ret 0;
}

/* ============================================================
 * 测试 11a: match 多值 fallthrough: 1, 2, 3 => body
 * ============================================================ */

fn test_int_match_fallthrough() i32 {
    var x: i32;
    var r: i32;

    /* 三个值映射到同一个 body */
    x = 1; r = 0;
    match x {
        1, 2, 3 => { r = 10; },
        4, 5 => { r = 20; }
    }
    if r != 10 { ret 1; }

    x = 3;
    match x {
        1, 2, 3 => { r = 10; },
        4, 5 => { r = 20; }
    }
    if r != 10 { ret 2; }

    x = 5;
    match x {
        1, 2, 3 => { r = 10; },
        4, 5 => { r = 20; }
    }
    if r != 20 { ret 3; }

    /* 单一值(非fallthrough)仍然正常 */
    x = 7; r = 0;
    match x {
        1 => { r = 1; },
        7 => { r = 7; }
    }
    if r != 7 { ret 4; }

    /* 多个负数值 */
    x = -2; r = 0;
    match x {
        -3, -2, -1 => { r = 100; },
        0, 1 => { r = 200; }
    }
    if r != 100 { ret 5; }

    ret 0;
}

/* ============================================================
 * 测试 11b: match with body 中修改变量
 * ============================================================ */

fn test_match_with_side_effects() i32 {
    var x: i32 = 3;
    var acc: i32 = 0;

    match x {
        1 => { acc = acc + 1; },
        2 => { acc = acc + 2; },
        3 => { acc = acc + 3; },
        4 => { acc = acc + 4; }
    }
    if acc != 3 { ret 1; }

    /* 再次 match 同一个变量 */
    match x {
        1 => { acc = acc + 1; },
        2 => { acc = acc + 2; },
        3 => { acc = acc + 3; },
        4 => { acc = acc + 4; }
    }
    if acc != 6 { ret 2; }

    ret 0;
}

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

fn main() i32 {
    var r: i32;

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

    r = test_optional_match();
    if r != 0 { ret r + 10; }

    r = test_shape_match();
    if r != 0 { ret r + 20; }

    r = test_action_result_match();
    if r != 0 { ret r + 30; }

    r = test_ptr_match();
    if r != 0 { ret r + 40; }

    r = test_match_in_func();
    if r != 0 { ret r + 50; }

    r = test_match_in_loop();
    if r != 0 { ret r + 60; }

    r = test_int_match();
    if r != 0 { ret r + 70; }

    r = test_int_match_default();
    if r != 0 { ret r + 80; }

    r = test_int_match_multi();
    if r != 0 { ret r + 90; }

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

    r = test_int_match_fallthrough();
    if r != 0 { ret r + 110; }

    ret 0;
}