kotlin {
    applyDefaultHierarchyTemplate()   // enabled by default in KGP 1.9.20+

    androidTarget()
    iosArm64()
    iosX64()
    iosSimulatorArm64()
    jvm()
}

kotlin {
    applyDefaultHierarchyTemplate()

    sourceSets {
        val jvmAndAndroid by creating {
            dependsOn(commonMain.get())
        }
        androidMain.get().dependsOn(jvmAndAndroid)
        jvmMain.get().dependsOn(jvmAndAndroid)
    }
}

// shared/domain/src/commonMain/kotlin/com/example/shared/domain/model/

// Shared kernel: types used across multiple bounded contexts
data class UserId(val value: String)
data class Money(val amount: Long, val currency: Currency)
enum class Currency { USD, EUR, CVE }

// shared/domain/src/commonMain/kotlin/com/example/shared/domain/model/

@JvmInline
value class Email(val value: String) {
    init {
        require(value.matches(EMAIL_REGEX)) { "Invalid email: $value" }
    }

    companion object {
        private val EMAIL_REGEX = Regex("^[A-Za-z0-9+_.-]+@[A-Za-z0-9.-]+$")
    }
}

@JvmInline
value class OrderId(val value: String) {
    init {
        require(value.isNotBlank()) { "OrderId must not be blank" }
    }
}

@JvmInline
value class ProductId(val value: String)

data class Money(
    val amount: Long,          // Store in minor units (cents) to avoid floating point
    val currency: Currency,
) {
    init {
        require(amount >= 0) { "Money amount must be non-negative" }
    }

    operator fun plus(other: Money): Money {
        require(currency == other.currency) { "Cannot add different currencies" }
        return copy(amount = amount + other.amount)
    }

    operator fun times(quantity: Int): Money =
        copy(amount = amount * quantity)
}

data class Address(
    val street: String,
    val city: String,
    val postalCode: String,
    val country: String,
) {
    init {
        require(street.isNotBlank()) { "Street must not be blank" }
        require(city.isNotBlank()) { "City must not be blank" }
    }
}

data class Order private constructor(
    val id: OrderId,
    val customerId: UserId,          // Reference other aggregates by ID only
    val items: List<OrderItem>,
    val status: OrderStatus,
    val createdAt: Long,
) {
    val total: Money
        get() = items.fold(Money(0, Currency.USD)) { acc, item ->
            acc + item.lineTotal
        }

    // Behavior method -- NOT a setter
    fun addItem(productId: ProductId, unitPrice: Money, quantity: Int): Order {
        require(status == OrderStatus.DRAFT) { "Cannot add items to a ${status.name} order" }
        require(quantity > 0) { "Quantity must be positive" }
        val newItem = OrderItem(productId, unitPrice, quantity)
        return copy(items = items + newItem)
    }

    fun submit(): Order {
        require(status == OrderStatus.DRAFT) { "Can only submit DRAFT orders" }
        require(items.isNotEmpty()) { "Cannot submit an empty order" }
        return copy(status = OrderStatus.SUBMITTED)
    }

    companion object {
        fun create(id: OrderId, customerId: UserId): Order = Order(
            id = id,
            customerId = customerId,
            items = emptyList(),
            status = OrderStatus.DRAFT,
            createdAt = currentTimeMillis(),
        )
    }
}

// CORRECT: reference by ID
data class Order(
    val id: OrderId,
    val customerId: UserId,      // ID reference, not User object
    val items: List<OrderItem>,
)

// WRONG: direct object reference creates tight coupling
data class Order(
    val id: OrderId,
    val customer: User,          // Do NOT hold the full User aggregate
    val items: List<OrderItem>,
)

// shared/domain/src/commonMain/kotlin/com/example/shared/domain/repository/
interface OrderRepository {
    fun getById(id: OrderId): Flow<Order?>
    fun getActiveOrders(customerId: UserId): Flow<List<Order>>
    suspend fun save(order: Order)
    suspend fun delete(id: OrderId)
}

// shared/data/src/commonMain/kotlin/com/example/shared/data/repository/
class OrderRepositoryImpl(
    private val db: AppDatabase,
    private val api: OrderApi,
    private val dispatchers: CoroutineDispatchers,
) : OrderRepository {

    override fun getById(id: OrderId): Flow<Order?> =
        db.orderQueries.getById(id.value)
            .asFlow()
            .mapToOneOrNull(dispatchers.io)
            .map { it?.toDomain() }

    override fun getActiveOrders(customerId: UserId): Flow<List<Order>> =
        db.orderQueries.getActiveByCustomer(customerId.value)
            .asFlow()
            .mapToList(dispatchers.io)
            .map { entities -> entities.map { it.toDomain() } }

    override suspend fun save(order: Order) = withContext(dispatchers.io) {
        db.transaction {
            db.orderQueries.upsert(order.toEntity())
            order.items.forEach { item ->
                db.orderItemQueries.upsert(item.toEntity(order.id))
            }
        }
    }
}

// shared/domain/src/commonMain/kotlin/com/example/shared/domain/event/

sealed interface DomainEvent {
    val occurredAt: Long
}

data class OrderSubmitted(
    val orderId: OrderId,
    val customerId: UserId,
    val total: Money,
    override val occurredAt: Long = currentTimeMillis(),
) : DomainEvent

data class PaymentCompleted(
    val orderId: OrderId,
    val transactionId: String,
    override val occurredAt: Long = currentTimeMillis(),
) : DomainEvent

// shared/domain/src/commonMain/kotlin/com/example/shared/domain/event/

interface EventBus {
    val events: SharedFlow<DomainEvent>
    suspend fun publish(event: DomainEvent)
}

class InMemoryEventBus : EventBus {
    private val _events = MutableSharedFlow<DomainEvent>(
        replay = 0,
        extraBufferCapacity = 64,
        onBufferOverflow = BufferOverflow.DROP_OLDEST,
    )
    override val events: SharedFlow<DomainEvent> = _events.asSharedFlow()

    override suspend fun publish(event: DomainEvent) {
        _events.emit(event)
    }
}

// features/orders -- publishes OrderSubmitted
class SubmitOrderUseCase(
    private val orderRepo: OrderRepository,
    private val eventBus: EventBus,
) {
    suspend operator fun invoke(orderId: OrderId) {
        val order = orderRepo.getById(orderId).first()
            ?: throw IllegalArgumentException("Order not found")
        val submitted = order.submit()
        orderRepo.save(submitted)
        eventBus.publish(OrderSubmitted(submitted.id, submitted.customerId, submitted.total))
    }
}

// features/payments -- listens for OrderSubmitted
class PaymentFeatureInitializer(
    private val eventBus: EventBus,
    private val scope: CoroutineScope,
) {
    fun start() {
        scope.launch {
            eventBus.events
                .filterIsInstance<OrderSubmitted>()
                .collect { event -> initiatePayment(event.orderId, event.total) }
        }
    }
}