Kotlin: شرح الوراثة والواجهات في كوتلن

// جافا: توثيق override اختياري - تجاوز صامت ممكن
class SpecialOrder extends Order {
    double calculateTotal() { ... }  // يتجاوز بصمت!
}

// كوتلن: override إلزامي - المُترجِم يلتقط الأخطاء
open class Order {
    open fun calculateTotal(): Double = ...
}
class SpecialOrder : Order() {
    override fun calculateTotal(): Double = ...  // يجب إعلان override
}

// افتراضي: الفئة نهائية (لا يمكن توارثها)
class Order(val id: String)  // لا يمكن توسيعها

// open: السماح بالوراثة صراحةً
open class Order(val id: String) {
    // الطرق أيضًا نهائية بشكل افتراضي
    fun process() { }  // لا يمكن تجاوزها

    // طريقة مفتوحة: السماح بالتجاوز صراحةً
    open fun calculateTotal(): Double = 0.0
}

// abstract: يجب توارثها، لا يمكن استنساخها
abstract class BaseOrder(val id: String) {
    // طريقة مجردة: يجب تنفيذها من الفئة الفرعية
    abstract fun calculateTotal(): Double

    // طريقة ملموسة في فئة مجردة
    fun getId(): String = id
}

interface Discountable {
    // طريقة مجردة
    fun discountRate(): Double

    // تطبيق افتراضي
    fun applyDiscount(total: Double): Double {
        return total * (1.0 - discountRate())
    }
}

interface Trackable {
    val trackingCode: String?  // خاصية مجردة

    fun track(): String = trackingCode?.let { "Tracking: $it" } ?: "Not shipped"
}

// تنفيذ واجهات متعددة
class PremiumOrder(
    val id: String,
    val total: Double,
    override val trackingCode: String?
) : Discountable, Trackable {
    override fun discountRate() = 0.15  // خصم 15%
}

open class Order(val id: String, var status: String) {
    open fun summary(): String = "Order $id: $status"
}

class BulkOrder(id: String, status: String, val minQuantity: Int) : Order(id, status) {
    // يجب استخدام كلمة override
    override fun summary(): String = "Bulk $id: $status (min: $minQuantity)"
}

open class Order {
    open fun process() { }
}

class SpecialOrder : Order() {
    // منع التجاوز الإضافي في الفئات الفرعية
    final override fun process() { }
}

interface A {
    fun hello() = "A"
}

interface B {
    fun hello() = "B"
}

// معين: C يرث hello() من كل من A وB
class C : A, B {
    // يجب تجاوز لحل التعارض
    override fun hello(): String {
        // اختيار تطبيق الوالد صراحةً
        return super<A>.hello()  // اختيار تطبيق A
    }
}

class D : A, B {
    override fun hello(): String {
        // استراتيجية 1: اختيار والد واحد
        return super<B>.hello()

        // استراتيجية 2: دمج كليهما
        // return "${super<A>.hello()} + ${super<B>.hello()}"

        // استراتيجية 3: تطبيق مخصص
        // return "D"
    }
}

// ============================================
// OrderProcessor - هرمية الوراثة
// الميزة: Order / BulkOrder / PriorityOrder
// ============================================

interface Discountable {
    fun discountRate(): Double
    fun applyDiscount(total: Double): Double = total * (1.0 - discountRate())
}

interface Trackable {
    val trackingCode: String?
    fun track(): String = trackingCode?.let { "Tracking: $it" } ?: "Not shipped yet"
}

open class Order(val id: String, var status: String, val total: Double) {
    init {
        require(total >= 0) { "Total must be non-negative" }
    }

    open fun summary(): String = "Order $id | \$$total USD | $status"
    open fun calculateFinal(): Double = total
}

class BulkOrder(
    id: String,
    status: String,
    total: Double,
    val minQuantity: Int
) : Order(id, status, total), Discountable {

    override fun discountRate() = 0.10  // خصم جملة 10%

    override fun calculateFinal(): Double = applyDiscount(total)

    override fun summary(): String =
        "${super.summary()} | Bulk (min: $minQuantity) | Final: \$${calculateFinal()} USD"
}

