Kotlin: مقدمة في كوتلن وفلسفة التصميم

// Java: 20+ سطر فقط لتعريف POJO بسيط
public class Order {
    private String id;
    private BigDecimal total;
    private String status;

    public Order(String id, BigDecimal total, String status) {
        this.id = id;
        this.total = total;
        this.status = status;
    }

    public String getId() { return id; }
    public BigDecimal getTotal() { return total; }
    public String getStatus() { return status; }

    @Override
    public boolean equals(Object o) { /* 10+ أسطر */ }
    @Override
    public int hashCode() { /* 5+ أسطر */ }
    @Override
    public String toString() { /* 3+ أسطر */ }
}

// Kotlin: سطر واحد يفعل كل شيء
data class Order(val id: String, val total: BigDecimal, val status: String)

// commonMain - مشترك عبر جميع المنصات
expect fun logMessage(message: String)

// منصة JVM
actual fun logMessage(message: String) = println("[JVM] $message")

// منصة JS
actual fun logMessage(message: String) = console.log("[JS] $message")

// نوع غير فارغ: لا يمكن أن يكون null
val orderId: String = "ORD-001"

// نوع فارغ: يجب استخدام اللاحقة ?
val customerName: String? = null

// عامل الاستدعاء الآمن
val length = customerName?.length  // null إذا كان customerName فارغًا

// عامل Elvis: توفير قيمة افتراضية
val name = customerName ?: "Unknown"

// تأكيد عدم الفارغ: رمي NPE إذا كان فارغًا (استخدم باعتدال)
val forced = customerName!!

// ============================================
// OrderProcessor - أول برنامج كوتلن
// الميزة: تعريف نموذج الطلب وطباعة الملخص
// ============================================

// فئة بيانات: توليد تلقائي لـ equals/hashCode/toString/copy
data class Order(val id: String, val total: Double, val status: String)

data class Customer(val name: String, val email: String?)

fun main() {
    // إنشاء الطلبات
    val order1 = Order("ORD-001", 299.99, "SHIPPED")
    val order2 = Order("ORD-002", 1_500.00, "PROCESSING")

    // عميل فارغ
    val customer: Customer? = Customer("Alice", "alice@example.com")

    // استدعاء آمن + عامل Elvis
    val email = customer?.email ?: "no-email"

    // قالب سلسلة
    println("Order: ${order1.id}, Total: \$${order1.total} USD, Status: ${order1.status}")
    println("Customer email: $email")

    // تعبير when (مثل switch لكن أقوى)
    val priority = when {
        order2.total > 1_000 -> "HIGH"
        order2.total > 500 -> "MEDIUM"
        else -> "LOW"
    }
    println("Order ${order2.id} priority: $priority")

    // تحويل ذكي
    val result: Any = order1
    if (result is Order) {
        // لا حاجة لتحويل صريح!
        println("Smart cast: ${result.id} - ${result.total} USD")
    }
}

Order: ORD-001, Total: $299.99 USD, Status: SHIPPED
Customer email: alice@example.com
Order ORD-002 priority: HIGH
Smart cast: ORD-001 - 299.99 USD

// ============================================
// العوامل الأساسية — لا يوجد تحويل ضمني بين الأعداد
// الميزة: استدعاء صريح لـ toInt/toDouble
// ============================================

val intVal: Int = 42
val longVal: Long = 42L
val doubleVal: Double = 3.14
val boolVal: Boolean = true

// عامل حسابي
val sum = intVal + 100           // 142 (Int)
val product = intVal * 2          // 84

// مقارنة — تُرجع Boolean
val isPositive = intVal > 0       // true
val isEqual = intVal == 42L       // false! Int != Long

// تحويل صريح مطلوب
val widened = intVal.toLong()      // 42L
val narrowed = doubleVal.toInt()   // 3 (اقتطاع)

// استخدام في if/when
val category = when {
    intVal < 10 -> "small"
    intVal < 100 -> "medium"
    else -> "large"
}

println("sum=$sum, product=$product, isPositive=$isPositive, category=$category")

sum=142, product=84, isPositive=true, category=medium

// ============================================
// قوائم كوتلن — forEach/map/filter بسلسلة
// الميزة: البرمجة الوظيفية مدمجة في اللغة
// ============================================

val orders = listOf(
    "ORD-001" to 299.99,
    "ORD-002" to 1500.00,
    "ORD-003" to 50.00,
    "ORD-004" to 3200.00
)

// forEach — استدعاء على كل عنصر
println("=== جميع الطلبات ===")
orders.forEach { (id, total) ->
    println("$id: \$$total USD")
}

// map — تحويل كل عنصر
val totals = orders.map { it.second }
println("Totals: $totals")

// filter — تصفية حسب شرط
val highValue = orders.filter { it.second > 500.0 }
println("طلبات عالية القيمة: ${highValue.size}")

// sum — مجموع القيم (دالة امتداد على Iterable)
val grandTotal = totals.sum()
println("Grand total: \$${grandTotal} USD")

=== جميع الطلبات ===
ORD-001: $299.99 USD
ORD-002: $1500.0 USD
ORD-003: $50.0 USD
ORD-004: $3200.0 USD
Totals: [299.99, 1500.0, 50.0, 3200.0]
طلبات عالية القيمة: 2
Grand total: $5049.99 USD

// ============================================
// تعبير when — بديل قوي لـ switch
// الميزة: يدعم مطابقة النوع، النطاق، والقيمة
// ============================================

fun describeOrder(order: Any): String = when (order) {
    is String -> "معرف طلب: $order"
    is Int -> "عدد صحيح: $order"
    is List<*> -> "قائمة بـ ${order.size} عناصر"
    in 1..10 -> "رقم في النطاق 1-10: $order"
    "special" -> "قيمة خاصة"
    else -> "نوع غير معروف"
}

println(describeOrder("ORD-001"))
println(describeOrder(42))
println(describeOrder(listOf(1, 2, 3)))
println(describeOrder(7))
println(describeOrder("special"))
println(describeOrder(3.14))

معرف طلب: ORD-001
عدد صحيح: 42
قائمة بـ 3 عناصر
رقم في النطاق 1-10: 7
قيمة خاصة
نوع غير معروف

fun main() {
    println("Hello, Kotlin!")
}

Hello, Kotlin!

val name = "Alice"
var age = 30
fun greet(n: String): String = "Hello, $n!"
println(greet(name))

Hello, Alice!

data class User(val name: String, val age: Int)
val alice = User("Alice", 30)
println(alice)

User(name=Alice, age=30)