Sabores: tres pantallas y un solo dueño del estado

implementation("androidx.navigation:navigation-compose:2.9.8")
implementation("androidx.lifecycle:lifecycle-viewmodel-compose:2.11.0")

package mx.tec.sabores.domain

data class Restaurant(
    val id: Int,
    val name: String,
    val cuisine: String,
    val address: String,
    val description: String,
    val priceLevel: Int,   // 1, 2 o 3
    val emoji: String
) {
    val priceLabel: String get() = "$".repeat(priceLevel)
}

package mx.tec.sabores.domain

data class Review(
    val restaurantId: Int,
    val stars: Int,
    val comment: String
)

package mx.tec.sabores.domain

data class RatingSummary(
    val average: Double,
    val count: Int
) {
    val hasReviews: Boolean get() = count > 0

    companion object {
        fun from(reviews: List<Review>): RatingSummary {
            if (reviews.isEmpty()) return RatingSummary(average = 0.0, count = 0)
            return RatingSummary(
                average = reviews.sumOf { it.stars }.toDouble() / reviews.size,
                count = reviews.size
            )
        }
    }
}

package mx.tec.sabores.domain

sealed interface ReviewError {
    data object NoStars : ReviewError
    data object CommentTooShort : ReviewError
    data object CommentTooLong : ReviewError
}

object ReviewValidator {
    const val COMMENT_MIN = 15
    const val COMMENT_MAX = 240

    fun validateStars(stars: Int): ReviewError? =
        if (stars !in 1..5) ReviewError.NoStars else null

    fun validateComment(comment: String): ReviewError? {
        val text = comment.trim()
        return when {
            text.length < COMMENT_MIN -> ReviewError.CommentTooShort
            text.length > COMMENT_MAX -> ReviewError.CommentTooLong
            else -> null
        }
    }

    fun isValid(stars: Int, comment: String): Boolean =
        validateStars(stars) == null && validateComment(comment) == null
}

package mx.tec.sabores.data

import mx.tec.sabores.domain.Restaurant

class RestaurantRepository {

    private val restaurants = listOf(
        Restaurant(1, "La Chinampa", "Mexicana", "Av. Garza Sada 300",
            "Cocina de mercado: tacos de guisado, sopes y agua del día.", 1, "🌮"),
        Restaurant(2, "Nonna Rosa", "Italiana", "Río Nazas 118",
            "Pasta fresca hecha en casa y horno de leña a la vista.", 3, "🍝"),
        Restaurant(3, "Kaze", "Japonesa", "Vasconcelos 402",
            "Barra de sushi de doce lugares. Menú corto que cambia cada semana.", 3, "🍣"),
        Restaurant(4, "Verde Limón", "Vegetariana", "Hidalgo 1204",
            "Bowls de temporada y jugos prensados en frío. Todo sin carne.", 2, "🥗"),
        Restaurant(5, "Brasa 33", "Parrilla", "Gómez Morín 33",
            "Cortes al carbón y papas rústicas. Reserva el fin de semana.", 3, "🥩")
    )

    fun getAll(): List<Restaurant> = restaurants

    fun getById(id: Int): Restaurant? = restaurants.firstOrNull { it.id == id }
}

@Composable
fun RatingLabel(summary: RatingSummary, modifier: Modifier = Modifier) {
    if (!summary.hasReviews) {
        Text(
            text = "Sin reseñas todavía",
            style = MaterialTheme.typography.labelMedium,
            color = MaterialTheme.colorScheme.onSurfaceVariant,
            modifier = modifier
        )
        return
    }
    Row(modifier, verticalAlignment = Alignment.CenterVertically) {
        Icon(
            imageVector = Icons.Default.Star,
            contentDescription = null,
            tint = Color(0xFFF5A623),
            modifier = Modifier.size(16.dp)
        )
        Spacer(Modifier.width(4.dp))
        Text(
            text = "%.1f".format(summary.average) +
                   " · ${summary.count} reseña${if (summary.count == 1) "" else "s"}",
            style = MaterialTheme.typography.labelMedium
        )
    }
}

