Phase 7: 2-step category create/edit flow, scale settings step, alarms on edit

LESSONS.md

@@ -129,6 +129,9 @@ When implementing the merge itself: don't reach for a `deleteLogsForPeriod`-styl
 **Derive range entities from per-unit facts; keep the derived rows persistent for consumers**
 When a domain concept is really a series of per-unit facts (a period is days of menstruation, a streak is days of activity), storing it as a single start/end record forces every attribute to be range-global (one flow level for a five-day period) and breeds edge-case bugs at the boundaries (extend, bridge, fragment, reopen). Store the per-unit facts as the source of truth and derive the range records by grouping under a tolerance rule, rebuilding after every mutation. Keep the derived rows persisted in the old table with stable ids (match old rows to new groups by span overlap, earliest survivor wins) so every existing consumer — stats, widgets, export, reminders — keeps reading the same schema. "Ongoing" then stops being a fragile nullable-end guess: a range is open while its last unit is within the tolerance window of today, and a scheduled reconcile closes it at its true last unit otherwise.
 
+**Gate a storage-representation field on dependent data existing, not on a blanket "immutable after creation" rule**
+When a field decides how dependent rows are encoded (a category's input type deciding whether logs hold labels, counts, or numbers), "immutable after creation" is stricter than the real invariant and blocks harmless fixes (user picked the wrong type before ever logging). The true constraint is "no dependent data may be reinterpreted": compute it live with a COUNT over the dependent table at edit time, lock the control only when rows exist, and say why in the UI in one plain sentence. Enforce the same guard again in the save/repository path (the UI check can be stale or bypassed), and don't cache the lock in a stored flag — a count is always current, survives deletion of the dependent rows, and needs no migration.
+
 **Insert/upsert flags need a separate edit-by-ID path**
 A flag like `allowMultiple` controls whether saving a log upserts an existing row (keyed by date + category) or always inserts a new one. Neither branch handles "update this specific existing row by ID." Routing an edit through `allowMultiple = false` works only when the existing row is uniquely keyed by the natural key; using `allowMultiple = true` creates a duplicate instead. The correct pattern is a dedicated `updateInPlace(existingLog, …)` method. Callers check `existingLog != null` and take this path directly, bypassing the insert/upsert decision entirely.
 

app/src/main/java/com/mapgie/goflo/MainActivity.kt

@@ -51,6 +51,8 @@ import com.mapgie.goflo.ui.screens.auth.LockViewModel
 import com.mapgie.goflo.ui.screens.auth.PinSetupScreen
 import com.mapgie.goflo.ui.screens.auth.PinSetupViewModel
 import com.mapgie.goflo.ui.screens.disclaimer.DisclaimerScreen
+import com.mapgie.goflo.ui.screens.categories.CategoryEditScreen
+import com.mapgie.goflo.ui.screens.categories.CategoryEditViewModel
 import com.mapgie.goflo.ui.screens.categories.ManageCategoriesScreen
 import com.mapgie.goflo.ui.screens.categories.ManageCategoriesViewModel
 import com.mapgie.goflo.ui.screens.categories.ManageCategoryValuesScreen
@@ -535,10 +537,55 @@ private fun MainNavHost(app: GoFloApplication, currentTheme: AppTheme, pendingCa
                     onNavigateBack = { navController.popBackStack() },
                     onNavigateToCategory = { categoryId ->
                         navController.navigate(Screen.ManageCategoryValues.forCategory(categoryId))
+                    },
+                    onNavigateToCreateCategory = { groupId ->
+                        navController.navigate(
+                            if (groupId != null) Screen.CategoryEdit.newInGroup(groupId)
+                            else Screen.CategoryEdit.newCategory
+                        )
                     }
                 )
             }
 
