Phase 7 Capstone · Study Tasks

package com.mastercoding.phase7

import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.activity.enableEdgeToEdge
import androidx.activity.viewModels
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.PaddingValues
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.consumeWindowInsets
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.imePadding
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.items
import androidx.compose.foundation.rememberScrollState
import androidx.compose.foundation.verticalScroll
import androidx.compose.material3.Button
import androidx.compose.material3.Card
import androidx.compose.material3.Checkbox
import androidx.compose.material3.CircularProgressIndicator
import androidx.compose.material3.LinearProgressIndicator
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.OutlinedTextField
import androidx.compose.material3.Scaffold
import androidx.compose.material3.Text
import androidx.compose.material3.TextButton
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.ui.Modifier
import androidx.compose.ui.semantics.contentDescription
import androidx.compose.ui.semantics.semantics
import androidx.compose.ui.unit.dp
import androidx.lifecycle.compose.collectAsStateWithLifecycle
import androidx.navigation.NavType
import androidx.navigation.compose.NavHost
import androidx.navigation.compose.composable
import androidx.navigation.compose.rememberNavController
import androidx.navigation.navArgument

class MainActivity : ComponentActivity() {
    private val model: TasksViewModel by viewModels {
        TasksViewModel.factory(TasksRepository(TasksDatabase.get(applicationContext).tasks()))
    }
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        enableEdgeToEdge()
        setContent { MaterialTheme { PocketTasks(model) } }
    }
}

@Composable
private fun PocketTasks(model: TasksViewModel) {
    val state by model.state.collectAsStateWithLifecycle()
    val nav = rememberNavController()
    Scaffold { insets ->
        NavHost(
            nav, startDestination = "tasks",
            modifier = Modifier.fillMaxSize().padding(insets)
                .consumeWindowInsets(insets).imePadding(),
        ) {
            composable("tasks") {
                TaskList(state, model::editDraft, model::addTask,
                    model::completeTask, model::deleteTask,
                    onOpen = { id -> nav.navigate("task/$id") { launchSingleTop = true } },
                    onRetry = model::retryRead)
            }
            composable("task/{taskId}", arguments = listOf(
                navArgument("taskId") { type = NavType.LongType },
            )) { entry ->
                val id = entry.arguments?.getLong("taskId")
                TaskDetail(state.tasks.firstOrNull { it.id == id }, state,
                    onComplete = model::completeTask,
                    onBack = { nav.popBackStack() }, onRetry = model::retryRead)
            }
        }
    }
}

@Composable
private fun TaskList(
    state: TasksUiState, onDraft: (String) -> Unit, onAdd: () -> Unit,
    onComplete: (Long, Boolean) -> Unit, onDelete: (Long) -> Unit, onOpen: (Long) -> Unit,
    onRetry: () -> Unit,
) {
    val completed = state.tasks.count { it.completed }
    val target = if (state.tasks.isEmpty()) 0f else completed.toFloat() / state.tasks.size
    val progress = target
    val canEdit = !state.busy && !state.loading && state.readError == null
    LazyColumn(
        modifier = Modifier.fillMaxSize(), contentPadding = PaddingValues(16.dp),
        verticalArrangement = Arrangement.spacedBy(8.dp),
    ) {
        item {
            Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
                TaskStatus(state, onRetry)
                OutlinedTextField(
                    value = state.draft, onValueChange = onDraft, label = { Text("New task") },
                    supportingText = { Text("Up to $MAX_TITLE_LENGTH characters") },
                    enabled = !state.busy, singleLine = true, modifier = Modifier.fillMaxWidth(),
                )
                Button(onClick = onAdd, enabled = canEdit) { Text(if (state.busy) "Saving…" else "Add task") }
                Text("$completed of ${state.tasks.size} completed")
                LinearProgressIndicator(progress = { progress }, modifier = Modifier.fillMaxWidth())
                if (state.tasks.isNotEmpty() && completed == state.tasks.size) {
                    Text("All done!", color = MaterialTheme.colorScheme.primary)
                }
                if (!state.loading && state.readError == null && state.tasks.isEmpty()) {
                    Text("Your list is empty. Add one small task.")
                }
            }
        }
        items(state.tasks, key = { it.id }) { task ->
            Card(Modifier.fillMaxWidth()) {
                Row(Modifier.padding(4.dp)) {
                    Checkbox(
                        checked = task.completed, onCheckedChange = { onComplete(task.id, it) },
                        enabled = canEdit,
                        modifier = Modifier.semantics { contentDescription = "Completed: ${task.title}" },
                    )
                    TextButton(onClick = { onOpen(task.id) }, modifier = Modifier.weight(1f)) {
                        Text(task.title)
                    }
                    TextButton(onClick = { onDelete(task.id) }, enabled = canEdit) { Text("Delete") }
                }
            }
        }
    }
}

@Composable
private fun TaskDetail(
    task: Task?, state: TasksUiState, onComplete: (Long, Boolean) -> Unit, onBack: () -> Unit,
    onRetry: () -> Unit,
) {
    Column(
        modifier = Modifier.fillMaxSize().verticalScroll(rememberScrollState()).padding(16.dp),
        verticalArrangement = Arrangement.spacedBy(12.dp),
    ) {
        TaskStatus(state, onRetry)
        TextButton(onClick = onBack) { Text("Back to tasks") }
        when {
            state.loading -> Text("Loading task…")
            state.readError != null -> Text("Task unavailable. Use Retry reading above.")
            task == null -> Text("Task not found. It may have been deleted.")
            else -> {
                Text(task.title, style = MaterialTheme.typography.headlineSmall)
                Text("Task #${task.id} · ${if (task.completed) "Completed" else "Still to do"}")
                Row {
                    Checkbox(checked = task.completed, enabled = !state.busy,
                        onCheckedChange = { onComplete(task.id, it) },
                        modifier = Modifier.semantics { contentDescription = "Completed: ${task.title}" })
                    Text("Completed", Modifier.padding(top = 12.dp))
                }
            }
        }
    }
}

@Composable
private fun TaskStatus(state: TasksUiState, onRetry: () -> Unit) {
    Text("Study Tasks", style = MaterialTheme.typography.headlineMedium)
    if (state.loading) CircularProgressIndicator()
    state.readError?.let {
        Text(it, color = MaterialTheme.colorScheme.error)
        TextButton(onClick = onRetry) { Text("Retry reading") }
    }
    state.writeError?.let { Text(it, color = MaterialTheme.colorScheme.error) }
}