TrustChain

interface VerifiableBlock {
    val id: String
    val hash: String
    val previousHash: String?
}

@Serializable
data class DeltaBlock<P>(
    val patches: P,
    val previousHash: String,
    val newHash: String,
    val signature: String = ""
)

sealed interface ChainEvent<out B : VerifiableBlock, out P> {
    data class Push<B : VerifiableBlock>(val block: B) : ChainEvent<B, Nothing>
    data object Pop : ChainEvent<Nothing, Nothing>
    data class Replace<B : VerifiableBlock>(val block: B) : ChainEvent<B, Nothing>
    data class ApplyDeltas<P>(val blocks: List<DeltaBlock<P>>) : ChainEvent<Nothing, P>
}

val result: Result<TrustChain<MyBlock, MyPatch>> = chain.reduce(ChainEvent.Push(nextBlock))

enum class ChainAction {
    PUSH, POP, REPLACE, PATCH, IDLE
}

sealed class ChainError(message: String) : RuntimeException(message) {
    data class HashMismatch(val expected: String?, val actual: String?) : ChainError(...)
    data class SignatureVerificationFailed(val blockHash: String) : ChainError(...)
    class CannotPopEmptyChain : ChainError(...)
    data class UnsupportedDeltaOperation(val detail: String) : ChainError(...)
}

fun interface SignatureVerifier {
    fun verify(payload: String, signatureBase64: String): Boolean
}

fun interface BlockPatcher<B : P VerifiableBlock, in > {
    fun patch(block: B, patches: P, newHash: String): B
}

fun proceedToShipping(sessionId: String, address: String): CheckoutStep {
    val currentHash = sessionStore.getHash(sessionId) ?: error("Session expired")
    val content = "prev=$currentHash;step=shipping;addr=$address"
    val newHash = Sha256.digest(content)

    sessionStore.updateHash(sessionId, newHash)

    return CheckoutStep(
        id = "step_shipping",
        title = "Shipping & Address",
        hash = newHash,
        previousHash = currentHash
    )
}

fun applyPromo(sessionId: String, promoCode: String): DeltaBlock<Map<String, String>> {
    val currentHash = sessionStore.getHash(sessionId)
    val patches = mapOf("discount" to "10%", "total" to "$180")
    val newHash = Sha256.digest("$currentHash;promo=$promoCode")
    val signature = ServerKeyStore.sign(newHash) // RSA or Ed25519

    sessionStore.updateHash(sessionId, newHash)

    return DeltaBlock(
        patches = patches,
        previousHash = currentHash,
        newHash = newHash,
        signature = signature
    )
}

var chain = TrustChain<CheckoutStep, Map<String, String>>(
    strictMode = true,
    verifier = SignatureVerifier { payload, signatureBase64 ->
        // Verify with server's public key (RSA / Ed25519)
        CryptoEngine.verifySignature(publicKey, payload, signatureBase64)
    },
    patcher = { currentStep, patches, newHash ->
        currentStep.copy(
            state = currentStep.state + patches,
            hash = newHash
        )
    }
)

// 1. Push next screen
chain = chain.reduce(ChainEvent.Push(step1)).getOrThrow()

// 2. Apply signed deltas received from WebSocket / HTTP
val delta = receiveDeltaFromServer()
chain = chain.reduce(ChainEvent.ApplyDeltas(listOf(delta))).getOrThrow()

// 3. Pop back
if (chain.canPop) {
    chain = chain.reduce(ChainEvent.Pop).getOrThrow()
}

chain.reduce(ChainEvent.Push(untrustedBlock)).fold(
    onSuccess = { updatedChain ->
        chain = updatedChain
    },
    onFailure = { error ->
        when (error) {
            is ChainError.HashMismatch -> {
                logger.error("Tamper Alert: Hash link broken! Expected ${error.expected}, got ${error.actual}")
            }
            is ChainError.SignatureVerificationFailed -> {
                logger.error("Security Alert: Server signature invalid for hash ${error.blockHash}")
            }
            else -> logger.error("Chain error: ${error.message}")
        }
    }
)

kotlin {
    sourceSets {
        commonMain.dependencies {
            implementation("io.github.numq.trustchain:core:1.0.0")
        }
    }
}

data class Step(
    override val id: String,
    override val hash: String,
    override val previousHash: String? = null
) : VerifiableBlock

// Setup chain
val root = Step(id = "1", hash = "root_hash", previousHash = null)
val next = Step(id = "2", hash = "step_2_hash", previousHash = "root_hash")

var chain = TrustChain<Step, Unit>(strictMode = true)
chain = chain.reduce(ChainEvent.Push(root)).getOrThrow()
chain = chain.reduce(ChainEvent.Push(next)).getOrThrow()

println("Current active step: ${chain.current?.id}") // Prints: 2