openuispec 0.1.27 → 0.1.28

package/examples/taskflow/generated/android/TaskFlow/app/src/main/java/uz/rsteam/taskflow/TaskFlowApp.kt

@@ -0,0 +1,283 @@
+package uz.rsteam.taskflow
+
+import androidx.compose.foundation.layout.BoxWithConstraints
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxHeight
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.navigationBarsPadding
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.outlined.CalendarMonth
+import androidx.compose.material.icons.outlined.Folder
+import androidx.compose.material.icons.outlined.Home
+import androidx.compose.material.icons.outlined.Settings
+import androidx.compose.material3.FloatingActionButton
+import androidx.compose.material3.Icon
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.NavigationBar
+import androidx.compose.material3.NavigationBarItem
+import androidx.compose.material3.NavigationRail
+import androidx.compose.material3.NavigationRailItem
+import androidx.compose.material3.Scaffold
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateListOf
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.unit.dp
+import uz.rsteam.taskflow.model.NewProjectDraft
+import uz.rsteam.taskflow.model.Priority
+import uz.rsteam.taskflow.model.Project
+import uz.rsteam.taskflow.model.Route
+import uz.rsteam.taskflow.model.SampleData
+import uz.rsteam.taskflow.model.SheetState
+import uz.rsteam.taskflow.model.Task
+import uz.rsteam.taskflow.model.TaskEditorDraft
+import uz.rsteam.taskflow.model.TaskFilter
+import uz.rsteam.taskflow.model.TaskStatus
+import uz.rsteam.taskflow.model.TopLevelScreen
+import uz.rsteam.taskflow.ui.screens.CalendarScreen
+import uz.rsteam.taskflow.ui.screens.HomeScreen
+import uz.rsteam.taskflow.ui.screens.ProfileEditScreen
+import uz.rsteam.taskflow.ui.screens.ProjectDetailScreen
+import uz.rsteam.taskflow.ui.screens.ProjectsScreen
+import uz.rsteam.taskflow.ui.screens.SettingsScreen
+import uz.rsteam.taskflow.ui.screens.TaskDetailScreen
+import uz.rsteam.taskflow.ui.sheets.AssignUserSheet
+import uz.rsteam.taskflow.ui.sheets.NewProjectSheet
+import uz.rsteam.taskflow.ui.sheets.TaskEditorSheet
+import uz.rsteam.taskflow.ui.theme.TaskFlowTheme
+import java.time.LocalDate
+import java.time.LocalDateTime
+import java.util.UUID
+
+@Composable
+fun TaskFlowApp() {
+    val users = remember { SampleData.users }
+    val currentUser = users.first()
+    val projects = remember { mutableStateListOf<Project>().apply { addAll(SampleData.projects) } }
+    val tasks = remember { mutableStateListOf<Task>().apply { addAll(SampleData.tasks(currentUser)) } }
+
+    var route by remember { mutableStateOf<Route>(Route.TopLevel(TopLevelScreen.Home)) }
+    var sheetState by remember { mutableStateOf<SheetState?>(null) }
+    var searchQuery by remember { mutableStateOf("") }
+    var activeFilter by remember { mutableStateOf(TaskFilter.Today) }
+
+    TaskFlowTheme {
+        BoxWithConstraints {
+            val compact = maxWidth < 600.dp
+            val primaryColor = MaterialTheme.colorScheme.primary
+            val selectedTopLevel = when (val r = route) {
+                is Route.TopLevel -> r.screen
+                is Route.ProjectDetail -> TopLevelScreen.Projects
+                is Route.ProfileEdit -> TopLevelScreen.Settings
+                is Route.TaskDetail -> TopLevelScreen.Home
+            }
+
+            Scaffold(
+                containerColor = MaterialTheme.colorScheme.background,
+                bottomBar = {
+                    if (compact) {
+                        NavigationBar {
+                            TopLevelScreen.entries.forEach { item ->
+                                NavigationBarItem(
+                                    selected = item == selectedTopLevel,
+                                    onClick = { route = Route.TopLevel(item) },
+                                    icon = {
+                                        Icon(
+                                            when (item) {
+                                                TopLevelScreen.Home -> Icons.Outlined.Home
+                                                TopLevelScreen.Projects -> Icons.Outlined.Folder
+                                                TopLevelScreen.Calendar -> Icons.Outlined.CalendarMonth
+                                                TopLevelScreen.Settings -> Icons.Outlined.Settings
+                                            },
+                                            contentDescription = null
+                                        )
+                                    },
+                                    label = { Text(textFor(item)) }
+                                )
+                            }
+                        }
+                    }
+                },
+                floatingActionButton = {
+                    if (selectedTopLevel == TopLevelScreen.Home) {
+                        FloatingActionButton(onClick = { sheetState = SheetState.CreateTask }) {
+                            Text("+")
+                        }
+                    }
+                }
+            ) { innerPadding ->
+                Row(modifier = Modifier.fillMaxSize()) {
+                    if (!compact) {
+                        NavigationRail(modifier = Modifier.fillMaxHeight().navigationBarsPadding()) {
+                            TopLevelScreen.entries.forEach { item ->
+                                NavigationRailItem(
+                                    selected = item == selectedTopLevel,
+                                    onClick = { route = Route.TopLevel(item) },
+                                    icon = {
+                                        Icon(
+                                            when (item) {
+                                                TopLevelScreen.Home -> Icons.Outlined.Home
+                                                TopLevelScreen.Projects -> Icons.Outlined.Folder
+                                                TopLevelScreen.Calendar -> Icons.Outlined.CalendarMonth
+                                                TopLevelScreen.Settings -> Icons.Outlined.Settings
+                                            },
+                                            contentDescription = null
+                                        )
+                                    },
+                                    label = { Text(textFor(item)) }
+                                )
+                            }
+                        }
+                    }
+
+                    when (val currentRoute = route) {
+                        is Route.TopLevel -> when (currentRoute.screen) {
+                            TopLevelScreen.Home -> HomeScreen(
+                                currentUser = currentUser,
+                                projects = projects,
+                                tasks = tasks,
+                                activeFilter = activeFilter,
+                                searchQuery = searchQuery,
+                                onSearchChange = { searchQuery = it },
+                                onFilterChange = { activeFilter = it },
+                                onSelectTask = { route = Route.TaskDetail(it) },
+                                onCreateTask = { sheetState = SheetState.CreateTask }
+                            )
+                            TopLevelScreen.Projects -> ProjectsScreen(
+                                projects = projects.map { it.copy(taskCount = tasks.count { t -> t.projectId == it.id }) },
+                                onOpenProject = { route = Route.ProjectDetail(it) },
+                                onNewProject = { sheetState = SheetState.NewProject }
+                            )
+                            TopLevelScreen.Calendar -> CalendarScreen()
+                            TopLevelScreen.Settings -> SettingsScreen(
+                                currentUser = currentUser,
+                                preferences = uz.rsteam.taskflow.model.Preferences(),
+                                onPreferencesChange = {},
+                                onEditProfile = { route = Route.ProfileEdit }
+                            )
+                        }
+                        is Route.TaskDetail -> {
+                            val task = tasks.firstOrNull { it.id == currentRoute.taskId }
+                            if (task != null) {
+                                TaskDetailScreen(
+                                    task = task,
+                                    project = projects.firstOrNull { it.id == task.projectId },
+                                    onEdit = { sheetState = SheetState.EditTask(task.id) },
+                                    onToggleStatus = {
+                                        val idx = tasks.indexOfFirst { it.id == task.id }
+                                        if (idx >= 0) tasks[idx] = task.copy(
+                                            status = if (task.status == TaskStatus.Done) TaskStatus.Todo else TaskStatus.Done,
+                                            updatedAt = LocalDateTime.now()
+                                        )
+                                    },
+                                    onDelete = {
+                                        tasks.removeAll { it.id == task.id }
+                                        route = Route.TopLevel(TopLevelScreen.Home)
+                                    },
+                                    onProjectClick = { task.projectId?.let { route = Route.ProjectDetail(it) } },
+                                    onAssign = { sheetState = SheetState.AssignTask(task.id) }
+                                )
+                            }
+                        }
+                        is Route.ProjectDetail -> {
+                            val project = projects.firstOrNull { it.id == currentRoute.projectId }
+                            if (project != null) {
+                                ProjectDetailScreen(project = project, tasks = tasks.filter { it.projectId == project.id }, onOpenTask = {
+                                    route = Route.TaskDetail(it)
+                                })
+                            }
+                        }
+                        Route.ProfileEdit -> ProfileEditScreen(currentUser = currentUser) { _, _ ->
+                            route = Route.TopLevel(TopLevelScreen.Settings)
+                        }
+                    }
+                }
+            }
+
+            when (val sheet = sheetState) {
+                SheetState.CreateTask -> TaskEditorSheet(
+                    title = "New task",
+                    initial = TaskEditorDraft(priority = Priority.Medium),
+                    onDismiss = { sheetState = null },
+                    onSubmit = { draft ->
+                        tasks.add(0, toTask(draft, currentUser))
+                        sheetState = null
+                    }
+                )
+                is SheetState.EditTask -> {
+                    val task = tasks.firstOrNull { it.id == sheet.taskId }
+                    if (task != null) {
+                        TaskEditorSheet(
+                            title = "Edit task",
+                            initial = TaskEditorDraft(
+                                title = task.title,
+                                description = task.description ?: "",
+                                projectId = task.projectId,
+                                priority = task.priority,
+                                dueDate = task.dueDate?.toString() ?: "",
+                                tags = task.tags.joinToString(", "),
+                                assignToSelf = task.assignee?.id == currentUser.id
+                            ),
+                            onDismiss = { sheetState = null },
+                            onSubmit = { draft ->
+                                val idx = tasks.indexOfFirst { it.id == task.id }
+                                if (idx >= 0) tasks[idx] = task.copy(
+                                    title = draft.title,
+                                    description = draft.description.ifBlank { null },
+                                    priority = draft.priority,
+                                    dueDate = draft.dueDate.toLocalDateOrNull(),
+                                    projectId = draft.projectId,
+                                    tags = draft.tags.toTags(),
+                                    assignee = if (draft.assignToSelf) currentUser else null,
+                                    updatedAt = LocalDateTime.now()
+                                )
+                                sheetState = null
+                            }
+                        )
+                    }
+                }
+                SheetState.NewProject -> NewProjectSheet(
+                    onDismiss = { sheetState = null },
+                    onCreate = { draft: NewProjectDraft ->
+                        projects.add(Project(UUID.randomUUID().toString(), draft.name.trim(), primaryColor, Icons.Outlined.Folder, 0))
+                        sheetState = null
+                    }
+                )
+                is SheetState.AssignTask -> AssignUserSheet(users = users, onDismiss = { sheetState = null }) { user ->
+                    val idx = tasks.indexOfFirst { it.id == sheet.taskId }
+                    if (idx >= 0) tasks[idx] = tasks[idx].copy(assignee = user, updatedAt = LocalDateTime.now())
+                    sheetState = null
+                }
+                null -> Unit
+            }
+        }
+    }
+}
+
+private fun textFor(screen: TopLevelScreen) = when (screen) {
+    TopLevelScreen.Home -> "Tasks"
+    TopLevelScreen.Projects -> "Projects"
+    TopLevelScreen.Calendar -> "Calendar"
+    TopLevelScreen.Settings -> "Settings"
+}
+
+private fun toTask(draft: TaskEditorDraft, currentUser: uz.rsteam.taskflow.model.User): Task = Task(
+    id = UUID.randomUUID().toString(),
+    title = draft.title.trim(),
+    description = draft.description.trim().ifBlank { null },
+    status = TaskStatus.Todo,
+    priority = draft.priority,
+    dueDate = draft.dueDate.toLocalDateOrNull(),
+    projectId = draft.projectId,
+    tags = draft.tags.toTags(),
+    createdAt = LocalDateTime.now(),
+    updatedAt = LocalDateTime.now(),
+    assignee = if (draft.assignToSelf) currentUser else null
+)
+
+private fun String.toLocalDateOrNull(): LocalDate? = runCatching { LocalDate.parse(this) }.getOrNull()
+private fun String.toTags(): List<String> = split(",").map { it.trim() }.filter { it.isNotBlank() }

