Kotlin: شرح تدفق التحكم في كوتلن

// نظيف، شامل، مُتحقَق من المُترجِم
fun route(order: Order): Pipeline = when (order.status) {
    Status.PENDING -> PendingPipeline
    Status.CONFIRMED -> if (order.total > 10_000) VipPipeline else StandardPipeline
    Status.SHIPPED -> TrackingPipeline
    Status.CANCELLED -> RefundPipeline
}

// if كتعبير
val max = if (a > b) a else b

// تعبير if متعدد الفروع
val category = if (total > 10_000) {
    println("High value order")
    "VIP"
} else if (total > 1_000) {
    "PRIORITY"
} else {
    "STANDARD"
}

// لا حاجة لعامل ثلاثي - if/else هو العامل الثلاثي
val discount = if (total > 5_000) 0.15 else if (total > 1_000) 0.10 else 0.0

// مطابقة تامة
val label = when (status) {
    "PENDING" -> "Waiting"
    "CONFIRMED" -> "Confirmed"
    else -> "Unknown"
}

// قيم متعددة في فرع واحد
val isTerminal = when (status) {
    "SHIPPED", "DELIVERED", "CANCELLED" -> true
    else -> false
}

// فروع شرطية مع 'in' والنطاقات
val pipeline = when {
    status == "CANCELLED" -> "REFUND"
    total > 10_000 && priority == "URGENT" -> "VIP_EXPRESS"
    total > 10_000 -> "VIP"
    total > 1_000 -> "PRIORITY"
    status in listOf("NEW", "PENDING") -> "QUEUE"
    else -> "STANDARD"
}

// التقاط مع موضوع when
val result = when (val response = httpClient.call()) {
    is Success -> "OK: ${response.data}"
    is Error -> "Failed: ${response.code}"
}
// response محوّل ذكيًا ومتاح في الفروع

// تكرار النطاق
for (i in 1..10) { /* i من 1 إلى 10 */ }

// تكرار القائمة
for (order in orders) { println(order.id) }

// مع فهرس
for ((index, order) in orders.withIndex()) {
    println("[$index] ${order.id}")
}

// تكرار الخريطة
for ((id, status) in orderStatusMap) {
    println("$id: $status")
}

// أي فئة بها operator fun iterator() يمكن استخدامها في حلقة for
class OrderBatch(val orders: List<Order>) {
    operator fun iterator(): Iterator<Order> = orders.iterator()
}

val batch = OrderBatch(orders)
for (order in batch) { /* يعمل! */ }

// while قياسية
var retryCount = 0
while (retryCount < 3) {
    val success = tryProcessOrder()
    if (success) break
    retryCount++
}

// do-while (تنفذ مرة واحدة على الأقل)
var input: String
do {
    input = readOrderStatus()
} while (input !in listOf("CONFIRM", "CANCEL"))

// تصنيف الحلقة الخارجية
loop@ for (batch in batches) {
    for (order in batch) {
        if (order.status == "CANCELLED") continue@loop  // تخطي للدُفعة التالية
        if (order.total > 100_000) break@loop  // إيقاف جميع المعالجة
        process(order)
    }
}

// إرجاع من lambda (إرجاع محلي)
orders.forEach { order ->
    if (order.status == "SKIP") return@forEach  // تخطي هذا العنصر فقط
    process(order)
}

// إرجاع من الدالة المُغلِقة (إرجاع غير محلي)
// يعمل فقط في الدوال المضمنة
orders.forEach { order ->
    if (order.status == "FATAL") return  // يخرج من main()
    process(order)
}

// ============================================
// OrderProcessor - توجيه حسب الحالة
// الميزة: توجيه كامل لحالة الطلب مع when
// ============================================

enum class Status { PENDING, CONFIRMED, SHIPPED, DELIVERED, CANCELLED }
data class Order(val id: String, val total: Double, val status: Status, val region: String)

fun routeOrder(order: Order): String = when (order.status) {
    Status.PENDING -> when {
        order.region == "EU" -> "EU_COMPLIANCE_QUEUE"
        order.total > 10_000 -> "HIGH_VALUE_QUEUE"
        else -> "STANDARD_QUEUE"
    }
    Status.CONFIRMED -> when {
        order.total > 5_000 -> "EXPRESS_SHIPPING"
        else -> "REGULAR_SHIPPING"
    }
    Status.SHIPPED -> "TRACKING_UPDATE"
    Status.DELIVERED -> "COMPLETION_QUEUE"
    Status.CANCELLED -> when {
        order.total > 1_000 -> "PRIORITY_REFUND"
        else -> "STANDARD_REFUND"
    }
}

