REST API Integration with Kotlin and Coroutines

interface OrderApi {
    @GET("orders/{id}") suspend fun order(@Path("id") id: String): OrderDto
    @GET("shipments/{orderId}") suspend fun shipment(@Path("orderId") id: String): ShipmentDto
    @GET("recommendations") suspend fun recommendations(@Query("orderId") id: String): List<ProductDto>
}

@Serializable data class OrderDto(val id: String, val total_paise: Long, val placed_at: String)
@Serializable data class ShipmentDto(val status: String, val eta: String? = null)
@Serializable data class ProductDto(val id: String, val name: String)

enum class ShipmentStatus { PACKED, SHIPPED, OUT_FOR_DELIVERY, DELIVERED, UNKNOWN }

data class OrderDetails(
    val orderId: String,
    val totalPaise: Long,
    val placedAt: Instant,
    val status: ShipmentStatus,
    val eta: LocalDate?,
    val recommendations: List<Product>,
)

fun ShipmentDto.statusEnum() = runCatching { ShipmentStatus.valueOf(status) }.getOrDefault(ShipmentStatus.UNKNOWN)

class OrderRepository(private val api: OrderApi) {

    suspend fun details(orderId: String): OrderDetails = coroutineScope {
        val order = async { retryIo { api.order(orderId) } }
        val shipment = async { retryIo { api.shipment(orderId) } }
        // Optional: failure shouldn't cancel siblings or fail the whole call
        val recs = async {
            runCatching { withTimeout(3_000) { api.recommendations(orderId) } }
                .getOrDefault(emptyList())
        }

        val o = order.await()
        val s = shipment.await()
        OrderDetails(
            orderId = o.id,
            totalPaise = o.total_paise,
            placedAt = Instant.parse(o.placed_at),
            status = s.statusEnum(),
            eta = s.eta?.let(LocalDate::parse),
            recommendations = recs.await().map { Product(it.id, it.name) },
        )
    }
}

/** Retries transient I/O failures with exponential backoff; rethrows the last error. */
suspend fun <T> retryIo(times: Int = 3, initialDelay: Long = 400, block: suspend () -> T): T {
    var delayMs = initialDelay
    repeat(times - 1) {
        try { return block() } catch (e: IOException) { delay(delayMs); delayMs *= 2 }
    }
    return block()
}

sealed interface OrderUiState {
    data object Loading : OrderUiState
    data class Content(val details: OrderDetails) : OrderUiState
    data class Error(val message: String) : OrderUiState
}

class OrderViewModel(private val repo: OrderRepository, savedState: SavedStateHandle) : ViewModel() {
    private val orderId: String = checkNotNull(savedState["orderId"])
    private val _state = MutableStateFlow<OrderUiState>(OrderUiState.Loading)
    val state = _state.asStateFlow()

    init { load() }

    fun load() = viewModelScope.launch {
        _state.value = OrderUiState.Loading
        _state.value = try {
            OrderUiState.Content(repo.details(orderId))
        } catch (e: IOException) {
            OrderUiState.Error("You're offline. Pull to retry.")
        } catch (e: HttpException) {
            OrderUiState.Error(if (e.code() == 404) "Order not found." else "Something went wrong (${e.code()}).")
        }
    }
}

@Test
fun `recommendations failure does not fail details`() = runTest {
    val api = object : OrderApi {
        override suspend fun order(id: String) = OrderDto(id, 129_900, "2026-10-01T10:00:00Z")
        override suspend fun shipment(id: String) = ShipmentDto("SHIPPED", "2026-10-03")
        override suspend fun recommendations(id: String): List<ProductDto> = throw IOException("down")
    }
    val details = OrderRepository(api).details("A1")
    assertEquals(ShipmentStatus.SHIPPED, details.status)
    assertTrue(details.recommendations.isEmpty())
}