State management,
crystallized.

@Serializable                       // opt-in: survives process death
data class SearchViewState(
    val query: String = "",
    @Transient val results: List<Project> = emptyList(),
    @Transient val isLoading: Boolean = false,
) : ViewState

sealed interface SearchIntent : ViewIntent {
    data class UpdateQuery(val query: String) : SearchIntent
    data object TriggerSearch : SearchIntent
}

sealed interface SearchSideEffect : SideEffect {
    data class ShowToast(val message: String) : SearchSideEffect
}

class SearchProcessor(
    private val searchUseCase: SearchUseCase,
) : PresentationProcessor<SearchIntent, SearchViewState, SearchSideEffect>(
    SearchViewState()
) {
    override suspend fun map(intent: SearchIntent) =
        when (intent) {
            is UpdateQuery -> reduce { copy(query = intent.query) }

            TriggerSearch -> composite(
                reduce { copy(isLoading = true) },
                async(cancellationKey = "search") {   // same key ⇒ restarts
                    val result = searchUseCase.execute(state.query)
                    reduce { copy(results = result, isLoading = false) }
                },
            )
        }   // sealed + exhaustive: a new intent won't compile unhandled
}

beforeSpec { Dispatchers.setMain(UnconfinedTestDispatcher()) }

it("updates the query") {
    // Under the test dispatcher, dispatch is synchronous.
    val processor = SearchProcessor(FakeSearchUseCase())
    processor.dispatch(UpdateQuery("kotlin"))
    processor.state.query shouldBe "kotlin"
}

it("keeps processing after a use case throws") {
    // Guarantee 04: errors never kill the intent loop.
    val processor = SearchProcessor(FailingSearchUseCase())
    processor.dispatch(TriggerSearch)
    processor.dispatch(UpdateQuery("still alive"))
    processor.state.query shouldBe "still alive"
}