fun processBatch(orders: List<Order>) {
    loop@ for (order in orders) {
        when (order.status) {
            Status.CANCELLED -> {
                println("SKIP: ${order.id} cancelled")
                continue@loop
            }
            else -> {
                val pipeline = routeOrder(order)
                val priority = if (order.total > 10_000) "CRITICAL" else "NORMAL"
                println("PROCESS: ${order.id} -> $pipeline [$priority]")
            }
        }
    }
}

fun main() {
    val orders = listOf(
        Order("ORD-001", 299.99, Status.CONFIRMED, "US"),
        Order("ORD-002", 15_000.00, Status.PENDING, "EU"),
        Order("ORD-003", 2_500.00, Status.CONFIRMED, "US"),
        Order("ORD-004", 45.50, Status.CANCELLED, "US"),
        Order("ORD-005", 800.00, Status.PENDING, "ASIA"),
        Order("ORD-006", 8_000.00, Status.SHIPPED, "US")
    )

    println("=== Order Routing ===")
    processBatch(orders)

    // ملخص باستخدام نتائج تعبير when
    val summary = orders
        .filter { it.status != Status.CANCELLED }
        .groupBy { routeOrder(it) }
        .mapValues { (pipeline, list) -> "${list.size} orders" }

    println("\n=== Pipeline Summary ===")
    summary.forEach { (pipeline, info) -> println("  $pipeline: $info") }
}

=== Order Routing ===
PROCESS: ORD-001 -> REGULAR_SHIPPING [NORMAL]
PROCESS: ORD-002 -> EU_COMPLIANCE_QUEUE [CRITICAL]
PROCESS: ORD-003 -> EXPRESS_SHIPPING [NORMAL]
SKIP: ORD-004 cancelled
PROCESS: ORD-005 -> STANDARD_QUEUE [NORMAL]
PROCESS: ORD-006 -> TRACKING_UPDATE [NORMAL]

=== Pipeline Summary ===
  REGULAR_SHIPPING: 1 orders
  EU_COMPLIANCE_QUEUE: 1 orders
  EXPRESS_SHIPPING: 1 orders
  STANDARD_QUEUE: 1 orders
  TRACKING_UPDATE: 1 orders

// if تعبير يمكن تعيينه مباشرة
val a = 10
val b = 20
val max = if (a > b) a else b
println("Max: $max")

// if متعدد الفروع كتعبير
val score = 85
val grade = if (score >= 90) "A"
           else if (score >= 80) "B"
           else if (score >= 70) "C"
           else "F"
println("Score $score -> Grade $grade")

// مع كتل (آخر تعبير يُرجع)
val description = if (score >= 60) {
    val bonus = score / 10
    "Passed with bonus: $bonus"
} else {
    "Failed"
}
println(description)

Max: 20
Score 85 -> Grade B
Passed with bonus: 8

// when كتعبير — يفرض الشمول
fun describe(value: Any): String = when (value) {
    is String -> "نص بطول ${value.length}: \"$value\""
    is Int -> when {
        value > 0 -> "عدد صحيح موجب"
        value < 0 -> "عدد صحيح سالب"
        else -> "صفر"
    }
    is List<*> -> "قائمة بـ ${value.size} عناصر"
    is Map<*, *> -> "خريطة بـ ${value.size} إدخالات"
    null -> "قيمة فارغة"
    else -> "نوع آخر: ${value::class.simpleName}"
}

println(describe("مرحبا"))
println(describe(42))
println(describe(-5))
println(describe(listOf(1, 2, 3)))
println(describe(null))
println(describe(3.14))

نص بطول 6: "مرحبا"
عدد صحيح موجب
عدد صحيح سالب
قائمة بـ 3 عناصر
قيمة فارغة
نوع آخر: double

fun classifyOrder(total: Double, status: String): String = when {
    status == "CANCELLED" -> "ملغي - تخطي"
    total > 10_000 -> "VIP - أولوية قصوى"
    total > 1_000 && status == "CONFIRMED" -> "أولوية عالية - شحن سريع"
    total in 500.0..1_000.0 -> "متوسط - معالجة قياسية"
    total < 0 -> "خطأ - مبلغ سالب"
    else -> "عادي"
}

