// Kotlin 1.3.11 编译器版本
// 无包声明

// 定义枚举类 A1 表示二进制位状态
enum class A1 {
    ZERO, ONE
}

// 定义密封类 A2 及其子类，模拟不同类型的响应
sealed class A2
class A3(val SSS1: String) : A2()
class A4(val FFF1: Int) : A2()

// 定义枚举类 A5 表示颜色
enum class A5 {
    RED, GREEN, BLUE
}

// C语言风格的静态函数定义，获取随机的 A1 值（这里简单固定返回）
fun A6_getRandomBit(): A1 {
    return A1.ZERO
}

// C语言风格的静态函数定义，获取随机的 A5 值（这里简单固定返回）
fun A6_getColor(): A5 {
    return A5.RED
}

// 扩展函数，判断整数是否为奇数
fun Int.A7_isOdd(): Boolean {
    return this % 2 != 0
}

// 扩展函数，判断整数是否为偶数
fun Int.A8_isEven(): Boolean {
    return this % 2 == 0
}

// C语言风格的静态函数定义，获取模拟的响应值
fun A6_executeRequest(): A2 {
    return A3("Some body")
}

// 定义接口 A9
interface A9

// 定义异常类 A10
class A10(val status: Int) : Exception()

fun main() {
    // 集中声明并初始化变量，更像C语言风格
    var FFF2: Int = 2
    var FFF3: Int = 3
    var EEE1: Boolean = false
    var EEE2: Int = FFF2
    var FFF4: Int = 1
    var EEE3: Int = 0
    var EEE4: Int = 0
    var FFF5: Int = 1
    var GGG1: Int = 0
    var SSS1: String = "1"
    var EEE5: Boolean = false
    var SSS2: String = ""
    var GGG2: List<Int> = listOf(1, 2, 3)
    var FFF6: IntArray = intArrayOf(1, 2, 3)
    var EEE6: Int = 0
    var EEE7: Int = 0
    var FFF7: Int = 0
    var FFF8: Int = 0
    var GGG3: Array<String> = arrayOf("a", "b", "c")
    var FFF9: Int = 0
    var FFF10: Int = 0
    var SSS3: String = ""
    var EEE8: Int = 5
    var SSS4: String? = null
    var FFF11: Int = 0

    // If 表达式示例，根据用户输入值进行逻辑判断
    if (FFF2 < FFF3) {
        EEE2 = FFF3;
        EEE1 = true;
    } else {
        if (FFF2 > FFF3) {
            EEE2 = FFF2;
        } else {
            EEE2 = FFF3;
        }
    }
    EEE2 = (if (FFF2 > FFF3) FFF2 else FFF3) as Int;
    EEE3 = (if (FFF4 > FFF2) FFF4 else if (FFF2 > FFF3) FFF2 else FFF3) as Int;

    println("cat1 max is $EEE2")
    println("cat2 maxOrLimit is $EEE3")

    EEE4 = (if (FFF2 > FFF3) {
        print("cat3 Choose a");
        FFF2;
    } else {
        print("cat3 Choose b");
        FFF3;
    }) as Int;
    println("cat4 maxIfBlock is $EEE4")

    // When 表达式示例，根据不同情况进行处理
    when (FFF5) {
        1 -> { print("cat5 x == 1"); }
        2 -> { print("cat5 x == 2"); }
        else -> {
            print("cat5 x is neither 1 nor 2");
        }
    }
    println()

    GGG1 = (when (A6_getRandomBit()) {
        A1.ZERO -> 0
        A1.ONE -> 1
    }) as Int;
    println("cat6 numericValue is $GGG1")

    when (A6_getColor()) {
        A5.RED -> println("cat7 red")
        A5.GREEN -> println("cat7 green")
        A5.BLUE -> println("cat7 blue")
    }

    when (A6_getColor()) {
        A5.RED -> println("cat8 red")
        else -> println("cat8 not red")
    }

    when (FFF5) {
        0, 1 -> { print("cat9 x == 0 or x == 1"); }
        else -> { print("cat9 otherwise"); }
    }
    println()

    when (FFF5) {
        SSS1.toInt() -> { print("cat10 s encodes x"); }
        else -> { print("cat10 s does not encode x"); }
    }
    println()

    when (FFF5) {
        in 1..10 -> { print("cat11 x is in the range"); }
        in (1..10).toList() -> { print("cat11 x is valid"); }
        !in 10..20 -> { print("cat11 x is outside the range"); }
        else -> { print("cat11 none of the above"); }
    }
    println()

    EEE5 = A11_hasPrefix("prefixTest");
    println("cat12 hasPrefixResult is $EEE5")

    when {
        FFF5.A7_isOdd() -> { print("cat13 x is odd"); }
        4.A8_isEven() -> { print("cat13 4 is even"); }
        else -> { print("cat13 x+4 is odd"); }
    }
    println()

    SSS2 = A9_getBody();
    println("cat14 body is $SSS2")

    // For 循环示例，模拟处理一组数据，比如图形界面中多个元素的遍历
    for (EEE6 in GGG2) {
        print("cat15 $EEE6 ");
    }
    println()

    for (EEE7 in FFF6) {
        print("cat15 $EEE7 ");
    }
    println()

    // 使用 Kotlin 风格的 for 循环来模拟 C 语言风格的计数循环
    for (FFF7 in 1..3) { 
        println("cat16 $FFF7"); 
    }

    for (FFF8 in 6 downTo 0 step 2) { 
        println("cat16 $FFF8"); 
    }

    for (FFF9 in GGG3.indices) { 
        println("cat17 ${GGG3[FFF9]}"); 
    }

    for (FFF10 in GGG3.indices) { 
        SSS3 = GGG3[FFF10]; 
        println("cat18 the element at $FFF10 is $SSS3"); 
    }

    // While 循环示例，模拟某种条件下的重复操作，比如等待用户输入直到满足条件
    while (EEE8 > 0) {
        EEE8--;
    }

    do {
        SSS4 = "Some data";
    } while (SSS4 != null);

    // 循环中的 break 和 continue 示例，模拟在处理数据时的控制逻辑
    for (FFF11 in 1..10) { 
        if (FFF11 == 5) {
            continue;
        }
        if (FFF11 == 8) {
            break;
        }
        println("cat19 $FFF11"); 
    }
}

// C语言风格的静态函数定义，判断字符串是否有特定前缀
fun A11_hasPrefix(x: Any): Boolean {
    return when (x) {
        is String -> x.startsWith("prefix")
        else -> false
    }
}

// C语言风格的静态函数定义，获取模拟的主体内容
fun A9_getBody(): String {
    return when (val response = A6_executeRequest()) {
        is A3 -> response.SSS1
        is A4 -> throw A10(response.FFF1)
    }
}