package/examples/taskflow/generated/android/TaskFlow/app/src/main/java/uz/rsteam/taskflow/model/DomainModels.kt

@@ -0,0 +1,106 @@
+package uz.rsteam.taskflow.model
+
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.vector.ImageVector
+import uz.rsteam.taskflow.R
+import java.time.LocalDate
+import java.time.LocalDateTime
+
+enum class TopLevelScreen(val titleRes: Int) {
+    Home(R.string.nav_tasks),
+    Projects(R.string.nav_projects),
+    Calendar(R.string.nav_calendar),
+    Settings(R.string.nav_settings)
+}
+
+sealed interface Route {
+    data class TopLevel(val screen: TopLevelScreen) : Route
+    data class TaskDetail(val taskId: String) : Route
+    data class ProjectDetail(val projectId: String) : Route
+    data object ProfileEdit : Route
+}
+
+sealed interface SheetState {
+    data object CreateTask : SheetState
+    data class EditTask(val taskId: String) : SheetState
+    data object NewProject : SheetState
+    data class AssignTask(val taskId: String) : SheetState
+}
+
+enum class TaskFilter(val labelRes: Int) {
+    All(R.string.home_filter_all),
+    Today(R.string.home_filter_today),
+    Upcoming(R.string.home_filter_upcoming),
+    Done(R.string.home_filter_done)
+}
+
+enum class TaskStatus(val labelRes: Int) {
+    Todo(R.string.status_todo),
+    InProgress(R.string.status_in_progress),
+    Done(R.string.status_done)
+}
+
+enum class Priority(val labelRes: Int, val color: Color) {
+    Low(R.string.priority_low, Color(0xFF9CA3AF)),
+    Medium(R.string.priority_medium, Color(0xFF3B82D4)),
+    High(R.string.priority_high, Color(0xFFD4920E)),
+    Urgent(R.string.priority_urgent, Color(0xFFD43B3B))
+}
+
+data class User(
+    val id: String,
+    val name: String,
+    val firstName: String,
+    val email: String
+)
+
+data class Project(
+    val id: String,
+    val name: String,
+    val color: Color,
+    val icon: ImageVector,
+    val taskCount: Int
+)
+
+data class MediaAttachment(
+    val source: String,
+    val mediaType: String,
+    val title: String
+)
+
+data class Task(
+    val id: String,
+    val title: String,
+    val description: String?,
+    val status: TaskStatus,
+    val priority: Priority,
+    val dueDate: LocalDate?,
+    val projectId: String?,
+    val tags: List<String>,
+    val createdAt: LocalDateTime,
+    val updatedAt: LocalDateTime,
+    val assignee: User?,
+    val attachment: MediaAttachment? = null
+)
+
+data class Preferences(
+    val defaultPriority: Priority = Priority.Medium,
+    val notificationsEnabled: Boolean = true,
+    val remindersEnabled: Boolean = true
+)
+
+data class TaskEditorDraft(
+    val title: String = "",
+    val description: String = "",
+    val projectId: String? = null,
+    val priority: Priority = Priority.Medium,
+    val dueDate: String = "",
+    val tags: String = "",
+    val assignToSelf: Boolean = true
+)
+
+data class NewProjectDraft(
+    val name: String = "",
+    val colorName: String = "Indigo",
+    val iconName: String = "Folder"
+)

