package com.example.godeye.managers

import android.Manifest
import android.content.Context
import android.content.pm.PackageManager
import androidx.core.content.ContextCompat
import com.example.godeye.models.AppError
import com.example.godeye.utils.Logger
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.asStateFlow

/**
 * PermissionManager - управление разрешениями приложения
 * Соответствует требованиям ТЗ для работы с CAMERA, RECORD_AUDIO, INTERNET
 */
class PermissionManager(private val context: Context) {

    private val _permissionsGranted = MutableStateFlow(false)
    val permissionsGranted: StateFlow<Boolean> = _permissionsGranted.asStateFlow()

    private val _missingPermissions = MutableStateFlow<List<String>>(emptyList())
    val missingPermissions: StateFlow<List<String>> = _missingPermissions.asStateFlow()

    companion object {
        /**
         * Все необходимые разрешения согласно ТЗ
         */
        val REQUIRED_PERMISSIONS = arrayOf(
            Manifest.permission.CAMERA,
            Manifest.permission.RECORD_AUDIO,
            Manifest.permission.INTERNET,
            Manifest.permission.ACCESS_NETWORK_STATE,
            Manifest.permission.WAKE_LOCK,
            Manifest.permission.FOREGROUND_SERVICE
        ).apply {
            // Добавляем FOREGROUND_SERVICE_CAMERA для API 34+ (но в Android 10 недоступно)
            // if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
            //     plus(Manifest.permission.FOREGROUND_SERVICE_CAMERA)
            // }
        }

        /**
         * Критически важные разрешения для основной функциональности
         */
        val CRITICAL_PERMISSIONS = arrayOf(
            Manifest.permission.CAMERA,
            Manifest.permission.RECORD_AUDIO,
            Manifest.permission.INTERNET
        )
    }

    /**
     * Проверка всех необходимых разрешений
     */
    fun checkPermissions(): Boolean {
        Logger.step("PERMISSION_CHECK", "Checking all required permissions")

        val missing = mutableListOf<String>()

        REQUIRED_PERMISSIONS.forEach { permission ->
            if (!isPermissionGranted(permission)) {
                missing.add(permission)
                Logger.d("Missing permission: $permission")
            }
        }

        _missingPermissions.value = missing
        val allGranted = missing.isEmpty()
        _permissionsGranted.value = allGranted

        Logger.step("PERMISSION_CHECK_RESULT",
            if (allGranted) "All permissions granted"
            else "Missing ${missing.size} permissions: ${missing.joinToString()}")

        return allGranted
    }

    /**
     * Проверка критически важных разрешений
     */
    fun checkCriticalPermissions(): Boolean {
        val missing = CRITICAL_PERMISSIONS.filter { !isPermissionGranted(it) }

        if (missing.isNotEmpty()) {
            Logger.step("CRITICAL_PERMISSIONS_MISSING",
                "Missing critical permissions: ${missing.joinToString()}")
            return false
        }

        Logger.step("CRITICAL_PERMISSIONS_OK", "All critical permissions granted")
        return true
    }

    /**
     * Проверка отдельного разрешения
     */
    fun isPermissionGranted(permission: String): Boolean {
        return ContextCompat.checkSelfPermission(context, permission) == PackageManager.PERMISSION_GRANTED
    }

    /**
     * Проверка разрешения камеры
     */
    fun hasCameraPermission(): Boolean {
        return isPermissionGranted(Manifest.permission.CAMERA)
    }

    /**
     * Проверка разрешения микрофона
     */
    fun hasAudioPermission(): Boolean {
        return isPermissionGranted(Manifest.permission.RECORD_AUDIO)
    }

    /**
     * Проверка разрешений для WebRTC
     */
    fun hasWebRTCPermissions(): Boolean {
        return hasCameraPermission() && hasAudioPermission()
    }

    /**
     * Получение списка отсутствующих разрешений для запроса
     */
    fun getMissingPermissions(): Array<String> {
        return REQUIRED_PERMISSIONS.filter { !isPermissionGranted(it) }.toTypedArray()
    }

    /**
     * Получение списка критически важных отсутствующих разрешений
     */
    fun getMissingCriticalPermissions(): Array<String> {
        return CRITICAL_PERMISSIONS.filter { !isPermissionGranted(it) }.toTypedArray()
    }

    /**
     * Обработка результата запроса разрешений
     */
    fun onPermissionsResult(
        permissions: Array<String>,
        grantResults: IntArray
    ): PermissionResult {
        Logger.step("PERMISSION_RESULT", "Processing permission request result")

        val granted = mutableListOf<String>()
        val denied = mutableListOf<String>()

        permissions.forEachIndexed { index, permission ->
            if (grantResults[index] == PackageManager.PERMISSION_GRANTED) {
                granted.add(permission)
                Logger.d("Permission granted: $permission")
            } else {
                denied.add(permission)
                Logger.d("Permission denied: $permission")
            }
        }

        // Обновляем состояние
        checkPermissions()

        val result = when {
            denied.isEmpty() -> PermissionResult.AllGranted
            denied.any { it in CRITICAL_PERMISSIONS } -> PermissionResult.CriticalDenied(denied)
            else -> PermissionResult.SomeGranted(granted, denied)
        }

        Logger.step("PERMISSION_RESULT_PROCESSED",
            "Result: ${result::class.simpleName}, granted: ${granted.size}, denied: ${denied.size}")

        return result
    }

    /**
     * Получение ошибки для отсутствующих разрешений
     */
    fun getPermissionError(): AppError? {
        return when {
            !hasCameraPermission() -> AppError.CameraPermissionDenied
            !hasAudioPermission() -> AppError.CameraPermissionDenied // Аудио тоже критично
            else -> null
        }
    }

    /**
     * Получение человекочитаемого описания разрешения
     */
    fun getPermissionDescription(permission: String): String {
        return when (permission) {
            Manifest.permission.CAMERA -> "Доступ к камере для видеосвязи"
            Manifest.permission.RECORD_AUDIO -> "Доступ к микрофону для аудиосвязи"
            Manifest.permission.INTERNET -> "Доступ к интернету для подключения к серверу"
            Manifest.permission.ACCESS_NETWORK_STATE -> "Проверка состояния сети"
            Manifest.permission.WAKE_LOCK -> "Предотвращение засыпания устройства"
            Manifest.permission.FOREGROUND_SERVICE -> "Работа в фоновом режиме"
            // Manifest.permission.FOREGROUND_SERVICE_CAMERA -> "Фоновая работа с камерой" // Недоступно в Android 10
            else -> "Системное разрешение"
        }
    }

    /**
     * Проверка необходимости объяснения разрешения
     */
    fun shouldShowRationale(permission: String): Boolean {
        // Для системных разрешений обычно не показываем rationale
        return when (permission) {
            Manifest.permission.CAMERA,
            Manifest.permission.RECORD_AUDIO -> true
            else -> false
        }
    }
}

/**
 * Результат запроса разрешений
 */
sealed class PermissionResult {
    object AllGranted : PermissionResult()
    data class SomeGranted(val granted: List<String>, val denied: List<String>) : PermissionResult()
    data class CriticalDenied(val denied: List<String>) : PermissionResult()
}