class PriorityOrder(
    id: String,
    status: String,
    total: Double,
    val priority: String,
    override val trackingCode: String?
) : Order(id, status, total), Discountable, Trackable {

    override fun discountRate() = when (priority) {
        "VIP" -> 0.20
        "GOLD" -> 0.15
        else -> 0.05
    }

    override fun calculateFinal(): Double = applyDiscount(total)

    override fun summary(): String =
        "${super.summary()} | Priority: $priority | ${track()} | Final: \$${calculateFinal()} USD"
}

fun main() {
    val orders = listOf(
        Order("ORD-001", "CONFIRMED", 299.99),
        BulkOrder("ORD-002", "CONFIRMED", 5_000.00, 100),
        PriorityOrder("ORD-003", "SHIPPED", 15_000.00, "VIP", "TRK-XYZ789"),
        PriorityOrder("ORD-004", "PENDING", 2_500.00, "GOLD", null)
    )

    println("=== Order Summary ===")
    orders.forEach { println(it.summary()) }

    val totalSavings = orders
        .filterIsInstance<Discountable>()
        .sumOf { it.applyDiscount((it as Order).total) - (it as Order).calculateFinal() }

    println("\nTotal savings from discounts: \$$totalSavings USD")
}

=== Order Summary ===
Order ORD-001 | $299.99 USD | CONFIRMED
Order ORD-002 | $5000.0 USD | CONFIRMED | Bulk (min: 100) | Final: $4500.0 USD
Order ORD-003 | $15000.0 USD | SHIPPED | Priority: VIP | Tracking: TRK-XYZ789 | Final: $12000.0 USD
Order ORD-004 | $2500.0 USD | PENDING | Priority: GOLD | Not shipped yet | Final: $2125.0 USD

Total savings from discounts: $3475.0 USD

// فئة أساسية - يجب أن تكون open لتكون قابلة للوراثة
open class Animal(val name: String, val sound: String) {
    open fun makeSound(): String = "$name says $sound!"

    fun describe(): String = "This is $name, a $sound maker"
}

// فئة فرعية
class Dog(name: String) : Animal(name, "Woof")

class Cat(name: String) : Animal(name, "Meow")

val dog = Dog("Buddy")
val cat = Cat("Whiskers")

println(dog.makeSound())
println(cat.makeSound())
println(dog.describe())

Buddy says Woof!
Whiskers says Meow!
This is Buddy, a Woof maker

open class Shape(val name: String) {
    open fun area(): Double = 0.0
    open fun describe(): String = "$name: area=${area()}"
}

class Circle(name: String, val radius: Double) : Shape(name) {
    override fun area(): Double = Math.PI * radius * radius
    override fun describe(): String = "${super.describe()} (radius=$radius)"
}

class Rectangle(name: String, val width: Double, val height: Double) : Shape(name) {
    override fun area(): Double = width * height
}

val circle = Circle("C1", 5.0)
val rect = Rectangle("R1", 4.0, 6.0)

println(circle.describe())
println("${rect.name}: area=${rect.area()}")

C1: area=78.53981633974483 (radius=5.0)
R1: area=24.0

abstract class Payment(val amount: Double) {
    abstract fun process(): Boolean
    abstract fun describe(): String

    fun receipt(): String = "Receipt: ${describe()} - \$$amount USD"
}

class CreditPayment(amount: Double, val cardNumber: String) : Payment(amount) {
    override fun process(): Boolean {
        println("Processing credit card payment...")
        return true
    }

    override fun describe(): String = "Credit card ending ${cardNumber.takeLast(4)}"
}

class BankTransfer(amount: Double, val account: String) : Payment(amount) {
    override fun process(): Boolean {
        println("Processing bank transfer...")
        return true
    }

    override fun describe(): String = "Bank transfer to $account"
}

val cc = CreditPayment(299.99, "1234567890123456")
val bt = BankTransfer(1500.00, "ACC-987654")

println(cc.receipt())
println("Success: ${cc.process()}")
println()
println(bt.receipt())
println("Success: ${bt.process()}")

Receipt: Credit card ending 3456 - $299.99 USD
Processing credit card payment...
Success: true

Receipt: Bank transfer to ACC-987654 - $1500.0 USD
Processing bank transfer...
Success: true

interface Printable {
    fun print(): String
}

interface Loggable {
    fun log(): String
}

interface Serializable {
    fun serialize(): String
}

