Pith - spline
package com.vgmlr.spline

import android.content.Context
import android.content.SharedPreferences
import androidx.core.content.edit

private const val DAY = 86_400_000L

internal enum class SplineInterval(val label: String, val ms: Long) {
    NONE("None", 0L),
    DAILY("Daily", DAY),
    WEEKLY("Weekly", 7 * DAY),
    MONTHLY("Monthly", 30 * DAY);

    companion object {
        fun of(label: String): SplineInterval = entries.firstOrNull { it.label == label } ?: DAILY
    }
}

internal data class SplinePending(val dl: Long, val id: String, val version: String) {
    fun encode(): String = "$dl|$id|$version"

    companion object {
        fun decode(s: String): SplinePending? {
            val f = s.split('|')
            if (f.size != 3) return null
            val dl = f[0].toLongOrNull() ?: return null
            return SplinePending(dl, f[1], f[2])
        }
    }
}

internal object SplinePrefs {
    private const val FILE = "spline"
    private const val K_INTERVAL = "interval"
    private const val K_LAST = "last_scan"
    private const val K_PENDING = "pending"
    private const val K_PERMIT = "permit"
    private const val K_NOTIFY = "notify"

    private fun sp(ctx: Context): SharedPreferences =
        ctx.getSharedPreferences(FILE, Context.MODE_PRIVATE)

    fun interval(ctx: Context): SplineInterval {
        val name = sp(ctx).getString(K_INTERVAL, null) ?: return SplineInterval.DAILY
        return SplineInterval.entries.firstOrNull { it.name == name } ?: SplineInterval.DAILY
    }

    fun setInterval(ctx: Context, v: SplineInterval) {
        sp(ctx).edit { putString(K_INTERVAL, v.name) }
    }

    fun lastScan(ctx: Context): Long = sp(ctx).getLong(K_LAST, 0L)

    fun setLastScan(ctx: Context, t: Long) {
        sp(ctx).edit { putLong(K_LAST, t) }
    }

    fun permitAsked(ctx: Context): Boolean = sp(ctx).getBoolean(K_PERMIT, false)

    fun setPermitAsked(ctx: Context) {
        sp(ctx).edit { putBoolean(K_PERMIT, true) }
    }

    fun notifyOn(ctx: Context): Boolean = sp(ctx).getBoolean(K_NOTIFY, true)

    fun setNotifyOn(ctx: Context, v: Boolean) {
        sp(ctx).edit { putBoolean(K_NOTIFY, v) }
    }

    @Synchronized
    fun pending(ctx: Context): List<SplinePending> =
        sp(ctx).getStringSet(K_PENDING, null).orEmpty().mapNotNull(SplinePending::decode)

    @Synchronized
    fun addPending(ctx: Context, p: SplinePending) {
        val set = HashSet(sp(ctx).getStringSet(K_PENDING, null).orEmpty())
        set += p.encode()
        sp(ctx).edit { putStringSet(K_PENDING, set) }
    }

    @Synchronized
    fun removePending(ctx: Context, dl: Long) {
        val set = sp(ctx).getStringSet(K_PENDING, null).orEmpty()
            .filterTo(HashSet()) { SplinePending.decode(it)?.dl != dl }
        sp(ctx).edit { putStringSet(K_PENDING, set) }
    }
}