Guess the Number

import kotlin.random.Random

class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent {
            MiniTheme {
                MiniScreen(stringResource(R.string.screen_title)) {
                    GuessNumberScreen()
                }
            }
        }
    }
}

@Composable
private fun GuessNumberScreen() {
    // The initializer runs for a new game screen, not on every recomposition.
    var secret by rememberSaveable { mutableIntStateOf(Random.nextInt(1, 101)) }
    var input by rememberSaveable { mutableStateOf("") }
    var attempts by rememberSaveable { mutableIntStateOf(0) }
    var feedbackName by rememberSaveable { mutableStateOf(GuessFeedback.READY.name) }
    var finished by rememberSaveable { mutableStateOf(false) }
    val feedback = GuessFeedback.valueOf(feedbackName)

    fun submitGuess() {

/** Pure rule: invalid input never consumes an attempt. */
fun evaluateGuess(input: String, secret: Int): GuessFeedback {
    require(secret in 1..100)
    val guess = input.trim().toIntOrNull()
    return when {
        guess == null || guess !in 1..100 -> GuessFeedback.INVALID
        guess < secret -> GuessFeedback.TOO_LOW
        guess > secret -> GuessFeedback.TOO_HIGH
        else -> GuessFeedback.CORRECT
    }
}

fun GuessFeedback.countsAsAttempt(): Boolean =
    this == GuessFeedback.TOO_LOW || this == GuessFeedback.TOO_HIGH ||
        this == GuessFeedback.CORRECT

private fun GuessNumberScreen() {
    // The initializer runs for a new game screen, not on every recomposition.
    var secret by rememberSaveable { mutableIntStateOf(Random.nextInt(1, 101)) }
    var input by rememberSaveable { mutableStateOf("") }
    var attempts by rememberSaveable { mutableIntStateOf(0) }
    var feedbackName by rememberSaveable { mutableStateOf(GuessFeedback.READY.name) }
    var finished by rememberSaveable { mutableStateOf(false) }
    val feedback = GuessFeedback.valueOf(feedbackName)

    fun submitGuess() {
        if (finished) return
        val outcome = evaluateGuess(input, secret)
        feedbackName = outcome.name
        if (outcome.countsAsAttempt()) attempts += 1
        finished = outcome == GuessFeedback.CORRECT
    }

    Text(stringResource(R.string.instructions))
    OutlinedTextField(
        value = input,
        onValueChange = {
            input = it
            feedbackName = GuessFeedback.READY.name
        },
        label = { Text(stringResource(R.string.guess_label)) },
        isError = feedback == GuessFeedback.INVALID,

    val feedback = GuessFeedback.valueOf(feedbackName)

    fun submitGuess() {
        if (finished) return
        val outcome = evaluateGuess(input, secret)
        feedbackName = outcome.name
        if (outcome.countsAsAttempt()) attempts += 1
        finished = outcome == GuessFeedback.CORRECT
    }

    Text(stringResource(R.string.instructions))
    OutlinedTextField(
        value = input,
        onValueChange = {
            input = it
            feedbackName = GuessFeedback.READY.name
        },
        label = { Text(stringResource(R.string.guess_label)) },
        isError = feedback == GuessFeedback.INVALID,
        enabled = !finished,
        singleLine = true,
        keyboardOptions = KeyboardOptions(
            keyboardType = KeyboardType.Number,
            imeAction = ImeAction.Done
        ),
        keyboardActions = KeyboardActions(onDone = { submitGuess() }),

    ) { Text(stringResource(R.string.check_guess)) }

    val feedbackText = stringResource(
        when (feedback) {
            GuessFeedback.READY -> R.string.feedback_ready
            GuessFeedback.INVALID -> R.string.feedback_invalid
            GuessFeedback.TOO_LOW -> R.string.feedback_low
            GuessFeedback.TOO_HIGH -> R.string.feedback_high
            GuessFeedback.CORRECT -> R.string.feedback_correct
        }
    )
    Text(
        text = feedbackText,
        color = if (feedback == GuessFeedback.INVALID) MaterialTheme.colorScheme.error
            else MaterialTheme.colorScheme.onSurface,
        modifier = Modifier.semantics { liveRegion = LiveRegionMode.Polite }
    )
    Text(stringResource(R.string.attempts, attempts))
    OutlinedButton(
        onClick = {
            secret = Random.nextInt(1, 101)
            input = ""
            attempts = 0
            feedbackName = GuessFeedback.READY.name
            finished = false
        },

    OutlinedButton(
        onClick = {
            secret = Random.nextInt(1, 101)
            input = ""
            attempts = 0
            feedbackName = GuessFeedback.READY.name
            finished = false
        },
        modifier = Modifier.fillMaxWidth()
    ) { Text(stringResource(R.string.new_game)) }
}

class GuessRulesTest {
    @Test fun invalidGuessesDoNotCount() {
        listOf("", "abc", "0", "101", "1.5", "99999999999999999999").forEach {
            val result = evaluateGuess(it, secret = 50)
            assertEquals(GuessFeedback.INVALID, result)
            assertFalse(result.countsAsAttempt())
        }
    }

    @Test fun validGuessesGiveDirectionalFeedbackAndCount() {
        assertEquals(GuessFeedback.TOO_LOW, evaluateGuess("1", 50))
        assertEquals(GuessFeedback.TOO_HIGH, evaluateGuess("100", 50))
        assertEquals(GuessFeedback.CORRECT, evaluateGuess(" 50 ", 50))
        assertTrue(evaluateGuess("50", 50).countsAsAttempt())
    }

    @Test fun secretCanUseBothEndpoints() {
        assertEquals(GuessFeedback.CORRECT, evaluateGuess("1", 1))
        assertEquals(GuessFeedback.CORRECT, evaluateGuess("100", 100))
    }
}