// فئة تنفذ عدة واجهات
class User(val name: String, val email: String) : Printable, Loggable, Serializable {
    override fun print(): String = "User: $name ($email)"
    override fun log(): String = "[LOG] User $name accessed"
    override fun serialize(): String = """{"name":"$name","email":"$email"}"""
}

val user = User("Alice", "alice@example.com")
println(user.print())
println(user.log())
println(user.serialize())

// واجهة مع تطبيق افتراضي
interface Greetable {
    fun greet(): String = "Hello!"  // تطبيق افتراضي
}

class FriendlyUser(name: String) : Greetable {
    // يستخدم التطبيق الافتراضي
    override fun greet(): String = "Hi, I'm $name!"  // override اختياري
}

User: Alice (alice@example.com)
[LOG] User Alice accessed
{"name":"Alice","email":"alice@example.com"}

// abstract class: يمكن أن يكون له حالة (خصائص مخزنة)
abstract class Vehicle(val maxSpeed: Double) {
    var currentSpeed: Double = 0.0

    abstract fun start()

    fun stop() {
        currentSpeed = 0.0
        println("Vehicle stopped")
    }

    fun status() = "Speed: $currentSpeed / $maxSpeed km/h"
}

// interface: فقط عقود (منذ Kotlin 1.8 يمكن أن يكون لها تطبيقات افتراضية)
interface Electric {
    val batteryLevel: Int  // خاصية مجردة
    fun charge() {
        println("Charging...")
    }
}

class Tesla(val model: String) : Vehicle(250.0), Electric {
    override var batteryLevel: Int = 100

    override fun start() {
        currentSpeed = 30.0
        println("$model started silently")
    }

    override fun charge() {
        batteryLevel = 100
        println("$model charged to 100%")
    }
}

val myCar = Tesla("Model 3")
myCar.start()
println(myCar.status())
println("Battery: ${myCar.batteryLevel}%")
myCar.stop()
myCar.charge()

Model 3 started silently
Speed: 30.0 / 250.0 km/h
Battery: 100%
Vehicle stopped
Model 3 charged to 100%

open class Animal2 {
    open fun sound() = "Generic sound"
}

class Dog2 : Animal2() {
    override fun sound() = "Woof"
    fun fetch() = "Fetching!"
}

class Cat2 : Animal2() {
    override fun sound() = "Meow"
}

// دالة تقبل Animal2 وتستخدم السلوك الديناميكي
fun interact(animal: Animal2) {
    println("${animal.sound()}")

    // فحص النوع وتحويل آمن
    if (animal is Dog2) {
        println("Dog detected: ${animal.fetch()}")
    } else if (animal is Cat2) {
        println("Cat detected")
    }
}

val animals: List<Animal2> = listOf(Dog2(), Cat2(), Dog2())
animals.forEach { interact(it) }

// smart cast داخل if
val animal: Animal2 = Dog2()
if (animal is Dog2) {
    // animal أصبح Dog2 تلقائيًا
    println("Fetch: ${animal.fetch()}")
}

Woof
Dog detected: Fetching!
Meow
Cat detected
Woof
Dog detected: Fetching!
Fetch: Fetching!

// الفئة العليا: قابل للمقارنة
abstract class ComparableEntity<T : ComparableEntity<T>>(val id: String) : Comparable<T> {
    override fun compareTo(other: T): Int = this.id.compareTo(other.id)
}

class UserEntity(id: String, val name: String) : ComparableEntity<UserEntity>(id)

class OrderEntity(id: String, val total: Double) : ComparableEntity<OrderEntity>(id)

val users = listOf(
    UserEntity("U003", "Charlie"),
    UserEntity("U001", "Alice"),
    UserEntity("U002", "Bob")
)

val orders = listOf(
    OrderEntity("O002", 1500.0),
    OrderEntity("O001", 299.99)
)

// sorted يستخدم compareTo
val sortedUsers = users.sorted()
val sortedOrders = orders.sorted()

println("Sorted users:")
sortedUsers.forEach { println("  ${it.id}: ${it.name}") }

println("\nSorted orders:")
sortedOrders.forEach { println("  ${it.id}: \$${it.total} USD") }

Sorted users:
  U001: Alice
  U002: Bob
  U003: Charlie

Sorted orders:
  O001: $299.99 USD
  O002: $1500.0 USD