package com.vgmlr.wedge

import android.content.Context
import androidx.room.*
import androidx.datastore.preferences.core.*
import androidx.datastore.preferences.preferencesDataStore
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.map
import androidx.compose.ui.graphics.Color
import androidx.core.graphics.toColorInt

@Entity(tableName = "notes")
data class NoteEntity(
    @PrimaryKey val id: Int = 1,
    val content: String = "",
    val lastModified: Long = System.currentTimeMillis()
)

@Dao
interface NoteDao {
    @Query("SELECT * FROM notes WHERE id = 1")
    fun getNote(): Flow<NoteEntity?>

    @Query("SELECT * FROM notes WHERE id = 1")
    suspend fun getNoteSync(): NoteEntity?

    @Insert(onConflict = OnConflictStrategy.REPLACE)
    suspend fun save(note: NoteEntity)
}

@Database(entities = [NoteEntity::class], version = 3, exportSchema = false)
abstract class AppDatabase : RoomDatabase() {
    abstract fun noteDao(): NoteDao
    companion object {
        @Volatile private var INSTANCE: AppDatabase? = null
        fun getInstance(context: Context): AppDatabase = INSTANCE ?: synchronized(this) {
            val instance = Room.databaseBuilder(context.applicationContext, AppDatabase::class.java, "wedge_db")
                .fallbackToDestructiveMigration()
                .build()
            INSTANCE = instance
            instance
        }
    }
}

private val Context.dataStore by preferencesDataStore("settings")

data class SettingsState(
    val textColor: String = WedgeConfig.TEXT_COLOR_DEFAULT,
    val bgColor: String = WedgeConfig.BG_COLOR_DEFAULT,
    val widgetTextColor: String = WedgeConfig.WIDGET_TEXT_COLOR_DEFAULT,
    val widgetBgColor: String = WedgeConfig.WIDGET_BG_COLOR_DEFAULT,
    val editorFontSize: Float = WedgeConfig.FONT_SIZE_DEFAULT,
    val widgetFontSize: Float = WedgeConfig.WIDGET_FONT_SIZE_DEFAULT,
    val lineHeight: Float = WedgeConfig.LINE_HEIGHT_DEFAULT,
    val boldColor: String = WedgeConfig.BOLD_COLOR_DEFAULT,
    val incognitoMode: Boolean = false,
    val passKey: String = "wedge03569"
)

class PreferenceManager(private val context: Context) {
    private val keyTextCol = stringPreferencesKey("text_color")
    private val keyBgCol = stringPreferencesKey("bg_color")
    private val keyWTextCol = stringPreferencesKey("widget_text_color")
    private val keyWBgCol = stringPreferencesKey("widget_bg_color")
    private val keyBoldCol = stringPreferencesKey("bold_color")
    private val keyIncognito = booleanPreferencesKey("incognito_mode")
    private val keyESize = floatPreferencesKey("editor_font_size_abs")
    private val keyWSize = floatPreferencesKey("widget_font_size_abs")
    private val keyWidgetBoldCol = stringPreferencesKey("widget_bold_color")
    private val keyNextTimeBg = stringPreferencesKey("next_time_bg_color")
    private val keyWidgetNextTimeBg = stringPreferencesKey("widget_next_time_bg_color")
    private val keyLHeight = floatPreferencesKey("line_height_multiplier")
    private val keyAlarmSoundUri = stringPreferencesKey("alarm_sound_uri")
    private val keyAlarmDurationMinutes = intPreferencesKey("alarm_duration_minutes")
    private val keyVibrationEnabled = booleanPreferencesKey("vibration_enabled")
    private val keyPassKey = stringPreferencesKey("pass_key")

    val settings: Flow<SettingsState> = context.dataStore.data.map { prefs ->
        SettingsState(
            textColor = prefs[keyTextCol] ?: WedgeConfig.TEXT_COLOR_DEFAULT,
            bgColor = prefs[keyBgCol] ?: WedgeConfig.BG_COLOR_DEFAULT,
            widgetTextColor = prefs[keyWTextCol] ?: WedgeConfig.WIDGET_TEXT_COLOR_DEFAULT,
            widgetBgColor = prefs[keyWBgCol] ?: WedgeConfig.WIDGET_BG_COLOR_DEFAULT,
            editorFontSize = prefs[keyESize] ?: WedgeConfig.FONT_SIZE_DEFAULT,
            widgetFontSize = prefs[keyWSize] ?: WedgeConfig.WIDGET_FONT_SIZE_DEFAULT,
            lineHeight = prefs[keyLHeight] ?: WedgeConfig.LINE_HEIGHT_DEFAULT,
            boldColor = prefs[keyBoldCol] ?: WedgeConfig.BOLD_COLOR_DEFAULT,
            incognitoMode = prefs[keyIncognito] ?: false,
            passKey = prefs[keyPassKey] ?: "wedge03569"
        )
    }