println(classifyOrder(15_000.0, "CONFIRMED"))
println(classifyOrder(2_500.0, "CONFIRMED"))
println(classifyOrder(750.0, "PENDING"))
println(classifyOrder(-100.0, "NEW"))
println(classifyOrder(50.0, "CANCELLED"))
println(classifyOrder(50.0, "NEW"))

VIP - أولوية قصوى
أولوية عالية - شحن سريع
متوسط - معالجة قياسية
خطأ - مبلغ سالب
ملغي - تخطي
عادي

// نطاق مغلق
print("1..5: ")
for (i in 1..5) print("$i ")
println()

// نطاق تنازلي مع step
print("10 downTo 1 step 2: ")
for (i in 10 downTo 1 step 2) print("$i ")
println()

// نصف مفتوح (حتى ولكن لا يشمل)
print("0 until 5: ")
for (i in 0 until 5) print("$i ")
println()

// قائمة
val fruits = listOf("تفاح", "موز", "برتقال")
for (fruit in fruits) println("فاكهة: $fruit")

// مع الفهرس
for ((index, fruit) in fruits.withIndex()) {
    println("$index: $fruit")
}

1..5: 1 2 3 4 5
10 downTo 1 step 2: 10 8 6 4 2
0 until 5: 0 1 2 3 4
فاكهة: تفاح
فاكهة: موز
فاكهة: برتقال
0: تفاح
1: موز
2: برتقال

// while — فحص شرط قبل التكرار
var countdown = 5
print("Countdown: ")
while (countdown > 0) {
    print("$countdown ")
    countdown--
}
println("Liftoff!")

// do-while — تنفيذ مرة واحدة على الأقل
var input = 0
var attempts = 0
do {
    attempts++
    input = (1..10).random()
    println("Attempt $attempts: got $input")
} while (input < 5 && attempts < 5)
println("Final: $input after $attempts attempts")

Countdown: 5 4 3 2 1 Liftoff!
Attempt 1: got 7
Final: 7 after 1 attempts

// البحث عن عنصر في مصفوفة ثنائية الأبعاد
val matrix = arrayOf(
    arrayOf(1, 2, 3),
    arrayOf(4, 5, 6),
    arrayOf(7, 8, 9)
)

var found = false
var targetValue = 5

outer@ for (i in matrix.indices) {
    inner@ for (j in matrix[i].indices) {
        if (matrix[i][j] == targetValue) {
            println("Found $targetValue at [$i][$j]")
            found = true
            break@outer  // يخرج من كلتا الحلقتين
        }
    }
}

if (!found) println("$targetValue not found")

// continue@label — تخطي إلى التكرار التالي لحلقة محددة
for (i in 1..5) {
    if (i == 3) continue
    print("$i ")
}

Found 5 at [1][1]
1 2 4 5

val orders = listOf(
    "ORD-001" to "CONFIRMED",
    "ORD-002" to "CANCELLED",
    "ORD-003" to "PENDING",
    "ORD-004" to "CONFIRMED"
)

// return@forEach يتخطى فقط هذا العنصر
orders.forEach { (id, status) ->
    if (status == "CANCELLED") {
        println("SKIP $id (cancelled)")
        return@forEach
    }
    println("PROCESS $id ($status)")
}

// البحث عن أول عنصر مطابق
val firstCancelled = orders.firstOrNull { it.second == "CANCELLED" }
println("First cancelled: ${firstCancelled?.first}")

// takeWhile / dropWhile
val pendingOrders = orders.takeWhile { it.second == "CONFIRMED" }
println("Take while CONFIRMED: $pendingOrders")

val remaining = orders.dropWhile { it.second == "CONFIRMED" }
println("Drop while CONFIRMED: $remaining")

SKIP ORD-002 (cancelled)
PROCESS ORD-001 (CONFIRMED)
PROCESS ORD-003 (PENDING)
PROCESS ORD-004 (CONFIRMED)
First cancelled: ORD-002
Take while CONFIRMED: [(ORD-001, CONFIRMED)]
Drop while CONFIRMED: [(ORD-002, CANCELLED), (ORD-003, PENDING), (ORD-004, CONFIRMED)]