package com.example.godeye.managers

import android.app.NotificationChannel
import android.app.NotificationManager
import android.content.Context
import android.os.Build
import android.util.Log
import androidx.core.app.NotificationCompat
import com.example.godeye.R
import com.example.godeye.utils.PreferenceManager
import kotlinx.coroutines.*
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.asStateFlow
import org.json.JSONObject

/**
 * Менеджер для автоматической обработки запросов доступа к камере
 */
class AutoApprovalManager(
    private val context: Context,
    private val preferenceManager: PreferenceManager,
    private val connectionManager: ConnectionManager
) {
    companion object {
        private const val TAG = "AutoApprovalManager"
        private const val NOTIFICATION_CHANNEL_ID = "camera_requests"
        private const val NOTIFICATION_ID = 1001
    }

    private val scope = CoroutineScope(Dispatchers.Main + SupervisorJob())
    private val notificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager

    // Активные сессии камеры с дополнительными метриками для мониторинга
    data class CameraSession(
        val sessionId: String,
        val operatorId: String,
        val cameraType: String,
        val startTime: Long = System.currentTimeMillis(),
        val isAutoApproved: Boolean = false,
        // Дополнительные поля для архитектуры GodEye Signal Center
        val deviceId: String,
        val quality: String = "720p",
        var lastHeartbeat: Long = System.currentTimeMillis(),
        var streamingState: StreamingState = StreamingState.INITIALIZING
    )

    enum class StreamingState {
        INITIALIZING,
        CONNECTING,
        STREAMING,
        PAUSED,
        ERROR,
        DISCONNECTED
    }

    // Состояние системы GodEye Signal Center
    private val _systemState = MutableStateFlow(SystemState.READY)
    val systemState: StateFlow<SystemState> = _systemState.asStateFlow()

    enum class SystemState {
        READY,
        PROCESSING_REQUEST,
        STREAMING_ACTIVE,
        ERROR,
        MAINTENANCE
    }

    private val _activeSessions = MutableStateFlow<List<CameraSession>>(emptyList())
    val activeSessions: StateFlow<List<CameraSession>> = _activeSessions.asStateFlow()

    // Слушатели для UI
    private val _pendingRequest = MutableStateFlow<JSONObject?>(null)
    val pendingRequest: StateFlow<JSONObject?> = _pendingRequest.asStateFlow()

    init {
        createNotificationChannel()
        setupConnectionManagerListeners()
    }

    /**
     * Настройка слушателей событий от ConnectionManager
     * Поддерживает обе конвенции именования: с двоеточиями (desktop/web) и дефисами (android)
     */
    private fun setupConnectionManagerListeners() {
        Log.d(TAG, "Setting up connection manager listeners with dual naming convention support")

        // Обработка запросов доступа к камере (поддержка обеих конвенций)
        val cameraRequestHandler: (Array<Any>) -> Unit = { data: Array<Any> ->
            try {
                Log.d(TAG, "Received camera request event with ${data.size} elements")
                if (data.isNotEmpty()) {
                    val requestData = data[0] as? JSONObject
                    Log.d(TAG, "Request data: $requestData")
                    requestData?.let { handleCameraRequest(it) }
                } else {
                    Log.w(TAG, "camera request event received but data is empty")
                }
            } catch (e: Exception) {
                Log.e(TAG, "Error processing camera request event", e)
            }
        }

        // Регистрируем обработчики для обеих конвенций
        connectionManager.registerEventListener("camera:request", cameraRequestHandler)   // Desktop/Web format
        connectionManager.registerEventListener("camera-request", cameraRequestHandler)   // Android format

        // Обработка автоматически одобренных запросов
        val autoApprovedHandler: (Array<Any>) -> Unit = { data: Array<Any> ->
            try {
                if (data.isNotEmpty()) {
                    val requestData = data[0] as? JSONObject
                    requestData?.let { handleAutoApprovedRequest(it) }
                }
            } catch (e: Exception) {
                Log.e(TAG, "Error processing camera auto-approved event", e)
            }
        }
        connectionManager.registerEventListener("camera:auto-approved", autoApprovedHandler)
        connectionManager.registerEventListener("camera-auto-approved", autoApprovedHandler)

        // Обработка отключения камеры
        val disconnectHandler: (Array<Any>) -> Unit = { data: Array<Any> ->
            try {
                if (data.isNotEmpty()) {
                    val requestData = data[0] as? JSONObject
                    requestData?.let { handleCameraDisconnect(it) }
                }
            } catch (e: Exception) {
                Log.e(TAG, "Error processing camera disconnect event", e)
            }
        }
        connectionManager.registerEventListener("camera:disconnect", disconnectHandler)
        connectionManager.registerEventListener("camera-disconnect", disconnectHandler)

        // Обработка WebRTC answer
        val webrtcAnswerHandler: (Array<Any>) -> Unit = { data: Array<Any> ->
            try {
                if (data.isNotEmpty()) {
                    val requestData = data[0] as? JSONObject
                    requestData?.let {
                        val sessionId = it.optString("sessionId")
                        val answer = it.optString("answer")
                        if (sessionId.isNotEmpty() && answer.isNotEmpty()) {
                            Log.d(TAG, "Received WebRTC answer for session: $sessionId")
                            connectionManager.handleWebRTCAnswer(sessionId, answer)
                        } else {
                            Log.w(TAG, "Invalid WebRTC answer data: sessionId=$sessionId, answer length=${answer.length}")
                        }
                    }
                }
            } catch (e: Exception) {
                Log.e(TAG, "Error processing webrtc answer event", e)
            }
        }
        connectionManager.registerEventListener("webrtc:answer", webrtcAnswerHandler)
        connectionManager.registerEventListener("webrtc-answer", webrtcAnswerHandler)
        // Добавляем слушатель для простого "answer" от signaling сервера
        connectionManager.registerEventListener("answer", webrtcAnswerHandler)

        // Обработка WebRTC ICE candidates
        val iceCandidateHandler: (Array<Any>) -> Unit = { data: Array<Any> ->
            try {
                if (data.isNotEmpty()) {
                    val requestData = data[0] as? JSONObject
                    requestData?.let {
                        val sessionId = it.optString("sessionId")
                        val candidate = it.optString("candidate")
                        if (sessionId.isNotEmpty() && candidate.isNotEmpty()) {
                            Log.d(TAG, "Received ICE candidate for session: $sessionId")
                            connectionManager.handleWebRTCIceCandidate(sessionId, candidate)
                        } else {
                            Log.w(TAG, "Invalid ICE candidate data: sessionId=$sessionId, candidate length=${candidate.length}")
                        }
                    }
                }
            } catch (e: Exception) {
                Log.e(TAG, "Error processing webrtc ice-candidate event", e)
            }
        }
        connectionManager.registerEventListener("webrtc:ice-candidate", iceCandidateHandler)
        connectionManager.registerEventListener("webrtc-ice-candidate", iceCandidateHandler)
        connectionManager.registerEventListener("ice:candidate", iceCandidateHandler)      // Alternative format
        connectionManager.registerEventListener("ice-candidate", iceCandidateHandler)      // Alternative format
        // Добавляем слушатель для простого "ice_candidate" от signaling сервера
        connectionManager.registerEventListener("ice_candidate", iceCandidateHandler)
    }

    /**
     * Обработка запроса доступа к камере
     */
    private fun handleCameraRequest(data: JSONObject) {
        // Проверяем, что JSON не пустой
        if (data.length() == 0) {
            Log.e(TAG, "Empty JSON object received for camera request")
            return
        }

        val sessionId = data.optString("sessionId")
        val operatorId = data.optString("operatorId")
        val cameraType = data.optString("cameraType", "back")

        // Расширенная валидация входных данных
        when {
            sessionId.isBlank() -> {
                Log.e(TAG, "Invalid camera request: sessionId is empty or blank")
                return
            }
            operatorId.isBlank() -> {
                Log.e(TAG, "Invalid camera request: operatorId is empty or blank")
                return
            }
            cameraType.isBlank() -> {
                Log.e(TAG, "Invalid camera request: cameraType is empty or blank, using default 'back'")
                // Не возвращаемся, а используем значение по умолчанию
            }
        }

        // Проверяем, нет ли уже активной сессии с этим sessionId
        if (_activeSessions.value.any { it.sessionId == sessionId }) {
            Log.w(TAG, "Session $sessionId already exists, ignoring duplicate request")
            return
        }

        Log.d(TAG, "Processing camera request - Session: $sessionId, Operator: $operatorId, Camera: $cameraType")
        Log.d(TAG, "Auto approve setting: ${preferenceManager.getAutoApprove()}")

        if (preferenceManager.getAutoApprove()) {
            // Автоматическое подтверждение включено
            Log.d(TAG, "Auto approve is ENABLED - automatically approving request")
            approveRequest(sessionId, operatorId, cameraType, isAutoApproved = true)
        } else {
            // Показать запрос пользователю
            Log.d(TAG, "Auto approve is DISABLED - showing notification to user")
            _pendingRequest.value = data
            showRequestNotification(operatorId, cameraType)
        }
    }

    /**
     * Подтверждение запроса доступа к камере
     */
    fun approveRequest(sessionId: String, operatorId: String, cameraType: String, isAutoApproved: Boolean = false) {
        scope.launch {
            try {
                Log.d(TAG, "Approving camera request - Session: $sessionId")

                // Валидация входных данных
                if (sessionId.isEmpty() || operatorId.isEmpty()) {
                    Log.e(TAG, "Cannot approve request: invalid parameters (sessionId=$sessionId, operatorId=$operatorId)")
                    return@launch
                }

                // Проверяем, нет ли уже активной сессии с этим sessionId
                if (_activeSessions.value.any { it.sessionId == sessionId }) {
                    Log.w(TAG, "Session $sessionId already exists, cannot approve duplicate")
                    return@launch
                }

                // Отправляем подтверждение на сервер
                connectionManager.sendCameraResponse(sessionId, true, "", operatorId)

                // Добавляем сессию в активные
                val session = CameraSession(sessionId, operatorId, cameraType, isAutoApproved = isAutoApproved, deviceId = android.provider.Settings.Secure.getString(
                    context.contentResolver,
                    android.provider.Settings.Secure.ANDROID_ID
                ))
                val currentSessions = _activeSessions.value.toMutableList()
                currentSessions.add(session)
                _activeSessions.value = currentSessions

                // Запускаем стриминг через ConnectionManager (не через WebRTC напрямую)
                connectionManager.startVideoStream(sessionId, operatorId, cameraType)

                // Очищаем pending запрос
                _pendingRequest.value = null

                // Показываем уведомление
                showActiveStreamingNotification(operatorId, cameraType)

                Log.d(TAG, "Camera request approved and streaming started for session: $sessionId")

            } catch (e: Exception) {
                Log.e(TAG, "Failed to approve camera request for session: $sessionId", e)
            }
        }
    }

    /**
     * Отклонение запроса доступа к камере
     */
    fun denyRequest(sessionId: String) {
        scope.launch {
            try {
                Log.d(TAG, "Denying camera request - Session: $sessionId")

                // Проверяем, что sessionId не пустой
                if (sessionId.isEmpty()) {
                    Log.e(TAG, "Cannot deny request: sessionId is empty")
                    return@launch
                }

                // Получаем информацию о запросе из pending request
                val pendingRequestData = _pendingRequest.value
                val operatorId = pendingRequestData?.optString("operatorId") ?: ""

                // Отправляем отклонение на сервер
                connectionManager.sendCameraResponse(sessionId, false, "User denied request", operatorId)

                // Очищаем pending запрос
                _pendingRequest.value = null

                Log.d(TAG, "Camera request denied for session: $sessionId")

            } catch (e: Exception) {
                Log.e(TAG, "Failed to deny camera request for session: $sessionId", e)
            }
        }
    }

    /**
     * Обработка отключения камеры
     */
    private fun handleCameraDisconnect(data: JSONObject) {
        val sessionId = data.optString("sessionId")

        Log.d(TAG, "Disconnecting camera session: $sessionId")

        // Остановка WebRTC стриминга через ConnectionManager
        connectionManager.stopVideoStream(sessionId)

        // Удаление сессии из активных
        val currentSessions = _activeSessions.value.toMutableList()
        currentSessions.removeAll { it.sessionId == sessionId }
        _activeSessions.value = currentSessions

        // Обновление уведомления
        if (currentSessions.isEmpty()) {
            notificationManager.cancel(NOTIFICATION_ID)
        } else {
            updateActiveStreamingNotification(currentSessions)
        }
    }

    /**
     * Создание канала уведомлений
     */
    private fun createNotificationChannel() {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
            val channel = NotificationChannel(
                NOTIFICATION_CHANNEL_ID,
                "Запросы доступа к камере",
                NotificationManager.IMPORTANCE_HIGH
            ).apply {
                description = "Уведомления о запросах операторов на доступ к камере"
            }
            notificationManager.createNotificationChannel(channel)
        }
    }

    /**
     * Показать уведомление о запросе
     */
    private fun showRequestNotification(operatorId: String, cameraType: String) {
        val notification = NotificationCompat.Builder(context, NOTIFICATION_CHANNEL_ID)
            .setSmallIcon(R.drawable.ic_camera_request)
            .setContentTitle("Запрос доступа к камере")
            .setContentText("Оператор $operatorId запрашивает доступ к ${getCameraDisplayName(cameraType)}")
            .setPriority(NotificationCompat.PRIORITY_HIGH)
            .setAutoCancel(false)
            .setStyle(NotificationCompat.BigTextStyle()
                .bigText("Оператор с UUID: $operatorId запрашивает доступ к ${getCameraDisplayName(cameraType)}"))
            .build()

        notificationManager.notify(NOTIFICATION_ID, notification)
    }

    /**
     * Показать уведомление об активном стриминге
     */
    private fun showActiveStreamingNotification(operatorId: String, cameraType: String) {
        val notification = NotificationCompat.Builder(context, NOTIFICATION_CHANNEL_ID)
            .setSmallIcon(R.drawable.ic_camera_active)
            .setContentTitle("Камера активна")
            .setContentText("Оператор $operatorId подключен к ${getCameraDisplayName(cameraType)}")
            .setPriority(NotificationCompat.PRIORITY_DEFAULT)
            .setOngoing(true)
            .setStyle(NotificationCompat.BigTextStyle()
                .bigText("Оператор с UUID: $operatorId подключен к ${getCameraDisplayName(cameraType)}"))
            .build()

        notificationManager.notify(NOTIFICATION_ID, notification)
    }

    private fun updateActiveStreamingNotification(sessions: List<CameraSession>) {
        val operatorIds = sessions.map { it.operatorId }.distinct()
        val operatorText = if (operatorIds.size == 1) {
            "UUID: ${operatorIds.first()}"
        } else {
            "Операторы: ${operatorIds.size} подключено"
        }

        val notification = NotificationCompat.Builder(context, NOTIFICATION_CHANNEL_ID)
            .setSmallIcon(R.drawable.ic_camera_active)
            .setContentTitle("Камера активна")
            .setContentText(operatorText)
            .setPriority(NotificationCompat.PRIORITY_DEFAULT)
            .setOngoing(true)
            .setStyle(NotificationCompat.BigTextStyle()
                .bigText("Активные операторы:\n${operatorIds.joinToString("\n") { "UUID: $it" }}"))
            .build()

        notificationManager.notify(NOTIFICATION_ID, notification)
    }

    private fun getCameraDisplayName(cameraType: String): String {
        return when (cameraType) {
            "back" -> "основной камере"
            "front" -> "фронтальной камере"
            "wide" -> "широкоугольной камере"
            "telephoto" -> "телеобъективу"
            else -> "камере"
        }
    }

    /**
     * Обработка автоматически одобренного запроса
     */
    private fun handleAutoApprovedRequest(data: JSONObject) {
        val sessionId = data.optString("sessionId")
        val operatorId = data.optString("operatorId")
        val cameraType = data.optString("cameraType", "back")

        approveRequest(sessionId, operatorId, cameraType, isAutoApproved = true)
    }

    /**
     * Принудительное отключение сессии
     */
    fun disconnectSession(sessionId: String) {
        scope.launch {
            try {
                Log.d(TAG, "Forcibly disconnecting session: $sessionId")

                // Остановка видеопотока
                connectionManager.stopVideoStream(sessionId)

                // Удаление из активных сессий
                val currentSessions = _activeSessions.value.toMutableList()
                val removedSession = currentSessions.find { it.sessionId == sessionId }
                currentSessions.removeAll { it.sessionId == sessionId }
                _activeSessions.value = currentSessions

                // Обновление уведомлений
                if (currentSessions.isEmpty()) {
                    notificationManager.cancel(NOTIFICATION_ID)
                } else {
                    updateActiveStreamingNotification(currentSessions)
                }

                Log.d(TAG, "Session $sessionId disconnected successfully")

            } catch (e: Exception) {
                Log.e(TAG, "Failed to disconnect session: $sessionId", e)
            }
        }
    }

    /**
     * Отключение всех активных сессий
     */
    fun disconnectAllSessions() {
        scope.launch {
            try {
                Log.d(TAG, "Disconnecting all active sessions")

                val currentSessions = _activeSessions.value.toList()

                // Остановка всех видеопотоков
                currentSessions.forEach { session ->
                    connectionManager.stopVideoStream(session.sessionId)
                }

                // Очистка активных сессий
                _activeSessions.value = emptyList()

                // Отмена уведомлений
                notificationManager.cancel(NOTIFICATION_ID)

                Log.d(TAG, "All sessions disconnected (${currentSessions.size} sessions)")

            } catch (e: Exception) {
                Log.e(TAG, "Failed to disconnect all sessions", e)
            }
        }
    }

    /**
     * Получение информации о сессии
     */
    fun getSessionInfo(sessionId: String): CameraSession? {
        return _activeSessions.value.find { it.sessionId == sessionId }
    }

    /**
     * Получение количества активных сессий
     */
    fun getActiveSessionCount(): Int {
        return _activeSessions.value.size
    }

    /**
     * Проверка, есть ли активная сессия с данным оператором
     */
    fun hasActiveSessionWithOperator(operatorId: String): Boolean {
        return _activeSessions.value.any { it.operatorId == operatorId }
    }

    /**
     * Очистка ресурсов
     */
    fun cleanup() {
        scope.cancel()
        notificationManager.cancel(NOTIFICATION_ID)
        // Очистка активных сессий при закрытии
        _activeSessions.value = emptyList()
        _pendingRequest.value = null
    }

    /**
     * Обновление состояния потоковой передачи сессии
     */
    fun updateSessionStreamingState(sessionId: String, state: StreamingState) {
        scope.launch {
            val currentSessions = _activeSessions.value.toMutableList()
            val sessionIndex = currentSessions.indexOfFirst { it.sessionId == sessionId }

            if (sessionIndex != -1) {
                val updatedSession = currentSessions[sessionIndex].copy(
                    streamingState = state,
                    lastHeartbeat = System.currentTimeMillis()
                )
                currentSessions[sessionIndex] = updatedSession
                _activeSessions.value = currentSessions

                Log.d(TAG, "Updated session $sessionId state to $state")

                // Обновляем общее состояние системы
                updateSystemState()
            }
        }
    }

    /**
     * Обновление общего состояния системы GodEye Signal Center
     */
    private fun updateSystemState() {
        val sessions = _activeSessions.value
        val newState = when {
            sessions.isEmpty() -> SystemState.READY
            sessions.any { it.streamingState == StreamingState.ERROR } -> SystemState.ERROR
            sessions.any { it.streamingState == StreamingState.STREAMING } -> SystemState.STREAMING_ACTIVE
            sessions.all { it.streamingState == StreamingState.INITIALIZING || it.streamingState == StreamingState.CONNECTING } ->
                SystemState.PROCESSING_REQUEST
            else -> SystemState.READY
        }

        if (_systemState.value != newState) {
            _systemState.value = newState
            Log.d(TAG, "System state updated to: $newState")
        }
    }

    /**
     * Получение диагностической информации для архитектуры GodEye Signal Center
     */
    fun getDiagnosticInfo(): JSONObject {
        return JSONObject().apply {
            put("systemState", _systemState.value.name)
            put("activeSessions", _activeSessions.value.size)
            put("autoApproveEnabled", preferenceManager.getAutoApprove())
            put("timestamp", System.currentTimeMillis())

            // Детальная информация о сессиях
            val sessionsArray = org.json.JSONArray()
            _activeSessions.value.forEach { session ->
                val sessionInfo = JSONObject().apply {
                    put("sessionId", session.sessionId)
                    put("operatorId", session.operatorId)
                    put("cameraType", session.cameraType)
                    put("isAutoApproved", session.isAutoApproved)
                    put("streamingState", session.streamingState.name)
                    put("duration", System.currentTimeMillis() - session.startTime)
                    put("lastHeartbeat", session.lastHeartbeat)
                    put("deviceId", session.deviceId)
                    put("quality", session.quality)
                }
                sessionsArray.put(sessionInfo)
            }
            put("sessions", sessionsArray)

            // Статистика для мониторинга
            val stats = JSONObject().apply {
                val streamingCount = _activeSessions.value.count { it.streamingState == StreamingState.STREAMING }
                val errorCount = _activeSessions.value.count { it.streamingState == StreamingState.ERROR }
                val connectingCount = _activeSessions.value.count { it.streamingState == StreamingState.CONNECTING }

                put("streamingSessions", streamingCount)
                put("errorSessions", errorCount)
                put("connectingSessions", connectingCount)
                put("autoApprovedSessions", _activeSessions.value.count { it.isAutoApproved })
            }
            put("statistics", stats)
        }
    }

    /**
     * Проверка "мертвых" сессий и их очистка
     * Метод для поддержания надежности системы GodEye Signal Center
     */
    fun performHealthCheck() {
        scope.launch {
            val currentTime = System.currentTimeMillis()
            val staleThreshold = 30000L // 30 секунд без heartbeat

            val currentSessions = _activeSessions.value.toMutableList()
            val staleSessions = currentSessions.filter { session ->
                currentTime - session.lastHeartbeat > staleThreshold &&
                session.streamingState != StreamingState.STREAMING
            }

            if (staleSessions.isNotEmpty()) {
                Log.w(TAG, "Found ${staleSessions.size} stale sessions, cleaning up...")

                staleSessions.forEach { session ->
                    Log.w(TAG, "Removing stale session: ${session.sessionId}")
                    connectionManager.stopVideoStream(session.sessionId)
                    currentSessions.remove(session)
                }

                _activeSessions.value = currentSessions
                updateSystemState()

                // Обновляем уведомления
                if (currentSessions.isEmpty()) {
                    notificationManager.cancel(NOTIFICATION_ID)
                } else {
                    updateActiveStreamingNotification(currentSessions)
                }
            }
        }
    }

    /**
     * Отправка heartbeat для активных сессий
     * Поддерживает мониторинг состояния в архитектуре GodEye Signal Center
     */
    fun sendSessionHeartbeat(sessionId: String) {
        scope.launch {
            val currentSessions = _activeSessions.value.toMutableList()
            val sessionIndex = currentSessions.indexOfFirst { it.sessionId == sessionId }

            if (sessionIndex != -1) {
                val updatedSession = currentSessions[sessionIndex].copy(
                    lastHeartbeat = System.currentTimeMillis()
                )
                currentSessions[sessionIndex] = updatedSession
                _activeSessions.value = currentSessions

                // Отправляем heartbeat на сервер через ConnectionManager
                try {
                    val heartbeatData = JSONObject().apply {
                        put("sessionId", sessionId)
                        put("timestamp", System.currentTimeMillis())
                        put("streamingState", updatedSession.streamingState.name)
                        put("deviceId", updatedSession.deviceId)
                    }

                    // Используем методы ConnectionManager для отправки heartbeat
                    // Пока не создадим специальный метод, логируем для отладки
                    Log.d(TAG, "Sending session heartbeat for $sessionId: $heartbeatData")

                } catch (e: Exception) {
                    Log.e(TAG, "Failed to send heartbeat for session $sessionId", e)
                }
            }
        }
    }

    /**
     * Получение метрик производительности для мониторинга GodEye Signal Center
     */
    fun getPerformanceMetrics(): JSONObject {
        val sessions = _activeSessions.value
        val currentTime = System.currentTimeMillis()

        return JSONObject().apply {
            // Общие метрики
            put("totalSessions", sessions.size)
            put("systemUptime", currentTime - startTime)
            put("averageSessionDuration", if (sessions.isNotEmpty()) {
                sessions.map { currentTime - it.startTime }.average()
            } else 0.0)

            // Метрики по состоянию
            StreamingState.values().forEach { state ->
                put("sessions_${state.name.lowercase()}", sessions.count { it.streamingState == state })
            }

            // Метрики по типам камер
            val cameraTypes = sessions.groupBy { it.cameraType }
            cameraTypes.forEach { (type, typeSessions) ->
                put("camera_${type}_sessions", typeSessions.size)
            }

            // Метрики автоодобрения
            put("autoApprovedSessions", sessions.count { it.isAutoApproved })
            put("manualApprovedSessions", sessions.count { !it.isAutoApproved })

            put("timestamp", currentTime)
        }
    }

    private val startTime = System.currentTimeMillis()

    /**
     * Генерация UUID для новой сессии
     */
    fun generateSessionId(): String {
        return java.util.UUID.randomUUID().toString()
    }

    /**
     * Тестовая функция для проверки автоподтверждения с UUID
     */
    fun testAutoApprovalWithUUID() {
        try {
            val testSessionId = generateSessionId()
            val testOperatorId = java.util.UUID.randomUUID().toString()

            Log.d(TAG, "Testing auto approval with UUID session ID: $testSessionId")

            // Создаем фиктивный запрос камеры с UUID
            val testRequest = JSONObject().apply {
                put("sessionId", testSessionId)
                put("operatorId", testOperatorId)
                put("cameraType", "back")
                put("timestamp", System.currentTimeMillis())
            }

            Log.d(TAG, "Simulating camera request with UUID: $testRequest")

            // Обрабатываем запрос
            handleCameraRequest(testRequest)

        } catch (e: Exception) {
            Log.e(TAG, "Failed to test auto approval with UUID", e)
        }
    }
}