    val textColor: Flow<String> =
        context.dataStore.data.map { it[keyTextCol] ?: WedgeConfig.TEXT_COLOR_DEFAULT }
    val bgColor: Flow<String> =
        context.dataStore.data.map { it[keyBgCol] ?: WedgeConfig.BG_COLOR_DEFAULT }
    val widgetTextColor: Flow<String> =
        context.dataStore.data.map { it[keyWTextCol] ?: WedgeConfig.WIDGET_TEXT_COLOR_DEFAULT }
    val widgetBgColor: Flow<String> =
        context.dataStore.data.map { it[keyWBgCol] ?: WedgeConfig.WIDGET_BG_COLOR_DEFAULT }
    val boldColor: Flow<String> =
        context.dataStore.data.map { it[keyBoldCol] ?: WedgeConfig.BOLD_COLOR_DEFAULT }
    val incognitoMode: Flow<Boolean> = context.dataStore.data.map { it[keyIncognito] ?: false }
    val widgetBoldColor: Flow<String> =
        context.dataStore.data.map { it[keyWidgetBoldCol] ?: WedgeConfig.WIDGET_BOLD_COLOR_DEFAULT }
    val nextTimeBg: Flow<String> =
        context.dataStore.data.map { it[keyNextTimeBg] ?: WedgeConfig.CALENDAR_COLOR_DEFAULT }
    val widgetNextTimeBg: Flow<String> = context.dataStore.data.map {
        it[keyWidgetNextTimeBg] ?: WedgeConfig.WIDGET_CALENDAR_COLOR_DEFAULT
    }
    val editorFontSize: Flow<Float> =
        context.dataStore.data.map { it[keyESize] ?: WedgeConfig.FONT_SIZE_DEFAULT }
    val widgetFontSize: Flow<Float> =
        context.dataStore.data.map { it[keyWSize] ?: WedgeConfig.FONT_SIZE_DEFAULT }
    val lineHeight: Flow<Float> =
        context.dataStore.data.map { it[keyLHeight] ?: WedgeConfig.LINE_HEIGHT_DEFAULT }
    val alarmSoundUri: Flow<String> = context.dataStore.data.map { it[keyAlarmSoundUri] ?: "" }
    val alarmDurationMinutes: Flow<Int> =
        context.dataStore.data.map { it[keyAlarmDurationMinutes] ?: 5 }
    val vibrationEnabled: Flow<Boolean> = 
        context.dataStore.data.map { it[keyVibrationEnabled] ?: false }
    val passKey: Flow<String> = context.dataStore.data.map { it[keyPassKey] ?: "wedge03569" }

    suspend fun setColors(
        txt: String,
        bg: String,
        wtxt: String,
        wbg: String,
        bcol: String,
        wBcol: String,
        nextBg: String,
        wNextBg: String
    ) = context.dataStore.edit {
        it[keyTextCol] = txt; it[keyBgCol] = bg; it[keyWTextCol] = wtxt; it[keyWBgCol] =
        wbg; it[keyBoldCol] = bcol
        it[keyWidgetBoldCol] = wBcol; it[keyNextTimeBg] = nextBg; it[keyWidgetNextTimeBg] = wNextBg
    }

    suspend fun setFontSettings(eSize: Float, wSize: Float, lHeight: Float) =
        context.dataStore.edit {
            it[keyESize] = eSize; it[keyWSize] = wSize; it[keyLHeight] = lHeight
        }

    suspend fun setIncognito(incognito: Boolean) = context.dataStore.edit {
        it[keyIncognito] = incognito
    }

    suspend fun setAlarmSettings(uri: String, duration: Int, vibration: Boolean) = context.dataStore.edit {
        it[keyAlarmSoundUri] = uri
        it[keyAlarmDurationMinutes] = duration
        it[keyVibrationEnabled] = vibration
    }
    
    suspend fun setPassKey(newPassKey: String) = context.dataStore.edit {
        it[keyPassKey] = newPassKey
    }
}

fun parseColor(hex: String): Color {
    return try { Color(hex.toColorInt()) } catch (_: Exception) { if (hex.length > 7) Color.White else Color.Black }
}