package com.example.godeye.managers

import com.example.godeye.models.CameraSession
import com.example.godeye.utils.Logger
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.asStateFlow

/**
 * Менеджер для управления активными сессиями с операторами
 */
class SessionManager {

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

    /**
     * Добавить новую сессию
     */
    fun addSession(sessionId: String, operatorId: String, cameraType: String) {
        val newSession = CameraSession(
            sessionId = sessionId,
            operatorId = operatorId,
            cameraType = cameraType,
            startTime = System.currentTimeMillis(),
            isActive = true,
            webRTCConnected = false
        )

        val currentSessions = _activeSessions.value.toMutableList()
        // Удаляем существующую сессию с тем же ID, если есть
        currentSessions.removeAll { it.sessionId == sessionId }
        currentSessions.add(newSession)
        _activeSessions.value = currentSessions

        Logger.d("Session added: $sessionId, operator: $operatorId, camera: $cameraType")
    }

    /**
     * Обновить статус WebRTC соединения для сессии
     */
    fun updateWebRTCStatus(sessionId: String, connected: Boolean) {
        val currentSessions = _activeSessions.value.toMutableList()
        val sessionIndex = currentSessions.indexOfFirst { it.sessionId == sessionId }

        if (sessionIndex != -1) {
            currentSessions[sessionIndex] = currentSessions[sessionIndex].copy(
                webRTCConnected = connected
            )
            _activeSessions.value = currentSessions
            Logger.d("WebRTC status updated for session $sessionId: $connected")
        }
    }

    /**
     * Переключить камеру для сессии
     */
    fun switchCameraForSession(sessionId: String, newCameraType: String) {
        val currentSessions = _activeSessions.value.toMutableList()
        val sessionIndex = currentSessions.indexOfFirst { it.sessionId == sessionId }

        if (sessionIndex != -1) {
            currentSessions[sessionIndex] = currentSessions[sessionIndex].copy(
                cameraType = newCameraType
            )
            _activeSessions.value = currentSessions
            Logger.d("Camera switched for session $sessionId to $newCameraType")
        }
    }

    /**
     * Завершить сессию
     */
    fun endSession(sessionId: String) {
        val currentSessions = _activeSessions.value.toMutableList()
        val removed = currentSessions.removeAll { it.sessionId == sessionId }

        if (removed) {
            _activeSessions.value = currentSessions
            Logger.d("Session ended: $sessionId")
        }
    }

    /**
     * Получить сессию по ID
     */
    fun getSession(sessionId: String): CameraSession? {
        return _activeSessions.value.find { it.sessionId == sessionId }
    }

    /**
     * Проверить, есть ли активные сессии
     */
    fun hasActiveSessions(): Boolean {
        return _activeSessions.value.isNotEmpty()
    }

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

    /**
     * Завершить все сессии
     */
    fun endAllSessions() {
        val sessionIds = _activeSessions.value.map { it.sessionId }
        _activeSessions.value = emptyList()
        Logger.d("All sessions ended: ${sessionIds.joinToString(", ")}")
    }

    /**
     * Получить текущий тип камеры для активной сессии
     */
    fun getCurrentCameraType(): String? {
        return _activeSessions.value.firstOrNull()?.cameraType
    }

    /**
     * Проверить, подключен ли WebRTC для сессии
     */
    fun isWebRTCConnected(sessionId: String): Boolean {
        return getSession(sessionId)?.webRTCConnected ?: false
    }

    /**
     * Получить статистику сессий
     */
    fun getSessionStats(): SessionStats {
        val sessions = _activeSessions.value
        return SessionStats(
            totalSessions = sessions.size,
            connectedSessions = sessions.count { it.webRTCConnected },
            activeSessions = sessions.count { it.isActive },
            oldestSessionTime = sessions.minOfOrNull { it.startTime },
            newestSessionTime = sessions.maxOfOrNull { it.startTime }
        )
    }
}

/**
 * Статистика сессий
 */
data class SessionStats(
    val totalSessions: Int,
    val connectedSessions: Int,
    val activeSessions: Int,
    val oldestSessionTime: Long?,
    val newestSessionTime: Long?
)