@Composable
fun RestaurantCard(
    restaurant: Restaurant,
    summary: RatingSummary,
    onClick: () -> Unit,
    modifier: Modifier = Modifier
) {
    Card(modifier = modifier.fillMaxWidth().clickable(onClick = onClick)) {
        Row(
            modifier = Modifier.padding(16.dp),
            verticalAlignment = Alignment.CenterVertically,
            horizontalArrangement = Arrangement.spacedBy(16.dp)
        ) {
            Text(restaurant.emoji, style = MaterialTheme.typography.displaySmall)
            Column(Modifier.weight(1f)) {
                Text(restaurant.name, style = MaterialTheme.typography.titleMedium)
                Text(
                    text = "${restaurant.cuisine} · ${restaurant.priceLabel}",
                    style = MaterialTheme.typography.bodyMedium,
                    color = MaterialTheme.colorScheme.onSurfaceVariant
                )
                Spacer(Modifier.height(6.dp))
                RatingLabel(summary)
            }
            Icon(Icons.AutoMirrored.Filled.KeyboardArrowRight, contentDescription = null)
        }
    }
}

@Composable
fun RestaurantListScreen(
    restaurants: List<Restaurant>,
    summaryOf: (Int) -> RatingSummary,
    onRestaurantClick: (Int) -> Unit,
    modifier: Modifier = Modifier
) {
    LazyColumn(
        modifier = modifier.fillMaxSize(),
        contentPadding = PaddingValues(16.dp),
        verticalArrangement = Arrangement.spacedBy(12.dp)
    ) {
        items(restaurants, key = { it.id }) { restaurant ->
            RestaurantCard(
                restaurant = restaurant,
                summary = summaryOf(restaurant.id),
                onClick = { onRestaurantClick(restaurant.id) }
            )
        }
    }
}

@Preview(showBackground = true)
@Composable
private fun ListPreview() {
    SaboresTheme {
        RestaurantListScreen(
            restaurants = RestaurantRepository().getAll(),
            summaryOf = { RatingSummary(4.2, 3) },   // datos falsos: es solo el dibujo
            onRestaurantClick = {}
        )
    }
}

setContent {
    SaboresTheme {
        val repository = remember { RestaurantRepository() }
        RestaurantListScreen(
            restaurants = repository.getAll(),
            summaryOf = { RatingSummary(0.0, 0) },
            onRestaurantClick = { }
        )
    }
}

package mx.tec.sabores.ui.navigation

object Route {
    const val HOME = "home"
    const val MY_REVIEWS = "myReviews"
    const val DETAIL = "detail/{restaurantId}"
    const val NEW_REVIEW = "review/{restaurantId}"

    const val ARG_RESTAURANT_ID = "restaurantId"

    fun detail(id: Int) = "detail/$id"
    fun newReview(id: Int) = "review/$id"
}

@Composable
fun SaboresApp() {
    val nav = rememberNavController()
    val repository = remember { RestaurantRepository() }

    NavHost(navController = nav, startDestination = Route.HOME) {

        composable(Route.HOME) {
            RestaurantListScreen(
                restaurants = repository.getAll(),
                summaryOf = { RatingSummary(0.0, 0) },        // provisional
                onRestaurantClick = { id -> nav.navigate(Route.detail(id)) }
            )
        }

        composable(
            route = Route.DETAIL,
            arguments = listOf(navArgument(Route.ARG_RESTAURANT_ID) { type = NavType.IntType })
        ) { backStackEntry ->
            val id = backStackEntry.arguments?.getInt(Route.ARG_RESTAURANT_ID) ?: return@composable
            val restaurant = repository.getById(id) ?: return@composable

            RestaurantDetailScreen(
                restaurant = restaurant,
                summary = RatingSummary(0.0, 0),               // provisional
                reviews = emptyList(),                         // provisional
                onWriteReviewClick = { nav.navigate(Route.newReview(id)) },
                onBack = { nav.popBackStack() }
            )
        }
    }
}

setContent { SaboresTheme { SaboresApp() } }

