data class CheckoutResult(
    val user: String, val cart: String, val promos: String,
    val stock: Boolean,
    val shipping: Double, val tax: Double,
    val payment: String,
)

val breaker = CircuitBreaker(maxFailures = 5, resetTimeout = 30.seconds)

coroutineScope {
    val dUser  = async { fetchUser() }
    val dCart  = async { fetchCart() }
    val dPromos = async {
        withTimeout(3.seconds) { fetchPromos() }
    }
    val user   = dUser.await()
    val cart    = dCart.await()
    val promos  = dPromos.await()

    // --- phase 2: validate stock (with retry) ---
    var stock = false
    var attempt = 0
    var delay = 100.milliseconds
    while (true) {
        try {
            stock = validateStock()
            break
        } catch (e: CancellationException) { throw e }
        catch (e: Exception) {
            if (++attempt >= 3) throw e
            delay(delay)
            delay *= 2
        }
    }

    // --- phase 3: shipping & tax in parallel ---
    val dShipping = async { calcShipping() }
    val dTax      = async { calcTax() }
    val shipping  = dShipping.await()
    val tax       = dTax.await()

    // --- phase 4: payment (with circuit breaker) ---
    val payment = if (!breaker.shouldAttempt()) {
        throw CircuitBreakerOpenException()
    } else {
        try {
            val p = withTimeout(5.seconds) { reservePayment() }
            breaker.recordSuccess()
            p
        } catch (e: CancellationException) { throw e }
        catch (e: Exception) {
            breaker.recordFailure()
            throw e
        }
    }

    CheckoutResult(user, cart, promos, stock, shipping, tax, payment)
}

@KapTypeSafe
data class CheckoutResult(
    val user: String, val cart: String, val promos: String,
    val stock: Boolean,
    val shipping: Double, val tax: Double,
    val payment: String,
)

import CheckoutResultKap.*

val retryPolicy = Schedule.exponential<Throwable>(100.milliseconds) and Schedule.times(3)
val breaker = CircuitBreaker(maxFailures = 5, resetTimeout = 30.seconds)

kap(::CheckoutResult)
    .with { user from fetchUser() }                                  // ┐
    .with { cart from fetchCart() }                                  // ├─ phase 1: parallel
    .with(promos from Kap { fetchPromos() }.timeout(3.seconds))      // ┘  + timeout on promos
    .then(stock from Kap { validateStock() }.retry(retryPolicy))     // ── phase 2: barrier + retry
    .with { shipping from calcShipping() }                           // ┐ phase 3: parallel
    .with { tax from calcTax() }                                     // ┘
    .then(payment from Kap { reservePayment() }                      // ── phase 4: barrier
        .withCircuitBreaker(breaker)                               //    + circuit breaker
        .timeout(5.seconds))
    .evalGraph()

@KapTypeSafe
data class Dashboard(val user: String, val feed: String, val notifications: Int)

kap(::Dashboard)
    .with { user from fetchUser() }              // ┐
    .with { feed from fetchFeed() }              // ├─ all three run in parallel
    .with { notifications from countUnread() }   // ┘
    .evalGraph()

@KapTypeSafe
data class ProfilePage(val user: String, val avatar: String, val recommendations: String)

kap(::ProfilePage)
    .with { user from fetchUser(id) }                         // ┐ parallel
    .with { avatar from fetchAvatar(id) }                     // ┘
    .then { recommendations from fetchRecommendations(user) } // waits for user, then fetches
    .evalGraph()

kap(::Dashboard)
    .with { user from fetchUser() }
    .with { feed from fetchFeed() }
    .with { notifications from countUnread() }
    .andThen { result ->
        // use result.user to decide what's next
        kap(::FullPage)
            .with { dashboard from result }
            .with { suggestions from fetchSuggestions(result.user) }
    }.evalGraph()

@KapTypeSafe
data class CheckoutResult(
    val user: String, val cart: String,
    val promos: String, val inventory: Boolean,
    val stock: Boolean,
    val shipping: Double, val tax: Double, val discounts: Double,
    val payment: String,
    val confirmation: String, val email: String,
)

