Pocket Notes with Room

import java.util.Date

class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent { MiniTheme { PocketNotesApp() } }
    }
}

@Composable
private fun PocketNotesApp() {
    val controller = rememberNavController()
    NavHost(controller, startDestination = "notes") {
        composable("notes") {
            NotesList(
                onAdd = { controller.navigate("new") },
                onOpen = { id -> controller.navigate("edit/$id") },
            )
        }
        composable("new") { NoteEditor(null, onBack = { controller.popBackStack() }) }
        composable(
            "edit/{id}",
            arguments = listOf(navArgument("id") { type = NavType.LongType }),
        ) { entry ->
            NoteEditor(entry.arguments!!.getLong("id"), onBack = { controller.popBackStack() })
        }

@Entity(tableName = "notes")
data class Note(
    @PrimaryKey(autoGenerate = true) val id: Long = 0,
    val title: String,
    val body: String,
    val updatedAt: Long,
)

@Dao
interface NoteDao {
    @Query("SELECT * FROM notes ORDER BY updatedAt DESC, id DESC")
    fun observeAll(): Flow<List<Note>>

    @Query("SELECT * FROM notes WHERE id = :id")
    suspend fun find(id: Long): Note?

    @Insert
    suspend fun insert(note: Note): Long

    @Update
    suspend fun update(note: Note): Int

    @Query("DELETE FROM notes WHERE id = :id")
    suspend fun delete(id: Long): Int
}

@Dao
interface NoteDao {
    @Query("SELECT * FROM notes ORDER BY updatedAt DESC, id DESC")
    fun observeAll(): Flow<List<Note>>

    @Query("SELECT * FROM notes WHERE id = :id")
    suspend fun find(id: Long): Note?

    @Insert
    suspend fun insert(note: Note): Long

    @Update
    suspend fun update(note: Note): Int

    @Query("DELETE FROM notes WHERE id = :id")
    suspend fun delete(id: Long): Int
}

@Database(entities = [Note::class], version = 1, exportSchema = false)
abstract class NotesDatabase : RoomDatabase() {
    abstract fun noteDao(): NoteDao

    companion object {
        @Volatile private var instance: NotesDatabase? = null

        @Volatile private var instance: NotesDatabase? = null

        fun get(context: Context): NotesDatabase = instance ?: synchronized(this) {
            instance ?: Room.databaseBuilder(
                context.applicationContext,
                NotesDatabase::class.java,
                "pocket-notes.db",
            ).build().also { instance = it }
        }
    }
}

@OptIn(ExperimentalCoroutinesApi::class)
class NotesViewModel(application: Application) : AndroidViewModel(application) {
    private val dao = NotesDatabase.get(application).noteDao()
    private val refresh = MutableStateFlow(0)
    val state = refresh.flatMapLatest {
        dao.observeAll()
            .map<List<Note>, NotesListState> { NotesListState.Ready(it) }
            .onStart { emit(NotesListState.Loading) }
            .catch { emit(NotesListState.Failed) }
    }.stateIn(viewModelScope, SharingStarted.WhileSubscribed(5_000), NotesListState.Loading)

    fun retry() { refresh.update { it + 1 } }
}

enum class NoteProblem { LoadFailed, Missing, WriteFailed }

data class EditorState(
    val title: String = "",
    val body: String = "",
    val loading: Boolean = false,
    val busy: Boolean = false,
    val titleError: Boolean = false,
    val problem: NoteProblem? = null,
    val finished: Boolean = false,
)

@Composable
private fun NoteEditor(id: Long?, onBack: () -> Unit) {
    val applicationContext = LocalContext.current.applicationContext
    val factory = remember(applicationContext, id) {
        viewModelFactory {
            initializer {
                NoteEditorViewModel(NotesDatabase.get(applicationContext).noteDao(), id, createSavedStateHandle())
            }
        }
    }
    // Navigation supplies a distinct ViewModelStoreOwner for each editor back-stack entry.
    val model: NoteEditorViewModel = viewModel(factory = factory)
    val state by model.state.collectAsStateWithLifecycle()
    var confirmDelete by rememberSaveable { mutableStateOf(false) }
    LaunchedEffect(state.finished) { if (state.finished) onBack() }
    MiniScreen(stringResource(if (id == null) R.string.add_note else R.string.edit_note)) {
        TextButton(onClick = onBack, enabled = !state.busy) { Text(stringResource(R.string.back)) }
        Text(stringResource(R.string.draft_help), style = MaterialTheme.typography.bodySmall)
        if (state.loading) {
            CircularProgressIndicator()
        } else if (state.problem == NoteProblem.LoadFailed || state.problem == NoteProblem.Missing) {
            Text(stringResource(if (state.problem == NoteProblem.Missing) R.string.note_missing else R.string.load_failed))
            if (state.problem == NoteProblem.LoadFailed) {
                Button(onClick = model::load) { Text(stringResource(R.string.retry)) }
            }

    }

    fun save() {
        if (state.value.busy || state.value.loading || state.value.finished) return
        val title = cleanTitle(state.value.title)
        if (title == null) {
            _state.update { it.copy(titleError = true) }
            return
        }
        val body = state.value.body
        _state.update { it.copy(busy = true, problem = null) }
        viewModelScope.launch {
            try {
                val existingId = recordId
                val note = Note(existingId ?: 0, title, body, System.currentTimeMillis())
                if (existingId == null) {
                    recordId = dao.insert(note)
                    saved["recordId"] = recordId
                } else if (dao.update(note) != 1) {
                    _state.update { it.copy(busy = false, problem = NoteProblem.Missing) }
                    return@launch
                }
                _state.update { it.copy(busy = false, finished = true) }
            } catch (cancelled: CancellationException) {
                throw cancelled
            } catch (_: Exception) {

    }

    fun delete() {
        val id = recordId ?: return
        if (state.value.busy || state.value.loading || state.value.finished) return
        _state.update { it.copy(busy = true, problem = null) }
        viewModelScope.launch {
            try {
                dao.delete(id)
                _state.update { it.copy(busy = false, finished = true) }
            } catch (cancelled: CancellationException) {
                throw cancelled
            } catch (_: Exception) {
                _state.update { it.copy(busy = false, problem = NoteProblem.WriteFailed) }
            }
        }
    }
}

                context.applicationContext,
                NotesDatabase::class.java,
                "pocket-notes.db",
            ).build().also { instance = it }
        }
    }
}

class NotesDatabaseTest {
    @Test
    fun observesChangesAndRetainsEditedRowsAfterReopen() = runBlocking {
        val context = InstrumentationRegistry.getInstrumentation().targetContext
        // A unique test-only filename keeps the student's real notebook untouched.
        val filename = "notes-instrumented-${UUID.randomUUID()}.db"
        fun openDatabase(): NotesDatabase = Room.databaseBuilder(
            context, NotesDatabase::class.java, filename,
        ).build()
        var database = openDatabase()
        val emissions = Channel<List<Note>>(Channel.UNLIMITED)
        val watcher = launch {
            database.noteDao().observeAll().collect { emissions.send(it) }
        }
        try {
            // Waiting for the initial emission ensures the collector is active before writing.
            assertTrue(withTimeout(5_000) { emissions.receive() }.isEmpty())
            val keptId = database.noteDao().insert(Note(title = "First", body = "Before", updatedAt = 100L))
            val added = emissions.awaitRows { rows -> rows.any { it.id == keptId } }
            assertEquals("Before", added.first { it.id == keptId }.body)

            val deletedId = database.noteDao().insert(Note(title = "Temporary", body = "Remove", updatedAt = 200L))
            emissions.awaitRows { it.size == 2 }
            assertEquals(1, database.noteDao().update(Note(keptId, "Edited", "After", 300L)))
            val updated = emissions.awaitRows { rows -> rows.any { it.id == keptId && it.body == "After" } }
            assertEquals(keptId, updated.first().id) // Newest timestamp is sorted first.