@OptIn(ExperimentalMaterial3Api::class)
@Composable
fun RestaurantDetailScreen(
    restaurant: Restaurant,
    summary: RatingSummary,
    reviews: List<Review>,
    onWriteReviewClick: () -> Unit,
    onBack: () -> Unit,
    modifier: Modifier = Modifier
) {
    Scaffold(
        modifier = modifier,
        topBar = {
            TopAppBar(
                title = { Text(restaurant.name) },
                navigationIcon = {
                    IconButton(onClick = onBack) {
                        Icon(Icons.AutoMirrored.Filled.ArrowBack, contentDescription = "Regresar")
                    }
                }
            )
        },
        floatingActionButton = {
            ExtendedFloatingActionButton(
                onClick = onWriteReviewClick,
                icon = { Icon(Icons.Default.Star, contentDescription = null) },
                text = { Text("Escribir reseña") }
            )
        }
    ) { padding ->
        LazyColumn(
            modifier = Modifier.fillMaxSize().padding(padding),
            contentPadding = PaddingValues(16.dp),
            verticalArrangement = Arrangement.spacedBy(12.dp)
        ) {
            item {
                Text(restaurant.emoji, style = MaterialTheme.typography.displayLarge)
                Text(
                    "${restaurant.cuisine} · ${restaurant.priceLabel}",
                    style = MaterialTheme.typography.titleMedium,
                    color = MaterialTheme.colorScheme.onSurfaceVariant
                )
                Spacer(Modifier.height(8.dp))
                RatingLabel(summary)
                Spacer(Modifier.height(12.dp))
                Text(restaurant.description, style = MaterialTheme.typography.bodyLarge)
                Spacer(Modifier.height(4.dp))
                Text(restaurant.address, style = MaterialTheme.typography.bodySmall)
                Spacer(Modifier.height(20.dp))
                Text("Reseñas", style = MaterialTheme.typography.titleLarge)
            }

            if (reviews.isEmpty()) {
                item {
                    Text(
                        "Nadie ha reseñado este lugar. Sé la primera persona.",
                        style = MaterialTheme.typography.bodyMedium,
                        color = MaterialTheme.colorScheme.onSurfaceVariant
                    )
                }
            } else {
                items(reviews) { review ->
                    Card(Modifier.fillMaxWidth()) {
                        Column(Modifier.padding(14.dp)) {
                            StarsRow(review.stars)      // una reseña: solo sus estrellas
                            Spacer(Modifier.height(6.dp))
                            Text(review.comment, style = MaterialTheme.typography.bodyMedium)
                        }
                    }
                }
            }

            item { Spacer(Modifier.height(72.dp)) }   // que el FAB no tape la última reseña
        }
    }
}

// ❌ A PROPÓSITO MAL
var reviews by remember { mutableStateOf(listOf<Review>()) }

onClick = { reviews = reviews + Review(restaurant.id, 5, "Estuvo increíble, volvería mañana") }

package mx.tec.sabores.ui.state

import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.setValue
import androidx.lifecycle.ViewModel
import mx.tec.sabores.data.RestaurantRepository
import mx.tec.sabores.domain.RatingSummary
import mx.tec.sabores.domain.Restaurant
import mx.tec.sabores.domain.Review
import mx.tec.sabores.domain.ReviewValidator

class SaboresViewModel : ViewModel() {

    private val repository = RestaurantRepository()

    // Estado que NO cambia: se lee una vez.
    val restaurants: List<Restaurant> = repository.getAll()

    // Estado que SÍ cambia: Compose se suscribe y recompone solo.
    var reviews by mutableStateOf<List<Review>>(emptyList())
        private set                                   // ← nadie de afuera puede asignarlo

    fun restaurantById(id: Int): Restaurant? = repository.getById(id)

    fun reviewsOf(restaurantId: Int): List<Review> =
        reviews.filter { it.restaurantId == restaurantId }

    fun summaryOf(restaurantId: Int): RatingSummary =
        RatingSummary.from(reviewsOf(restaurantId))     // ← el dominio decide; el VM pregunta

    // --- eventos que llegan desde la UI ---

    fun addReview(restaurantId: Int, stars: Int, comment: String) {
        if (!ReviewValidator.isValid(stars, comment)) return    // ← el dominio manda
        reviews = reviews + Review(restaurantId, stars, comment.trim())
    }
}