kap(::CheckoutResult)
    .with { user from fetchUser() }               // ┐
    .with { cart from fetchCart() }               // ├─ phase 1: parallel
    .with { promos from fetchPromos() }           // │
    .with { inventory from fetchInventory() }     // ┘
    .then { stock from validateStock() }          // ── phase 2: barrier
    .with { shipping from calcShipping() }        // ┐
    .with { tax from calcTax() }                  // ├─ phase 3: parallel
    .with { discounts from calcDiscounts() }      // ┘
    .then { payment from reservePayment() }       // ── phase 4: barrier
    .with { confirmation from generateConfirmation() }  // ┐ phase 5
    .with { email from sendEmail() }              // ┘
    .evalGraph()

@KapTypeSafe
data class HomePage(val profile: String, val feed: Result<String>, val ads: Result<String>)

import HomePageKap.*

kap(::HomePage)
    .with { profile from fetchProfile() }              // critical — failure cancels everything
    .with(feed from settled { fetchFeed() })           // optional — failure returns Result.failure
    .with(ads from settled { fetchAds() })             // optional — failure returns Result.failure
    .evalGraph()
// Feed throws? Profile and ads still complete. You get Result.failure for feed.

val results = listOf("svc-a", "svc-b", "svc-c").traverseSettled { svc ->
    Kap { callService(svc) }
}.evalGraph()
// → [Success("ok"), Failure(TimeoutException), Success("ok")]

val price = raceN(
    Kap { pricingFromUS(item) },
    Kap { pricingFromEU(item) },
    Kap { pricingFromAsia(item) },
).evalGraph()  // fastest response wins, other two cancelled

val users = userIds.traverse(concurrency = 5) { id ->
    Kap { fetchUser(id) }
}.evalGraph()  // 100 users, 5 at a time, results in order

val data = Kap { fetchFromApi() }
    .timeoutRace(2.seconds, fallback = Kap { readFromCache() })
    .evalGraph()  // both start at t=0, API wins if fast enough, cache if not

val policy = Schedule.exponential<Throwable>(100.milliseconds)
    .jittered()                          // ±50% random spread (no thundering herd)
    .and(Schedule.times(3))              // max 3 attempts
    .withMaxDuration(10.seconds)         // total budget

Kap { callFlakyService() }.retry(policy).evalGraph()

@KapTypeSafe
data class Dashboard(val user: String, val latency: TimedResult<String>)

import DashboardKap.*

kap(::Dashboard)
    .with { user from fetchUser() }
    .with(latency from timed { fetchSlowService() })   // TimedResult(value, duration)
    .evalGraph()
// dashboard.latency.duration → 230.ms

val config = Kap { loadRemoteConfig() }.memoizeOnSuccess()

// call it from 10 coroutines — only one HTTP request, others wait for the cached result
// if it fails, next caller retries (failures are NOT cached)

@KapTypeSafe
data class DeveloperProfile(val user: GithubUser, val topRepos: List<GithubRepo>, val funFact: String)

val profile = kap(::DeveloperProfile)
    .with { user from client.get("https://api.github.com/users/kotlin").body() }
    .with { topRepos from client.get("https://api.github.com/users/kotlin/repos?sort=stars").body() }
    .with { funFact from client.get("https://catfact.ninja/fact").body<CatFact>().fact }
    .evalGraph()
// 3 HTTP calls in parallel, one result. See examples/real-world-http for the full example.

@KapTypeSafe
data class OrderResult(
    val finalPrice: Double,
    val reservationId: String,
    val paymentId: String,
    val notifications: List<Result<Unit>>,
)

import OrderResultKap.*

// Retry: exponential backoff (100ms, 200ms, 400ms) + jitter, max 3 attempts
val retryPolicy = Schedule.exponential<Throwable>(100.milliseconds).jittered() and Schedule.times(3)
// Circuit breaker: after 5 failures, stop calling payment for 30s
val paymentBreaker = CircuitBreaker(maxFailures = 5, resetTimeout = 30.seconds)

