package com.rizoma.trazo.data

import android.content.Context
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.setValue
import androidx.datastore.core.DataStore
import androidx.datastore.preferences.core.MutablePreferences
import androidx.datastore.preferences.core.Preferences
import androidx.datastore.preferences.core.booleanPreferencesKey
import androidx.datastore.preferences.core.edit
import androidx.datastore.preferences.core.stringPreferencesKey
import androidx.datastore.preferences.preferencesDataStore
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.launch

/** Intensidad del retorno háptico al teclear. */
enum class HapticLevel { SUAVE, MEDIO, FUERTE }

private val Context.trazoSettingsStore: DataStore<Preferences> by preferencesDataStore(name = "trazo_settings")

/**
 * Preferencias de Trazo, persistidas en DataStore y expuestas como estado de Compose.
 * Un único colector mantiene en sincronía cualquier instancia (la del IME y la de la
 * pantalla de ajustes), así que tocar un toggle se refleja al instante en el teclado.
 */
class TrazoSettings(context: Context, private val scope: CoroutineScope) {

    private val store = context.applicationContext.trazoSettingsStore

    var haptics by mutableStateOf(true); private set
    var hapticLevel by mutableStateOf(HapticLevel.MEDIO); private set
    var doubleSpacePeriod by mutableStateOf(true); private set
    var spanish by mutableStateOf(true); private set
    var english by mutableStateOf(true); private set
    var recentEmojis by mutableStateOf<List<String>>(emptyList()); private set

    init {
        scope.launch {
            store.data.collect { p ->
                haptics = p[HAPTICS] ?: true
                hapticLevel = runCatching { HapticLevel.valueOf(p[HAPTIC_LEVEL] ?: "") }
                    .getOrDefault(HapticLevel.MEDIO)
                doubleSpacePeriod = p[DOUBLE_SPACE] ?: true
                spanish = p[LANG_ES] ?: true
                english = p[LANG_EN] ?: true
                recentEmojis = p[RECENT_EMOJIS]?.split(" ")?.filter { it.isNotEmpty() } ?: emptyList()
            }
        }
    }

    fun setHaptics(v: Boolean) = persist { it[HAPTICS] = v }
    fun setHapticLevel(v: HapticLevel) = persist { it[HAPTIC_LEVEL] = v.name }
    fun setDoubleSpacePeriod(v: Boolean) = persist { it[DOUBLE_SPACE] = v }
    fun setSpanish(v: Boolean) = persist { it[LANG_ES] = v }
    fun setEnglish(v: Boolean) = persist { it[LANG_EN] = v }

    /** Empuja un emoji a la cabeza de "recientes" (sin duplicar, acotado). */
    fun pushRecentEmoji(e: String) {
        val updated = (listOf(e) + recentEmojis.filter { it != e }).take(RECENTS_MAX)
        persist { it[RECENT_EMOJIS] = updated.joinToString(" ") }
    }

    private fun persist(block: (MutablePreferences) -> Unit) {
        scope.launch(Dispatchers.IO) { runCatching { store.edit(block) } }
    }

    private companion object {
        val HAPTICS = booleanPreferencesKey("haptics")
        val HAPTIC_LEVEL = stringPreferencesKey("haptic_level")
        val DOUBLE_SPACE = booleanPreferencesKey("double_space_period")
        val LANG_ES = booleanPreferencesKey("lang_es")
        val LANG_EN = booleanPreferencesKey("lang_en")
        val RECENT_EMOJIS = stringPreferencesKey("recent_emojis")
        const val RECENTS_MAX = 24
    }
}