package com.example.godeye.utils

import android.content.Context
import android.content.SharedPreferences
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.asStateFlow

/**
 * Менеджер настроек приложения
 */
class PreferenceManager(context: Context) {

    private val prefs: SharedPreferences = context.getSharedPreferences("godeye_settings", Context.MODE_PRIVATE)

    companion object {
        private const val TAG = "PreferenceManager"
        private const val PREFS_NAME = "godeye_preferences"
        private const val KEY_DEVICE_ID = "device_id"
        private const val KEY_SERVER_URL = "server_url"
        private const val KEY_AUTO_APPROVAL = "auto_approval"
        private const val KEY_OPERATOR_MODE = "operator_mode"
        private const val KEY_LAST_CONNECTION = "last_connection"
        private const val KEY_STATISTICS_ENABLED = "statistics_enabled"
        private const val KEY_DEVICE_NAME = "device_name"
        private const val KEY_UUID_MIGRATED = "uuid_migrated"
        private const val KEY_AUTO_CONNECT = "auto_connect"
        private const val KEY_AUTO_APPROVE = "auto_approve"
        private const val KEY_NOTIFICATIONS_ENABLED = "notifications_enabled"
        private const val KEY_CAMERA_QUALITY = "camera_quality"

        // ИСПРАВЛЕНИЕ: Обновляем IP по умолчанию на ваш сервер
        private const val DEFAULT_SERVER_URL = "http://192.168.219.108:3001"
        private const val DEFAULT_DEVICE_NAME = "Android Device"
    }

    // StateFlow для реактивного наблюдения за изменениями настроек
    private val _serverUrl = MutableStateFlow(getServerUrl())
    val serverUrl: StateFlow<String> = _serverUrl.asStateFlow()

    private val _deviceName = MutableStateFlow(getDeviceName())
    val deviceName: StateFlow<String> = _deviceName.asStateFlow()

    private val _autoConnect = MutableStateFlow(getAutoConnect())
    val autoConnect: StateFlow<Boolean> = _autoConnect.asStateFlow()

    private val _autoApprove = MutableStateFlow(getAutoApprove())
    val autoApprove: StateFlow<Boolean> = _autoApprove.asStateFlow()

    // URL сервера
    fun getServerUrl(): String = prefs.getString(KEY_SERVER_URL, DEFAULT_SERVER_URL) ?: DEFAULT_SERVER_URL

    fun setServerUrl(url: String) {
        prefs.edit().putString(KEY_SERVER_URL, url).apply()
        _serverUrl.value = url
    }

    // Имя устройства
    fun getDeviceName(): String = prefs.getString(KEY_DEVICE_NAME, DEFAULT_DEVICE_NAME) ?: DEFAULT_DEVICE_NAME

    fun setDeviceName(name: String) {
        prefs.edit().putString(KEY_DEVICE_NAME, name).apply()
        _deviceName.value = name
    }

    // Автоматическое подключение
    fun getAutoConnect(): Boolean = prefs.getBoolean(KEY_AUTO_CONNECT, false)

    fun setAutoConnect(enabled: Boolean) {
        prefs.edit().putBoolean(KEY_AUTO_CONNECT, enabled).apply()
        _autoConnect.value = enabled
    }

    // Автоматическое подтверждение
    fun getAutoApprove(): Boolean = prefs.getBoolean(KEY_AUTO_APPROVE, false)

    fun setAutoApprove(enabled: Boolean) {
        prefs.edit().putBoolean(KEY_AUTO_APPROVE, enabled).apply()
        _autoApprove.value = enabled
    }

    // ID устройства (генерируется один раз) - теперь использует UUID
    fun getDeviceId(): String {
        var deviceId = prefs.getString(KEY_DEVICE_ID, null)
        if (deviceId == null) {
            // Генерируем настоящий UUID вместо timestamp
            deviceId = java.util.UUID.randomUUID().toString()
            prefs.edit().putString(KEY_DEVICE_ID, deviceId).apply()
        }
        return deviceId
    }

    /**
     * Принудительная перегенерация Device ID с новым UUID
     * Используется для обновления старых устройств на новый формат
     */
    fun regenerateDeviceId(): String {
        val newDeviceId = java.util.UUID.randomUUID().toString()
        prefs.edit().putString(KEY_DEVICE_ID, newDeviceId).apply()
        return newDeviceId
    }

    /**
     * Проверка, является ли Device ID старым форматом (android_timestamp)
     */
    fun isLegacyDeviceId(): Boolean {
        val deviceId = prefs.getString(KEY_DEVICE_ID, null)
        return deviceId != null && deviceId.startsWith("android_")
    }

    /**
     * Автоматическое обновление старого Device ID на UUID
     */
    fun migrateToUUID(): String {
        return if (isLegacyDeviceId()) {
            val oldDeviceId = prefs.getString(KEY_DEVICE_ID, null)
            val newDeviceId = regenerateDeviceId()
            android.util.Log.d("PreferenceManager", "Migrated Device ID from $oldDeviceId to $newDeviceId")
            newDeviceId
        } else {
            getDeviceId()
        }
    }

    // Настройки уведомлений
    fun getNotificationsEnabled(): Boolean = prefs.getBoolean(KEY_NOTIFICATIONS_ENABLED, true)

    fun setNotificationsEnabled(enabled: Boolean) {
        prefs.edit().putBoolean(KEY_NOTIFICATIONS_ENABLED, enabled).apply()
    }

    // Качество камеры
    fun getCameraQuality(): String = prefs.getString(KEY_CAMERA_QUALITY, "HIGH") ?: "HIGH"

    fun setCameraQuality(quality: String) {
        prefs.edit().putString(KEY_CAMERA_QUALITY, quality).apply()
    }

    /**
     * Получить все настройки для отладки
     */
    fun getAllSettings(): Map<String, Any> {
        return mapOf(
            "serverUrl" to getServerUrl(),
            "deviceName" to getDeviceName(),
            "autoConnect" to getAutoConnect(),
            "autoApprove" to getAutoApprove(),
            "deviceId" to getDeviceId(),
            "notificationsEnabled" to getNotificationsEnabled(),
            "cameraQuality" to getCameraQuality()
        )
    }

    /**
     * Очистка всех настроек (для отладки)
     */
    fun clearAllSettings() {
        prefs.edit().clear().apply()
        android.util.Log.d("PreferenceManager", "All settings cleared")
    }

    /**
     * Проверка времени последней миграции Device ID
     */
    private fun shouldMigrate(): Boolean {
        val lastMigration = prefs.getLong("last_migration_time", 0)
        val currentTime = System.currentTimeMillis()
        val migrationInterval = 24 * 60 * 60 * 1000L // 24 часа

        return (currentTime - lastMigration) > migrationInterval
    }

    /**
     * Автоматическая миграция с проверкой времени
     */
    fun autoMigrateDeviceId(): String {
        return if (isLegacyDeviceId() && shouldMigrate()) {
            val newDeviceId = regenerateDeviceId()
            prefs.edit().putLong("last_migration_time", System.currentTimeMillis()).apply()
            newDeviceId
        } else {
            getDeviceId()
        }
    }
}