suspend fun placeOrder(input: OrderInput): Either<Nel<OrderError>, OrderResult> {

    // ── PHASE 1: Validate in parallel, collect ALL errors ────────
    val validated = kapV<OrderError, ValidAddress, ValidCard, ValidItems, ValidOrder>(::ValidOrder)
        .withV { validateAddress(input.address) }       // ┐ all three run at the same time
        .withV { validatePaymentInfo(input.card) }      // ├─ if address AND card fail,
        .withV { validateItems(input.items) }           // ┘ you get BOTH errors
        .evalGraph()

    val order = validated.getOrElse { return Either.Left(it) }

    // ── PHASES 2–5: inside DB transaction (rollback on any failure) ──
    return bracketCase(
        acquire = { db.beginTransaction() },
        use = { tx ->
            kap(::OrderResult)

                // PHASE 2: race 3 pricing providers — fastest wins, losers cancelled
                .with(finalPrice from raceN(
                    Kap { pricingServiceA(order) },
                    Kap { pricingServiceB(order) },
                    Kap { pricingServiceC(order) },
                ))

                // PHASE 3: reserve inventory — retry with backoff if flaky
                .then(reservationId from
                    Kap { reserveInventory(tx, order) }
                        .retry(retryPolicy)
                )

                // PHASE 4: charge payment — circuit breaker + 5s timeout
                .then(paymentId from
                    Kap { chargePayment(tx, order) }
                        .withCircuitBreaker(paymentBreaker)
                        .timeout(5.seconds)
                )

                // PHASE 5: notifications — if one fails, others still complete
                .with(notifications from listOf(
                    Kap { sendEmail(order) },
                    Kap { sendPush(order) },
                    Kap { updateAnalytics(order) },
                ).sequenceSettled())

                .map { Either.Right(it) }
        },
        release = { tx, exit -> when (exit) {
            is ExitCase.Completed -> tx.commit()      // success → commit
            else                  -> tx.rollback()    // failure or cancel → rollback
        }}
    ).evalGraph()
}

// Arrow types + KAP orchestration
val result: Either<Nel<OrderError>, OrderResult> =
    kapV<OrderError, ValidEmail, ValidAge, User>(::User)
        .withV { validateEmail(input) }    // returns Either<Nel<OrderError>, ValidEmail>
        .withV { validateAge(input) }      // returns Either<Nel<OrderError>, ValidAge>
        .evalGraph()
// Both run in parallel. Both errors collected. Arrow types, KAP execution.

// Ktor

get("/checkout/{id}") {
    val id = call.parameters["id"]!!
    val result = kap(::CheckoutResult)
        .with { user from userService.fetch(id) }
        .with { cart from cartService.fetch(id) }
        .with { promos from promoService.fetch(id) }
        .evalGraph()
    call.respond(result)
}

// Spring Boot

@RestController
class CheckoutController(val userService: UserService, val cartService: CartService) {

    @GetMapping("/checkout/{id}")
    suspend fun checkout(@PathVariable id: String): CheckoutResult =
        kap(::CheckoutResult)
            .with { user from userService.fetch(id) }
            .with { cart from cartService.fetch(id) }
            .with { promos from promoService.fetch(id) }
            .evalGraph()
}

// Android ViewModel
import HomeDataKap.*

class HomeViewModel : ViewModel() {
    val state = MutableStateFlow<HomeState>(Loading)

    fun load() = viewModelScope.launch {
        val home = kap(::HomeData)
            .with { profile from repo.fetchProfile() }
            .with(feed from settled { repo.fetchFeed() })
            .with { notifications from repo.countUnread() }
            .evalGraph()
        state.value = Ready(home)
    }
}

@KapTypeSafe
fun buildCheckout(
    user: String,
    cart: String,
    promos: String,
    stock: Boolean,
    shipping: Double,
    tax: Double,
    payment: String,
): Checkout = Checkout(
    user = user.trim(),                                  // normalize here…
    cart = cart,
    promos = promos.ifBlank { "NONE" },
    stock = stock,
    total = shipping + tax,                              // …or compute derived fields
    payment = payment,
)

kap(::buildCheckout)
    .with { user from fetchUser() }                        // ┐
    .with { cart from fetchCart() }                        // ├─ same IDE autocomplete
    .with { promos from fetchPromos() }                    // │   as the data-class form
    .then { stock from validateStock() }                   // ┘
    .with { shipping from calcShipping() }
    .with { tax from calcTax() }
    .then { payment from reservePayment() }
    .evalGraph()

plugins {
    id("com.google.devtools.ksp") // only needed for @KapTypeSafe
}

dependencies {
    implementation("io.github.damian-rafael-lattenero:kap-core:3.0.0")

    // optional — add any combination
    implementation("io.github.damian-rafael-lattenero:kap-resilience:3.0.0")
    implementation("io.github.damian-rafael-lattenero:kap-arrow:3.0.0")
    implementation("io.github.damian-rafael-lattenero:kap-ksp-annotations:3.0.0")
    ksp("io.github.damian-rafael-lattenero:kap-ksp:3.0.0")
}