Arsitektur Android Modern.

┌──────────── UI layer ────────────┐
│  Composable  ◀── StateFlow ──  ViewModel
│      │ event (onRetry, onQuery)      │
└──────┼───────────────────────────────┼──┘
       ▼                               ▼
┌──────────── Data layer ──────────────────┐
│            NotificationRepository        │
│   Room (riwayat)  DataStore (config)  Retrofit (API)
│                     SendScheduler → WorkManager
└──────────────────────────────────────────┘

data class HistoryUiState(
    val items: List<NotificationEntity> = emptyList(),
    val query: String = "",
    val isLoading: Boolean = true,
)

class HistoryViewModel(private val repository: NotificationRepository) : ViewModel() {

    private val query = MutableStateFlow("")

    val uiState: StateFlow<HistoryUiState> =
        combine(repository.notifications, query) { all, q ->
            HistoryUiState(
                items = all.filter { q.isBlank() || it.title.orEmpty().contains(q, ignoreCase = true) },
                query = q,
                isLoading = false,
            )
        }
            .flowOn(Dispatchers.Default)          // filter/grouping di luar main thread
            .stateIn(
                scope = viewModelScope,
                started = SharingStarted.WhileSubscribed(5_000),
                initialValue = HistoryUiState(),
            )

    private val _messages = MutableSharedFlow<String>(extraBufferCapacity = 4)
    val messages = _messages.asSharedFlow()        // event sekali jalan (snackbar)

    fun onQueryChange(value: String) { query.value = value }

    fun retry(id: Long) = viewModelScope.launch {
        repository.retry(id)
        _messages.tryEmit("Dimasukkan ke antrean kirim")
    }
}

@Entity(tableName = "notifications", indices = [Index("status"), Index("postTime")])
data class NotificationEntity(
    @PrimaryKey(autoGenerate = true) val id: Long = 0,
    val packageName: String,
    val title: String?,
    val text: String?,
    val postTime: Long,
    @ColumnInfo(defaultValue = "PENDING") val status: String = "PENDING",
    val retryCount: Int = 0,
)

@Dao
interface NotificationDao {
    @Insert suspend fun insert(entity: NotificationEntity): Long

    @Query("SELECT * FROM notifications ORDER BY postTime DESC")
    fun observeAll(): Flow<List<NotificationEntity>>          // otomatis emit saat tabel berubah

    @Query("SELECT * FROM notifications WHERE status IN ('PENDING', 'FAILED')")
    suspend fun getRetryable(): List<NotificationEntity>

    @Query("UPDATE notifications SET status = :status WHERE id = :id")
    suspend fun updateStatus(id: Long, status: String)
}

@Database(entities = [NotificationEntity::class], version = 1, exportSchema = true)
abstract class AppDatabase : RoomDatabase() {
    abstract fun notificationDao(): NotificationDao
}

// satu instance untuk seluruh aplikasi
val db = Room.databaseBuilder(appContext, AppDatabase::class.java, "notifly.db").build()

private val Context.dataStore by preferencesDataStore(name = "notifly_config")   // top-level, sekali

data class AppConfig(val serverUrl: String = "", val keywords: Set<String> = emptySet(), val retentionDays: Int = 30)

class ConfigDataStore(private val context: Context) {
    private object Keys {
        val SERVER_URL = stringPreferencesKey("server_url")
        val KEYWORDS = stringSetPreferencesKey("keywords")
        val RETENTION_DAYS = intPreferencesKey("retention_days")
    }

    val config: Flow<AppConfig> = context.dataStore.data.map { p ->
        AppConfig(
            serverUrl = p[Keys.SERVER_URL].orEmpty(),
            keywords = p[Keys.KEYWORDS].orEmpty(),
            retentionDays = p[Keys.RETENTION_DAYS] ?: 30,
        )
    }

    suspend fun current(): AppConfig = config.first()

    suspend fun setServerUrl(url: String) = context.dataStore.edit { it[Keys.SERVER_URL] = url.trim() }

    suspend fun addKeyword(k: String) = context.dataStore.edit {
        it[Keys.KEYWORDS] = it[Keys.KEYWORDS].orEmpty() + k.trim().lowercase()
    }
}

class SendNotificationWorker(ctx: Context, params: WorkerParameters) : CoroutineWorker(ctx, params) {
    override suspend fun doWork(): Result {
        val id = inputData.getLong(KEY_ID, -1L)
        if (id <= 0L) return Result.failure()
        val repo = (applicationContext as NotiFlyApplication).container.notificationRepository
        val entity = repo.getById(id) ?: return Result.success()        // sudah dihapus

        return when (val r = repo.send(entity)) {
            is SendResult.Success -> { repo.markSent(id); Result.success() }
            is SendResult.Permanent -> { repo.markFailed(id, r.message); Result.failure() }
            is SendResult.Retryable ->
                if (runAttemptCount + 1 >= MAX_ATTEMPTS) { repo.markFailed(id, r.message); Result.failure() }
                else Result.retry()                                    // backoff diatur WorkManager
        }
    }
    companion object { const val KEY_ID = "notification_id"; const val MAX_ATTEMPTS = 3 }
}

fun enqueueSend(workManager: WorkManager, id: Long) {
    val request = OneTimeWorkRequestBuilder<SendNotificationWorker>()
        .setInputData(workDataOf(SendNotificationWorker.KEY_ID to id))
        .setConstraints(Constraints.Builder().setRequiredNetworkType(NetworkType.CONNECTED).build())
        .setBackoffCriteria(BackoffPolicy.EXPONENTIAL, 30, TimeUnit.SECONDS)
        .build()
    // unik per item; REPLACE agar retry manual menggantikan antrean lama
    workManager.enqueueUniqueWork("send-$id", ExistingWorkPolicy.REPLACE, request)
}

// pembersihan riwayat harian; KEEP agar jadwal tidak ter-reset setiap app dibuka
fun schedulePruning(workManager: WorkManager) =
    workManager.enqueueUniquePeriodicWork(
        "prune-history", ExistingPeriodicWorkPolicy.KEEP,
        PeriodicWorkRequestBuilder<PruneHistoryWorker>(1, TimeUnit.DAYS).build(),
    )

class AppContainer(context: Context) {
    private val appContext = context.applicationContext

    val configDataStore by lazy { ConfigDataStore(appContext) }
    private val database by lazy {
        Room.databaseBuilder(appContext, AppDatabase::class.java, "notifly.db").build()
    }
    private val apiService by lazy { ApiClient.create() }
    private val workManager by lazy { WorkManager.getInstance(appContext) }

    val notificationRepository by lazy {
        NotificationRepository(database.notificationDao(), configDataStore, apiService, workManager)
    }
}

class NotiFlyApplication : Application() {
    lateinit var container: AppContainer
        private set

    override fun onCreate() {
        super.onCreate()
        container = AppContainer(this)
    }
}

// Satu factory untuk semua ViewModel
object ViewModelFactory {
    val Factory = viewModelFactory {
        initializer {
            val app = this[ViewModelProvider.AndroidViewModelFactory.APPLICATION_KEY] as NotiFlyApplication
            HistoryViewModel(app.container.notificationRepository)
        }
    }
}

// di Compose
val vm: HistoryViewModel = viewModel(factory = ViewModelFactory.Factory)