Tip and Bill Splitter

package com.mastercoding.miniprojects.tips

sealed interface SplitResult {
    data class Success(val tip: Double, val total: Double, val perPerson: Double) : SplitResult
    data class Error(val message: String) : SplitResult
}

fun calculateSplit(billText: String, peopleText: String, tipPercent: Int): SplitResult {
    val bill = billText.trim().toDoubleOrNull()
    if (bill == null || !bill.isFinite() || bill < 0.0) {
        return SplitResult.Error("Enter a finite bill amount of zero or more.")
    }
    val people = peopleText.trim().toIntOrNull()
    if (people == null || people <= 0) {
        return SplitResult.Error("People must be a positive whole number.")
    }
    if (tipPercent !in 0..100) {
        return SplitResult.Error("Tip must be between 0 and 100 percent.")
    }
    val tip = bill * (tipPercent / 100.0)
    val total = bill + tip
    if (!tip.isFinite() || !total.isFinite()) {
        return SplitResult.Error("This amount is too large to calculate. Try a smaller bill.")
    }
    return SplitResult.Success(tip, total, total / people)
}

}

fun calculateSplit(billText: String, peopleText: String, tipPercent: Int): SplitResult {
    val bill = billText.trim().toDoubleOrNull()
    if (bill == null || !bill.isFinite() || bill < 0.0) {
        return SplitResult.Error("Enter a finite bill amount of zero or more.")
    }
    val people = peopleText.trim().toIntOrNull()
    if (people == null || people <= 0) {
        return SplitResult.Error("People must be a positive whole number.")
    }
    if (tipPercent !in 0..100) {
        return SplitResult.Error("Tip must be between 0 and 100 percent.")
    }
    val tip = bill * (tipPercent / 100.0)
    val total = bill + tip
    if (!tip.isFinite() || !total.isFinite()) {
        return SplitResult.Error("This amount is too large to calculate. Try a smaller bill.")
    }
    return SplitResult.Success(tip, total, total / people)
}

        return SplitResult.Error("Tip must be between 0 and 100 percent.")
    }
    val tip = bill * (tipPercent / 100.0)
    val total = bill + tip
    if (!tip.isFinite() || !total.isFinite()) {
        return SplitResult.Error("This amount is too large to calculate. Try a smaller bill.")
    }
    return SplitResult.Success(tip, total, total / people)
}

@Composable
fun TipSplitter() {
    var bill by rememberSaveable { mutableStateOf("") }
    var people by rememberSaveable { mutableStateOf("1") }
    var tipPercent by rememberSaveable { mutableIntStateOf(15) }
    val result = calculateSplit(bill, people, tipPercent)

    Text("Enter a bill in US dollars. Results update whenever an input changes.")
    OutlinedTextField(
        value = bill,
        onValueChange = { bill = it },
        label = { Text("Bill amount (USD)") },
        supportingText = { Text("Use a dot for decimals, for example 42.50.") },
        keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Decimal),
        singleLine = true,
        modifier = Modifier.fillMaxWidth()
    )
    OutlinedTextField(
        value = people,
        onValueChange = { people = it },
        label = { Text("Number of people") },
        keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Number),
        singleLine = true,
        modifier = Modifier.fillMaxWidth()
    )
    Text("Tip percentage", style = MaterialTheme.typography.titleMedium)

        horizontalArrangement = Arrangement.SpaceBetween
    ) {
        listOf(0, 10, 15, 20).forEach { percentage ->
            FilterChip(
                selected = tipPercent == percentage,
                onClick = { tipPercent = percentage },
                label = { Text("$percentage%") }
            )
        }
    }
    when (result) {
        is SplitResult.Error -> Text(result.message, color = MaterialTheme.colorScheme.error)
        is SplitResult.Success -> Card(modifier = Modifier.fillMaxWidth()) {
            Column(
                modifier = Modifier.padding(20.dp),
                verticalArrangement = Arrangement.spacedBy(8.dp)
            ) {
                Text("Tip: ${money(result.tip)}")
                Text("Total: ${money(result.total)}")
                Text("Each person: ${money(result.perPerson)}", style = MaterialTheme.typography.titleLarge)
            }
        }
    }
    Text("Amounts are rounded for display. Equal displayed shares can differ from the total by a few cents.")
}

        }
    }
    when (result) {
        is SplitResult.Error -> Text(result.message, color = MaterialTheme.colorScheme.error)
        is SplitResult.Success -> Card(modifier = Modifier.fillMaxWidth()) {
            Column(
                modifier = Modifier.padding(20.dp),
                verticalArrangement = Arrangement.spacedBy(8.dp)
            ) {
                Text("Tip: ${money(result.tip)}")
                Text("Total: ${money(result.total)}")
                Text("Each person: ${money(result.perPerson)}", style = MaterialTheme.typography.titleLarge)
            }
        }
    }
    Text("Amounts are rounded for display. Equal displayed shares can differ from the total by a few cents.")
}

private fun money(amount: Double): String =
    NumberFormat.getCurrencyInstance(Locale.US).format(amount)

class TipCalculatorTest {
    @Test fun includesTipBeforeSplitting() {
        val result = calculateSplit("100", "4", 20) as SplitResult.Success
        assertEquals(20.0, result.tip, 0.000001)
        assertEquals(120.0, result.total, 0.000001)
        assertEquals(30.0, result.perPerson, 0.000001)
    }

    @Test fun zeroBillAndZeroTipAreValid() {
        val result = calculateSplit("0", "2", 0) as SplitResult.Success
        assertEquals(0.0, result.perPerson, 0.0)
    }

    @Test fun rejectsInvalidAmountsAndPeople() {
        listOf("", "-1", "hello", "NaN", "Infinity").forEach {
            assertTrue(calculateSplit(it, "1", 15) is SplitResult.Error)
        }
        listOf("", "0", "-2", "1.5", "999999999999").forEach {
            assertTrue(calculateSplit("10", it, 15) is SplitResult.Error)
        }
    }

    @Test fun rejectsOverflowAndInvalidTip() {
        assertTrue(calculateSplit("1.7e308", "1", 20) is SplitResult.Error)
        assertTrue(calculateSplit("10", "1", -1) is SplitResult.Error)