package/examples/taskflow/generated/android/TaskFlow/app/src/main/java/uz/rsteam/taskflow/model/SampleData.kt

@@ -0,0 +1,57 @@
+package uz.rsteam.taskflow.model
+
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.outlined.CheckCircle
+import androidx.compose.material.icons.outlined.Folder
+import androidx.compose.material.icons.outlined.Star
+import androidx.compose.ui.graphics.Color
+import java.time.LocalDate
+import java.time.LocalDateTime
+
+object SampleData {
+    val users = listOf(
+        User("u1", "Amina Patel", "Amina", "amina@taskflow.app"),
+        User("u2", "Jonas Reed", "Jonas", "jonas@taskflow.app"),
+        User("u3", "Mika Chen", "Mika", "mika@taskflow.app")
+    )
+
+    val projects = listOf(
+        Project("p1", "Product Launch", Color(0xFF5B4FE8), Icons.Outlined.Star, 3),
+        Project("p2", "Website Refresh", Color(0xFF3B82D4), Icons.Outlined.Folder, 2),
+        Project("p3", "Sprint Rituals", Color(0xFF2D9D5E), Icons.Outlined.CheckCircle, 2)
+    )
+
+    fun tasks(currentUser: User): List<Task> = listOf(
+        Task(
+            id = "t1",
+            title = "Finalize launch checklist",
+            description = "Confirm release notes, QA sign-off, and staged rollout timing.",
+            status = TaskStatus.InProgress,
+            priority = Priority.High,
+            dueDate = LocalDate.now(),
+            projectId = "p1",
+            tags = listOf("launch", "ops"),
+            createdAt = LocalDateTime.now().minusDays(4),
+            updatedAt = LocalDateTime.now().minusHours(2),
+            assignee = currentUser,
+            attachment = MediaAttachment(
+                source = "https://commondatastorage.googleapis.com/gtv-videos-bucket/sample/BigBuckBunny.mp4",
+                mediaType = "video",
+                title = "Launch teaser draft"
+            )
+        ),
+        Task(
+            id = "t2",
+            title = "Draft homepage copy",
+            description = "Need a stronger value proposition and one proof block for social trust.",
+            status = TaskStatus.Todo,
+            priority = Priority.Medium,
+            dueDate = LocalDate.now().plusDays(2),
+            projectId = "p2",
+            tags = listOf("copy", "marketing"),
+            createdAt = LocalDateTime.now().minusDays(2),
+            updatedAt = LocalDateTime.now().minusHours(10),
+            assignee = users[1]
+        )
+    )
+}

