SettingsStore.kt

package to.bitkit.data

import android.content.Context
import androidx.datastore.core.DataStore
import androidx.datastore.dataStore
import dagger.hilt.android.qualifiers.ApplicationContext
import kotlinx.coroutines.flow.Flow
import kotlinx.serialization.Serializable
import to.bitkit.data.serializers.SettingsSerializer
import to.bitkit.env.Env
import to.bitkit.models.BitcoinDisplayUnit
import to.bitkit.models.CoinSelectionPreference
import to.bitkit.models.PrimaryDisplay
import to.bitkit.models.SettingsBackupV1
import to.bitkit.models.Suggestion
import to.bitkit.models.TransactionSpeed
import to.bitkit.utils.Logger
import javax.inject.Inject
import javax.inject.Singleton

private val Context.settingsDataStore: DataStore<SettingsData> by dataStore(
    fileName = "settings.json",
    serializer = SettingsSerializer,
)

@Singleton
class SettingsStore @Inject constructor(
    @ApplicationContext private val context: Context,
) {
    private val store = context.settingsDataStore

    val data: Flow<SettingsData> = store.data

    suspend fun restoreFromBackup(payload: SettingsBackupV1) =
        runCatching {
            val data = payload.settings.resetPin()
            store.updateData { data }
        }.onSuccess {
            Logger.debug("Restored settings", TAG)
        }

    suspend fun update(transform: (SettingsData) -> SettingsData) {
        store.updateData(transform)
    }

    suspend fun addLastUsedTag(newTag: String) {
        store.updateData { currentSettings ->
            val combinedTags = (listOf(newTag) + currentSettings.lastUsedTags).distinct()
            val limitedTags = combinedTags.take(MAX_LAST_USED_TAGS)
            currentSettings.copy(lastUsedTags = limitedTags)
        }
    }

    suspend fun deleteLastUsedTag(tag: String) {
        store.updateData { currentSettings ->
            currentSettings.copy(lastUsedTags = currentSettings.lastUsedTags.filter { it != tag })
        }
    }

    suspend fun addDismissedSuggestion(suggestion: Suggestion) {
        store.updateData { currentSettings ->
            val updatedDismissedSuggestions = (currentSettings.dismissedSuggestions + suggestion.name).distinct()
            currentSettings.copy(dismissedSuggestions = updatedDismissedSuggestions)
        }
    }

    suspend fun reset() {
        store.updateData { SettingsData() }
        Logger.info("Deleted all user settings data.")
    }

    companion object {
        private const val TAG = "SettingsStore"
        private const val MAX_LAST_USED_TAGS = 10
    }
}

@Serializable
data class SettingsData(
    val primaryDisplay: PrimaryDisplay = PrimaryDisplay.BITCOIN,
    val displayUnit: BitcoinDisplayUnit = BitcoinDisplayUnit.MODERN,
    val selectedCurrency: String = "USD",
    val defaultTransactionSpeed: TransactionSpeed = TransactionSpeed.default(),
    val showEmptyBalanceView: Boolean = true,
    val hasSeenSpendingIntro: Boolean = false,
    val hasSeenWidgetsIntro: Boolean = false,
    val hasSeenTransferIntro: Boolean = false,
    val hasSeenSavingsIntro: Boolean = false,
    val hasSeenShopIntro: Boolean = false,
    val hasSeenProfileIntro: Boolean = false,
    val quickPayIntroSeen: Boolean = false,
    val bgPaymentsIntroSeen: Boolean = false,
    val isQuickPayEnabled: Boolean = false,
    val quickPayAmount: Int = 5,
    val lightningSetupStep: Int = 0,
    val isPinEnabled: Boolean = false,
    val isBiometricEnabled: Boolean = false,
    val isPinForPaymentsEnabled: Boolean = false,
    val isDevModeEnabled: Boolean = Env.isDebug,
    val showWidgets: Boolean = true,
    val showWidgetTitles: Boolean = false,
    val lastUsedTags: List<String> = emptyList(),
    val enableSwipeToHideBalance: Boolean = true,
    val hideBalance: Boolean = false,
    val hideBalanceOnOpen: Boolean = false,
    val enableAutoReadClipboard: Boolean = false,
    val enableSendAmountWarning: Boolean = false,
    val backupVerified: Boolean = false,
    val notificationsGranted: Boolean = false,
    val showNotificationDetails: Boolean = true,
    val dismissedSuggestions: List<String> = emptyList(),
    val balanceWarningIgnoredMillis: Long = 0,
    val backupWarningIgnoredMillis: Long = 0,
    val notificationsIgnoredMillis: Long = 0,
    val balanceWarningTimes: Int = 0,
    val coinSelectAuto: Boolean = true,
    val coinSelectPreference: CoinSelectionPreference = CoinSelectionPreference.BranchAndBound,
    val electrumServer: String = Env.electrumServerUrl,
    val rgsServerUrl: String? = Env.ldkRgsServerUrl,
)

fun SettingsData.resetPin() = this.copy(
    isPinEnabled = false,
    isPinForPaymentsEnabled = false,
    isBiometricEnabled = false,
)