@Composable
fun SaboresApp() {
    val nav = rememberNavController()
    val viewModel: SaboresViewModel = viewModel()   // androidx.lifecycle.viewmodel.compose.viewModel

    NavHost(navController = nav, startDestination = Route.HOME) {

        composable(Route.HOME) {
            RestaurantListScreen(
                restaurants = viewModel.restaurants,
                summaryOf = { id -> viewModel.summaryOf(id) },
                onRestaurantClick = { id -> nav.navigate(Route.detail(id)) }
            )
        }

        composable(
            route = Route.DETAIL,
            arguments = listOf(navArgument(Route.ARG_RESTAURANT_ID) { type = NavType.IntType })
        ) { entry ->
            val id = entry.arguments?.getInt(Route.ARG_RESTAURANT_ID) ?: return@composable
            val restaurant = viewModel.restaurantById(id) ?: return@composable

            RestaurantDetailScreen(
                restaurant = restaurant,
                summary = viewModel.summaryOf(id),
                reviews = viewModel.reviewsOf(id),
                onWriteReviewClick = { nav.navigate(Route.newReview(id)) },
                onBack = { nav.popBackStack() }
            )
        }
    }
}

data class NewReviewUiState(
    val stars: Int = 0,
    val comment: String = ""
) {
    // Estado DERIVADO: se calcula, no se guarda.
    val commentError: ReviewError? =
        if (comment.isEmpty()) null else ReviewValidator.validateComment(comment)

    val canSave: Boolean = ReviewValidator.isValid(stars, comment)

    val charactersLeft: Int = ReviewValidator.COMMENT_MAX - comment.trim().length
}

class NewReviewViewModel : ViewModel() {

    var uiState by mutableStateOf(NewReviewUiState())
        private set

    fun onStarsChange(stars: Int) {
        uiState = uiState.copy(stars = stars)
    }

    fun onCommentChange(text: String) {
        if (text.length <= ReviewValidator.COMMENT_MAX) {
            uiState = uiState.copy(comment = text)
        }
    }
}

@Composable
fun StarPicker(value: Int, onValueChange: (Int) -> Unit, modifier: Modifier = Modifier) {
    Row(modifier) {
        (1..5).forEach { n ->
            IconButton(onClick = { onValueChange(n) }) {
                // Ojo: NO existe una estrella hueca en el set de iconos base.
                // La diferencia entre marcada y sin marcar la hace el TINTE.
                Icon(
                    imageVector = Icons.Default.Star,
                    contentDescription = "$n estrella${if (n == 1) "" else "s"}",
                    tint = if (n <= value) Color(0xFFF5A623)
                           else MaterialTheme.colorScheme.outlineVariant,
                    modifier = Modifier.size(36.dp)
                )
            }
        }
    }
}

/** Las estrellas de UNA reseña. Distinto de RatingLabel, que resume MUCHAS. */
@Composable
fun StarsRow(stars: Int, modifier: Modifier = Modifier) {
    Row(modifier.semantics { contentDescription = "$stars de 5 estrellas" }) {
        repeat(stars) {
            Icon(
                imageVector = Icons.Default.Star,
                contentDescription = null,
                tint = Color(0xFFF5A623),
                modifier = Modifier.size(16.dp)
            )
        }
    }
}

@OptIn(ExperimentalMaterial3Api::class)
@Composable
fun NewReviewScreen(
    restaurant: Restaurant,
    uiState: NewReviewUiState,
    onStarsChange: (Int) -> Unit,
    onCommentChange: (String) -> Unit,
    onSave: () -> Unit,
    onCancel: () -> Unit,
    modifier: Modifier = Modifier
) {
    Scaffold(
        modifier = modifier,
        topBar = {
            TopAppBar(
                title = { Text("Reseñar ${restaurant.name}") },
                navigationIcon = {
                    IconButton(onClick = onCancel) {
                        Icon(Icons.Default.Close, contentDescription = "Cancelar")
                    }
                }
            )
        }
    ) { padding ->
        Column(
            modifier = Modifier.fillMaxSize().padding(padding).padding(16.dp),
            verticalArrangement = Arrangement.spacedBy(16.dp)
        ) {
            Text("¿Cómo estuvo?", style = MaterialTheme.typography.titleMedium)
            StarPicker(value = uiState.stars, onValueChange = onStarsChange)

            OutlinedTextField(
                value = uiState.comment,
                onValueChange = onCommentChange,
                label = { Text("Tu reseña") },
                minLines = 4,
                isError = uiState.commentError != null,
                supportingText = {
                    val error = uiState.commentError
                    if (error != null) Text(error.message())
                    else Text("Te quedan ${uiState.charactersLeft} caracteres")
                },
                modifier = Modifier.fillMaxWidth()
            )

            Button(
                onClick = onSave,
                enabled = uiState.canSave,
                modifier = Modifier.fillMaxWidth()
            ) { Text("Publicar reseña") }
        }
    }
}