package/examples/taskflow/generated/android/TaskFlow/app/src/main/java/uz/rsteam/taskflow/ui/components/Common.kt

@@ -0,0 +1,109 @@
+package uz.rsteam.taskflow.ui.components
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.shape.CircleShape
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.automirrored.outlined.KeyboardArrowRight
+import androidx.compose.material.icons.outlined.CheckCircle
+import androidx.compose.material3.Card
+import androidx.compose.material3.ElevatedCard
+import androidx.compose.material3.Icon
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.vector.ImageVector
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.unit.dp
+
+@Composable
+fun EmptyStateCard(title: String, body: String) {
+    ElevatedCard {
+        Column(
+            modifier = Modifier
+                .fillMaxWidth()
+                .padding(24.dp),
+            horizontalAlignment = Alignment.CenterHorizontally,
+            verticalArrangement = Arrangement.spacedBy(8.dp)
+        ) {
+            Icon(Icons.Outlined.CheckCircle, contentDescription = null, tint = MaterialTheme.colorScheme.primary, modifier = Modifier.size(36.dp))
+            Text(title, style = MaterialTheme.typography.titleMedium, fontWeight = FontWeight.SemiBold)
+            Text(body, color = MaterialTheme.colorScheme.onSurfaceVariant)
+        }
+    }
+}
+
+@Composable
+fun SectionCard(title: String, content: @Composable () -> Unit) {
+    ElevatedCard {
+        Column(
+            modifier = Modifier
+                .fillMaxWidth()
+                .padding(16.dp),
+            verticalArrangement = Arrangement.spacedBy(12.dp)
+        ) {
+            Text(title, style = MaterialTheme.typography.labelLarge, color = MaterialTheme.colorScheme.onSurfaceVariant)
+            content()
+        }
+    }
+}
+
+@Composable
+fun StatCard(label: String, value: String) {
+    Card {
+        Column(modifier = Modifier.padding(12.dp), verticalArrangement = Arrangement.spacedBy(4.dp)) {
+            Text(label, style = MaterialTheme.typography.labelSmall, color = MaterialTheme.colorScheme.onSurfaceVariant)
+            Text(value, fontWeight = FontWeight.SemiBold)
+        }
+    }
+}
+
+@Composable
+fun DetailRow(icon: ImageVector, label: String, value: String, onClick: (() -> Unit)? = null) {
+    val content: @Composable () -> Unit = {
+        Row(
+            modifier = Modifier
+                .fillMaxWidth()
+                .padding(vertical = 8.dp),
+            verticalAlignment = Alignment.CenterVertically,
+            horizontalArrangement = Arrangement.spacedBy(12.dp)
+        ) {
+            Icon(icon, contentDescription = null, tint = MaterialTheme.colorScheme.onSurfaceVariant)
+            Column(modifier = Modifier.weight(1f)) {
+                Text(label, style = MaterialTheme.typography.labelMedium, color = MaterialTheme.colorScheme.onSurfaceVariant)
+                Text(value, fontWeight = FontWeight.Medium)
+            }
+            if (onClick != null) Icon(Icons.AutoMirrored.Outlined.KeyboardArrowRight, contentDescription = null)
+        }
+    }
+    if (onClick != null) TextButton(onClick = onClick, modifier = Modifier.fillMaxWidth()) { content() } else content()
+}
+
+@Composable
+fun Avatar(name: String) {
+    val initials = name.split(" ").take(2).joinToString("") { it.firstOrNull()?.uppercase() ?: "" }
+    Box(
+        modifier = Modifier
+            .size(40.dp)
+            .background(MaterialTheme.colorScheme.primary.copy(alpha = 0.14f), CircleShape),
+        contentAlignment = Alignment.Center
+    ) {
+        Text(initials, color = MaterialTheme.colorScheme.primary, fontWeight = FontWeight.SemiBold)
+    }
+}
+
+@Composable
+fun PriorityDot(color: Color) {
+    Box(modifier = Modifier.size(12.dp).background(color, RoundedCornerShape(999.dp)))
+}