+            // ── Category create/edit flow (logging redesign Phase 7) ──────────────
+
+            composable(
+                route = Screen.CategoryEdit.route,
+                arguments = listOf(
+                    navArgument("categoryId") { type = NavType.LongType; defaultValue = -1L },
+                    navArgument("groupId") { type = NavType.LongType; defaultValue = -1L },
+                )
+            ) { backStack ->
+                val categoryId = backStack.arguments?.getLong("categoryId") ?: -1L
+                val groupId = backStack.arguments?.getLong("groupId") ?: -1L
+                val vm: CategoryEditViewModel = viewModel(
+                    key = "category_edit_${categoryId}_$groupId",
+                    factory = CategoryEditViewModel.Factory(
+                        categoryId, groupId,
+                        app.trackingRepository, app.customAlarmRepository, app.applicationContext
+                    )
+                )
+                CategoryEditScreen(
+                    viewModel = vm,
+                    onNavigateBack = { navController.popBackStack() },
+                    onCreated = { newId, categoryType ->
+                        navController.popBackStack()
+                        // Default (list-of-values) categories continue to the values
+                        // screen so the user can add their options; every other type
+                        // is fully configured by the create flow already.
+                        if (categoryType == "default") {
+                            navController.navigate(Screen.ManageCategoryValues.forCategory(newId))
+                        }
+                    },
+                    onNavigateToNewAlarm = {
+                        navController.navigate(Screen.EditAlarm.newForCategory(categoryId))
+                    },
+                    onNavigateToEditAlarm = { alarmId ->
+                        navController.navigate(Screen.EditAlarm.forAlarm(alarmId))
+                    },
+                )
+            }
+
             composable(
                 route = Screen.ManageCategoryValues.route,
                 arguments = listOf(navArgument("categoryId") { type = NavType.LongType })
@@ -559,6 +606,9 @@ private fun MainNavHost(app: GoFloApplication, currentTheme: AppTheme, pendingCa
                     onNavigateToEditAlarm = { alarmId ->
                         navController.navigate(Screen.EditAlarm.forAlarm(alarmId))
                     },
+                    onNavigateToEditCategory = {
+                        navController.navigate(Screen.CategoryEdit.forCategory(categoryId))
+                    },
                 )
             }
 

app/src/main/java/com/mapgie/goflo/data/database/dao/TrackingLogDao.kt

@@ -36,6 +36,10 @@ interface TrackingLogDao {
     @Query("SELECT * FROM tracking_logs WHERE date = :date AND categoryId = :categoryId ORDER BY loggedAt ASC, id ASC")
     suspend fun getLogsForDateAndCategory(date: String, categoryId: Long): List<TrackingLog>
 
+    /** Number of tracking log rows recorded for [categoryId], across all dates. */
+    @Query("SELECT COUNT(*) FROM tracking_logs WHERE categoryId = :categoryId")
+    suspend fun countLogsForCategory(categoryId: Long): Int
+
     @Insert(onConflict = OnConflictStrategy.REPLACE)
     suspend fun insertLog(log: TrackingLog): Long
 

app/src/main/java/com/mapgie/goflo/data/repository/TrackingRepository.kt

@@ -390,6 +390,17 @@ class TrackingRepository(
         return newCount
     }
 
+    /**
+     * True when at least one tracking log exists for the category.
+     *
+     * Used by the category edit flow (logging redesign Phase 7) to decide
+     * whether the input type is still editable: the owner-decided rule is
+     * "the type is fixed once logged" — computed here from the presence of
+     * dependent data rather than stored as a flag.
+     */
+    suspend fun hasLogs(categoryId: Long): Boolean =
+        logDao.countLogsForCategory(categoryId) > 0
+
     /** Returns the existing log (with values) for a specific (date, category), or null. */
     suspend fun getExistingLog(date: LocalDate, categoryId: Long): TrackingLogWithValues? {
         val log = logDao.getLogForDateAndCategory(date.toString(), categoryId) ?: return null

app/src/main/java/com/mapgie/goflo/ui/navigation/Screen.kt

@@ -39,6 +39,18 @@ sealed class Screen(val route: String) {
         fun forCategory(id: Long) = "manage_category_values/$id"
     }
 
+    /**
+     * The 2-step category create/edit flow (logging redesign Phase 7).
+     * - [categoryId] `> 0` edits an existing category; `-1` creates a new one.
+     * - [groupId] `> 0` (create only) files the new category into that group on
+     *   save and pre-selects the group's default input type.
+     */
+    data object CategoryEdit : Screen("category_edit?categoryId={categoryId}&groupId={groupId}") {
+        val newCategory = "category_edit?categoryId=-1&groupId=-1"
+        fun newInGroup(groupId: Long) = "category_edit?categoryId=-1&groupId=$groupId"
+        fun forCategory(categoryId: Long) = "category_edit?categoryId=$categoryId&groupId=-1"
+    }
+
     // ── Custom alarms ──────────────────────────────────────────────────────────
 
     data object CustomAlarms : Screen("custom_alarms")