// Traducir el error del dominio a español es trabajo de la UI, no del dominio.
private fun ReviewError.message(): String = when (this) {
    ReviewError.NoStars         -> "Selecciona de 1 a 5 estrellas"
    ReviewError.CommentTooShort -> "Escribe al menos ${ReviewValidator.COMMENT_MIN} caracteres"
    ReviewError.CommentTooLong  -> "Máximo ${ReviewValidator.COMMENT_MAX} caracteres"
}

composable(
    route = Route.NEW_REVIEW,
    arguments = listOf(navArgument(Route.ARG_RESTAURANT_ID) { type = NavType.IntType })
) { entry ->
    val id = entry.arguments?.getInt(Route.ARG_RESTAURANT_ID) ?: return@composable
    val restaurant = viewModel.restaurantById(id) ?: return@composable

    // OJO: este viewModel() vive DENTRO del composable → su dueño es este destino.
    val formViewModel: NewReviewViewModel = viewModel()

    NewReviewScreen(
        restaurant = restaurant,
        uiState = formViewModel.uiState,
        onStarsChange = formViewModel::onStarsChange,
        onCommentChange = formViewModel::onCommentChange,
        onSave = {
            viewModel.addReview(                       // ← el VM COMPARTIDO recibe el dato
                restaurantId = id,
                stars = formViewModel.uiState.stars,
                comment = formViewModel.uiState.comment
            )
            nav.popBackStack()                         // ← la NAVEGACIÓN la decide la UI
        },
        onCancel = { nav.popBackStack() }
    )
}

enum class MenuItem(val route: String, val label: String, val icon: ImageVector) {
    HOME(Route.HOME, "Restaurantes", Icons.Default.Home),
    MY_REVIEWS(Route.MY_REVIEWS, "Mis reseñas", Icons.Default.Star)
}

val backStackEntry by nav.currentBackStackEntryAsState()
val currentRoute = backStackEntry?.destination?.route
val showBottomBar = MenuItem.entries.any { it.route == currentRoute }

Scaffold(
    bottomBar = {
        if (showBottomBar) {
            NavigationBar {
                MenuItem.entries.forEach { item ->
                    NavigationBarItem(
                        selected = currentRoute == item.route,
                        onClick = {
                            nav.navigate(item.route) {
                                popUpTo(Route.HOME) { saveState = true }
                                launchSingleTop = true
                                restoreState = true
                            }
                        },
                        icon = { Icon(item.icon, contentDescription = null) },
                        label = { Text(item.label) }
                    )
                }
            }
        }
    }
) { padding ->
    NavHost(
        navController = nav,
        startDestination = Route.HOME,
        modifier = Modifier.padding(padding)
    ) {
        /* … los cuatro destinos … */
    }
}

data class MyReviewItem(val restaurantName: String, val review: Review)

val myReviews: List<MyReviewItem>
    get() = reviews.reversed().mapNotNull { review ->
        restaurantById(review.restaurantId)?.let { MyReviewItem(it.name, review) }
    }

@Composable
fun MyReviewsScreen(items: List<MyReviewItem>, modifier: Modifier = Modifier) {
    if (items.isEmpty()) {
        Box(modifier.fillMaxSize(), contentAlignment = Alignment.Center) {
            Text("Todavía no has reseñado ningún lugar.",
                 color = MaterialTheme.colorScheme.onSurfaceVariant)
        }
        return
    }
    LazyColumn(
        modifier = modifier.fillMaxSize(),
        contentPadding = PaddingValues(16.dp),
        verticalArrangement = Arrangement.spacedBy(12.dp)
    ) {
        items(items) { item ->
            Card(Modifier.fillMaxWidth()) {
                Column(Modifier.padding(16.dp)) {
                    Text(item.restaurantName, style = MaterialTheme.typography.titleMedium)
                    StarsRow(item.review.stars)
                    Spacer(Modifier.height(6.dp))
                    Text(item.review.comment, style = MaterialTheme.typography.bodyMedium)
                }
            }
        }
    }
}