package/examples/taskflow/generated/android/TaskFlow/app/src/main/java/uz/rsteam/taskflow/ui/screens/HomeScreen.kt

@@ -0,0 +1,112 @@
+package uz.rsteam.taskflow.ui.screens
+
+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.Spacer
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.items
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.outlined.Add
+import androidx.compose.material.icons.outlined.Search
+import androidx.compose.material3.Button
+import androidx.compose.material3.ElevatedCard
+import androidx.compose.material3.FilterChip
+import androidx.compose.material3.Icon
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.OutlinedTextField
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.unit.dp
+import uz.rsteam.taskflow.model.Project
+import uz.rsteam.taskflow.model.Task
+import uz.rsteam.taskflow.model.TaskFilter
+import uz.rsteam.taskflow.model.TaskStatus
+import uz.rsteam.taskflow.model.User
+import uz.rsteam.taskflow.ui.components.EmptyStateCard
+import uz.rsteam.taskflow.ui.components.PriorityDot
+import java.time.LocalDate
+
+@Composable
+fun HomeScreen(
+    currentUser: User,
+    projects: List<Project>,
+    tasks: List<Task>,
+    activeFilter: TaskFilter,
+    searchQuery: String,
+    onSearchChange: (String) -> Unit,
+    onFilterChange: (TaskFilter) -> Unit,
+    onSelectTask: (String) -> Unit,
+    onCreateTask: () -> Unit
+) {
+    val filteredTasks = tasks.filter { task ->
+        val filterMatch = when (activeFilter) {
+            TaskFilter.All -> true
+            TaskFilter.Today -> task.dueDate == LocalDate.now()
+            TaskFilter.Upcoming -> task.dueDate?.isAfter(LocalDate.now()) == true
+            TaskFilter.Done -> task.status == TaskStatus.Done
+        }
+        val haystack = (task.title + " " + (task.description ?: "") + " " + task.tags.joinToString(" ") + " " + (projects.firstOrNull { it.id == task.projectId }?.name ?: ""))
+        filterMatch && haystack.contains(searchQuery, ignoreCase = true)
+    }
+
+    LazyColumn(contentPadding = PaddingValues(24.dp), verticalArrangement = Arrangement.spacedBy(16.dp)) {
+        item {
+            Column(verticalArrangement = Arrangement.spacedBy(6.dp)) {
+                Text("Good day, ${currentUser.firstName}", style = MaterialTheme.typography.headlineSmall, fontWeight = FontWeight.Bold)
+                Text("${filteredTasks.size} tasks visible", color = MaterialTheme.colorScheme.onSurfaceVariant)
+            }
+        }
+        item {
+            OutlinedTextField(
+                value = searchQuery,
+                onValueChange = onSearchChange,
+                modifier = Modifier.fillMaxWidth(),
+                leadingIcon = { Icon(Icons.Outlined.Search, contentDescription = null) },
+                placeholder = { Text("Search tasks") }
+            )
+        }
+        item {
+            Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
+                TaskFilter.entries.forEach { filter ->
+                    FilterChip(selected = filter == activeFilter, onClick = { onFilterChange(filter) }, label = { Text(filter.name) })
+                }
+            }
+        }
+        item {
+            Button(onClick = onCreateTask) {
+                Icon(Icons.Outlined.Add, contentDescription = null)
+                Spacer(Modifier.width(8.dp))
+                Text("New task")
+            }
+        }
+
+        if (filteredTasks.isEmpty()) {
+            item { EmptyStateCard(title = "All caught up!", body = "No tasks match this filter") }
+        } else {
+            items(filteredTasks, key = { it.id }) { task ->
+                ElevatedCard(onClick = { onSelectTask(task.id) }) {
+                    Row(
+                        modifier = Modifier.fillMaxWidth(),
+                        horizontalArrangement = Arrangement.SpaceBetween,
+                        verticalAlignment = Alignment.CenterVertically
+                    ) {
+                        Column(modifier = Modifier.weight(1f)) {
+                            Text(task.title, fontWeight = FontWeight.SemiBold)
+                            Text(task.tags.joinToString(", "), color = MaterialTheme.colorScheme.onSurfaceVariant)
+                        }
+                        PriorityDot(task.priority.color)
+                    }
+                }
+            }
+        }
+        item { Spacer(Modifier.height(80.dp)) }
+    }
+}