package com.example.godeye.ui.components

import androidx.compose.foundation.background
import androidx.compose.foundation.layout.*
import androidx.compose.foundation.rememberScrollState
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.foundation.verticalScroll
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.*
import androidx.compose.material3.*
import androidx.compose.runtime.*
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.platform.LocalContext
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import androidx.compose.ui.viewinterop.AndroidView
import com.example.godeye.models.VideoStatistics
import org.webrtc.SurfaceViewRenderer

@OptIn(ExperimentalMaterial3Api::class)
@Composable
fun StreamingVideoView(
    isStreaming: Boolean,
    statistics: VideoStatistics?,
    onStartStreaming: () -> Unit,
    onStopStreaming: () -> Unit,
    webRTCManager: com.example.godeye.managers.WebRTCManager? = null,
    modifier: Modifier = Modifier
) {
    val scrollState = rememberScrollState()
    val context = LocalContext.current

    // Состояния для сворачивания секций
    var cameraExpanded by remember { mutableStateOf(true) }
    var statsExpanded by remember { mutableStateOf(true) }
    var operatorExpanded by remember { mutableStateOf(true) }
    var trafficExpanded by remember { mutableStateOf(true) }
    var debugExpanded by remember { mutableStateOf(false) }

    // Состояние для SurfaceViewRenderer
    var surfaceRenderer by remember { mutableStateOf<SurfaceViewRenderer?>(null) }

    // ИСПРАВЛЕНИЕ: Улучшенная инициализация камеры для предпросмотра
    LaunchedEffect(webRTCManager) {
        if (webRTCManager != null && surfaceRenderer == null) {
            try {
                android.util.Log.d("StreamingVideoView", "🎥 Initializing camera preview renderer...")

                // Создаем SurfaceViewRenderer
                val renderer = SurfaceViewRenderer(context).apply {
                    setScalingType(org.webrtc.RendererCommon.ScalingType.SCALE_ASPECT_FIT)
                    setEnableHardwareScaler(true)
                    setMirror(false) // Отключаем зеркалирование для корректного отображения
                }

                // ИСПРАВЛЕНИЕ: Инициализируем с EGL контекстом от WebRTCManager
                webRTCManager.getEglBaseContext()?.let { eglContext ->
                    renderer.init(eglContext, null)
                    surfaceRenderer = renderer

                    // КРИТИЧНО: Подключаем к WebRTCManager ПОСЛЕ инициализации
                    webRTCManager.attachLocalVideoRenderer(renderer)

                    // НОВОЕ: Запускаем предпросмотр камеры немедленно
                    webRTCManager.startCameraPreview()

                    android.util.Log.d("StreamingVideoView", "✅ Camera preview renderer initialized and started successfully")
                } ?: run {
                    android.util.Log.e("StreamingVideoView", "❌ EGL context is null - cannot initialize camera preview")
                }
            } catch (e: Exception) {
                android.util.Log.e("StreamingVideoView", "❌ Failed to initialize camera preview renderer", e)
            }
        }
    }

    // ИСПРАВЛЕНИЕ: Правильная очистка рендерера при уничтожении
    DisposableEffect(surfaceRenderer, webRTCManager) {
        onDispose {
            try {
                if (surfaceRenderer != null && webRTCManager != null) {
                    android.util.Log.d("StreamingVideoView", "🧹 Cleaning up camera preview renderer...")

                    // Останавливаем предпросмотр
                    webRTCManager.stopCameraPreview()

                    // Отключаем рендерер
                    webRTCManager.detachLocalVideoRenderer()

                    // Освобождаем ресурсы
                    surfaceRenderer?.release()
                    surfaceRenderer = null

                    android.util.Log.d("StreamingVideoView", "✅ Camera preview renderer cleaned up successfully")
                }
            } catch (e: Exception) {
                android.util.Log.e("StreamingVideoView", "❌ Failed to cleanup camera preview renderer", e)
            }
        }
    }

    Column(
        modifier = modifier
            .fillMaxSize()
            .verticalScroll(scrollState)
            .padding(8.dp),
        verticalArrangement = Arrangement.spacedBy(8.dp)
    ) {
        // 1. Плашка предпросмотра камеры
        CollapsibleCard(
            title = "📹 Предпросмотр камеры",
            expanded = cameraExpanded,
            onToggle = { cameraExpanded = !cameraExpanded }
        ) {
            Box(
                modifier = Modifier
                    .fillMaxWidth()
                    .height(240.dp)
                    .background(
                        Color.Black,
                        RoundedCornerShape(8.dp)
                    )
            ) {
                // WebRTC SurfaceView для предпросмотра
                AndroidView(
                    factory = { context ->
                        SurfaceViewRenderer(context).apply {
                            setScalingType(org.webrtc.RendererCommon.ScalingType.SCALE_ASPECT_FIT)
                            setEnableHardwareScaler(true)
                            // Инициализируем с EGL контекстом от WebRTCManager
                            webRTCManager?.getEglBaseContext()?.let { eglContext ->
                                try {
                                    init(eglContext, null)
                                    surfaceRenderer = this
                                    // ИСПРАВЛЕНИЕ: Подключаем рендерер к WebRTCManager сразу
                                    webRTCManager.attachLocalVideoRenderer(this)
                                    android.util.Log.d("StreamingVideoView", "✅ Camera renderer attached in factory")
                                } catch (e: Exception) {
                                    android.util.Log.e("StreamingVideoView", "❌ Failed to init SurfaceViewRenderer", e)
                                }
                            }
                        }
                    },
                    update = { view ->
                        // Убираем дублирование инициализации
                        android.util.Log.d("StreamingVideoView", "AndroidView update called")
                    },
                    modifier = Modifier.fillMaxSize()
                )

                // Мигающий индикатор REC
                if (isStreaming) {
                    RecordingIndicator(
                        modifier = Modifier
                            .align(Alignment.TopStart)
                            .padding(12.dp)
                    )
                }

                // Кнопки управления
                Row(
                    modifier = Modifier
                        .align(Alignment.BottomCenter)
                        .padding(12.dp),
                    horizontalArrangement = Arrangement.spacedBy(8.dp)
                ) {
                    Button(
                        onClick = if (isStreaming) onStopStreaming else onStartStreaming,
                        colors = ButtonDefaults.buttonColors(
                            containerColor = if (isStreaming) Color.Red else MaterialTheme.colorScheme.primary
                        )
                    ) {
                        Icon(
                            if (isStreaming) Icons.Default.Stop else Icons.Default.PlayArrow,
                            contentDescription = null
                        )
                        Spacer(modifier = Modifier.width(4.dp))
                        Text(if (isStreaming) "Стоп" else "Старт")
                    }

                    IconButton(
                        onClick = {
                            webRTCManager?.switchCamera()
                        },
                        modifier = Modifier.background(
                            Color.Black.copy(alpha = 0.5f),
                            RoundedCornerShape(50)
                        )
                    ) {
                        Icon(
                            Icons.Default.FlipCameraAndroid,
                            contentDescription = "Переключить камеру",
                            tint = Color.White
                        )
                    }
                }
            }
        }

        // 2. Характеристики видеопотока
        CollapsibleCard(
            title = "📊 Характеристики видеопотока",
            expanded = statsExpanded,
            onToggle = { statsExpanded = !statsExpanded }
        ) {
            statistics?.let { stats ->
                VideoStatisticsContent(statistics = stats)
            } ?: run {
                Text(
                    "Статистика недоступна",
                    color = MaterialTheme.colorScheme.onSurface.copy(alpha = 0.6f)
                )
            }
        }

        // 3. Подключенный оператор
        CollapsibleCard(
            title = "👤 Подключенный оператор",
            expanded = operatorExpanded,
            onToggle = { operatorExpanded = !operatorExpanded }
        ) {
            OperatorInfoContent(isConnected = isStreaming)
        }

        // 4. Переданный трафик
        CollapsibleCard(
            title = "📡 Переданный трафик",
            expanded = trafficExpanded,
            onToggle = { trafficExpanded = !trafficExpanded }
        ) {
            TrafficInfoContent(statistics = statistics)
        }

        // 5. Отладка и диагностика
        CollapsibleCard(
            title = "🔧 Отладка и диагностика",
            expanded = debugExpanded,
            onToggle = { debugExpanded = !debugExpanded }
        ) {
            DebugInfoContent()
        }

        // Мониторинг сетевого трафика (всегда внизу)
        NetworkTrafficMonitor(
            sessionId = if (isStreaming) "active_session" else null,
            modifier = Modifier.fillMaxWidth()
        )
    }
}

@Composable
private fun RecordingIndicator(
    modifier: Modifier = Modifier
) {
    var isVisible by remember { mutableStateOf(true) }

    LaunchedEffect(Unit) {
        while (true) {
            kotlinx.coroutines.delay(1000)
            isVisible = !isVisible
        }
    }

    if (isVisible) {
        Card(
            modifier = modifier,
            colors = CardDefaults.cardColors(containerColor = Color.Red),
            shape = RoundedCornerShape(16.dp)
        ) {
            Row(
                modifier = Modifier.padding(horizontal = 8.dp, vertical = 4.dp),
                verticalAlignment = Alignment.CenterVertically,
                horizontalArrangement = Arrangement.spacedBy(4.dp)
            ) {
                Icon(
                    Icons.Default.FiberManualRecord,
                    contentDescription = null,
                    tint = Color.White,
                    modifier = Modifier.size(8.dp)
                )
                Text(
                    "REC",
                    color = Color.White,
                    fontSize = 12.sp,
                    fontWeight = FontWeight.Bold
                )
            }
        }
    }
}

@OptIn(ExperimentalMaterial3Api::class)
@Composable
private fun CollapsibleCard(
    title: String,
    expanded: Boolean,
    onToggle: () -> Unit,
    content: @Composable () -> Unit
) {
    Card(
        modifier = Modifier.fillMaxWidth(),
        elevation = CardDefaults.cardElevation(defaultElevation = 2.dp)
    ) {
        Column {
            // Заголовок (всегда видим)
            Surface(
                onClick = onToggle,
                modifier = Modifier.fillMaxWidth()
            ) {
                Row(
                    modifier = Modifier
                        .fillMaxWidth()
                        .padding(16.dp),
                    horizontalArrangement = Arrangement.SpaceBetween,
                    verticalAlignment = Alignment.CenterVertically
                ) {
                    Text(
                        text = title,
                        fontSize = 16.sp,
                        fontWeight = FontWeight.SemiBold,
                        color = MaterialTheme.colorScheme.primary
                    )
                    Icon(
                        imageVector = if (expanded) Icons.Default.ExpandLess else Icons.Default.ExpandMore,
                        contentDescription = if (expanded) "Свернуть" else "Развернуть",
                        tint = MaterialTheme.colorScheme.primary
                    )
                }
            }

            // Содержимое (показывается только при развернутом состоянии)
            if (expanded) {
                Column(
                    modifier = Modifier.padding(16.dp)
                ) {
                    content()
                }
            }
        }
    }
}

@Composable
private fun VideoStatisticsContent(statistics: VideoStatistics) {
    Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
        StatisticRow("FPS", "${statistics.fps}")
        StatisticRow("Разрешение", "${statistics.width}x${statistics.height}")
        StatisticRow("Битрейт", formatBitrate(statistics.bitrate))
        StatisticRow("Переданные кадры", "${statistics.framerate}")
        StatisticRow("Потерянные пакеты", "${statistics.packetsLost}")
        StatisticRow("Задержка (RTT)", "${statistics.rtt}ms")
        StatisticRow("Джиттер", "${String.format("%.2f", statistics.jitter)}ms")
    }
}

@Composable
private fun OperatorInfoContent(isConnected: Boolean) {
    Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
        Row(
            verticalAlignment = Alignment.CenterVertically,
            horizontalArrangement = Arrangement.spacedBy(8.dp)
        ) {
            Icon(
                Icons.Default.Circle,
                contentDescription = null,
                tint = if (isConnected) Color.Green else Color.Gray,
                modifier = Modifier.size(12.dp)
            )
            Text(
                if (isConnected) "Подключен" else "Не подключен",
                fontWeight = FontWeight.Medium,
                color = if (isConnected) Color.Green else Color.Gray
            )
        }

        if (isConnected) {
            StatisticRow("ID оператора", "OP_12345")
            StatisticRow("Время сессии", "05:23")
            StatisticRow("Качество связи", "Отлично")
            StatisticRow("Тип камеры", "Основная")
        }
    }
}

@Composable
private fun TrafficInfoContent(statistics: VideoStatistics?) {
    Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
        statistics?.let { stats ->
            StatisticRow("Всего отправлено", formatBytes(stats.bytesSent))
            StatisticRow("Скорость", formatBitrate(stats.bitrate))
            StatisticRow("Сжатие", "H.264")
            StatisticRow("Использовано трафика", formatBytes(stats.bytesSent))
        } ?: run {
            Text(
                "Нет данных о трафике",
                color = MaterialTheme.colorScheme.onSurface.copy(alpha = 0.6f)
            )
        }
    }
}

@Composable
private fun DebugInfoContent() {
    Column(verticalArrangement = Arrangement.spacedBy(12.dp)) {
        // Информация о соединении
        Text(
            "Информация о соединении",
            fontWeight = FontWeight.SemiBold,
            fontSize = 14.sp
        )
        StatisticRow("WebRTC состояние", "CONNECTED")
        StatisticRow("ICE состояние", "COMPLETED")
        StatisticRow("Signaling", "STABLE")

        HorizontalDivider()

        // Сетевая информация
        Text(
            "Сетевая информация",
            fontWeight = FontWeight.SemiBold,
            fontSize = 14.sp
        )
        StatisticRow("Локальный IP", "192.168.1.105")
        StatisticRow("Внешний IP", "203.45.67.89")
        StatisticRow("STUN сервер", "stun.l.google.com:19302")
        StatisticRow("Порт", "51234")

        HorizontalDivider()

        // Кнопки действий
        Text(
            "Действия отладки",
            fontWeight = FontWeight.SemiBold,
            fontSize = 14.sp
        )

        Row(
            modifier = Modifier.fillMaxWidth(),
            horizontalArrangement = Arrangement.spacedBy(8.dp)
        ) {
            OutlinedButton(
                onClick = { /* Тест соединения */ },
                modifier = Modifier.weight(1f)
            ) {
                Text("Тест связи", fontSize = 12.sp)
            }

            OutlinedButton(
                onClick = { /* Перезапуск */ },
                modifier = Modifier.weight(1f)
            ) {
                Text("Перезапуск", fontSize = 12.sp)
            }
        }

        Row(
            modifier = Modifier.fillMaxWidth(),
            horizontalArrangement = Arrangement.spacedBy(8.dp)
        ) {
            OutlinedButton(
                onClick = { /* Логи */ },
                modifier = Modifier.weight(1f)
            ) {
                Text("Экспорт логов", fontSize = 12.sp)
            }

            OutlinedButton(
                onClick = { /* Диагностика */ },
                modifier = Modifier.weight(1f)
            ) {
                Text("Диагностика", fontSize = 12.sp)
            }
        }

        // Переключатели отладки
        HorizontalDivider()

        Text(
            "Настройки отладки",
            fontWeight = FontWeight.SemiBold,
            fontSize = 14.sp
        )

        var verboseLogging by remember { mutableStateOf(false) }
        var showStatistics by remember { mutableStateOf(true) }
        var autoReconnect by remember { mutableStateOf(true) }

        DebugSwitchRow(
            "Детальное логирование",
            verboseLogging
        ) { verboseLogging = it }

        DebugSwitchRow(
            "Показывать статистику",
            showStatistics
        ) { showStatistics = it }

        DebugSwitchRow(
            "Автоперезподключение",
            autoReconnect
        ) { autoReconnect = it }
    }
}

@Composable
private fun DebugSwitchRow(
    label: String,
    checked: Boolean,
    onCheckedChange: (Boolean) -> Unit
) {
    Row(
        modifier = Modifier.fillMaxWidth(),
        horizontalArrangement = Arrangement.SpaceBetween,
        verticalAlignment = Alignment.CenterVertically
    ) {
        Text(
            label,
            fontSize = 14.sp,
            modifier = Modifier.weight(1f)
        )
        Switch(
            checked = checked,
            onCheckedChange = onCheckedChange,
            modifier = Modifier.height(24.dp)
        )
    }
}

@Composable
private fun StatisticRow(
    label: String,
    value: String
) {
    Row(
        modifier = Modifier.fillMaxWidth(),
        horizontalArrangement = Arrangement.SpaceBetween,
        verticalAlignment = Alignment.CenterVertically
    ) {
        Text(
            text = label,
            fontSize = 14.sp,
            color = MaterialTheme.colorScheme.onSurface.copy(alpha = 0.7f),
            modifier = Modifier.weight(1f)
        )
        Text(
            text = value,
            fontSize = 14.sp,
            fontWeight = FontWeight.Medium,
            color = MaterialTheme.colorScheme.onSurface
        )
    }
}

private fun formatBytes(bytes: Long): String {
    return when {
        bytes < 1024 -> "$bytes B"
        bytes < 1024 * 1024 -> "${bytes / 1024} KB"
        bytes < 1024 * 1024 * 1024 -> "${bytes / (1024 * 1024)} MB"
        else -> "${bytes / (1024 * 1024 * 1024)} GB"
    }
}

private fun formatBitrate(bitrate: Long): String {
    return when {
        bitrate < 1000 -> "${bitrate} bps"
        bitrate < 1000000 -> "${bitrate / 1000} Kbps"
        else -> "${bitrate / 1000000} Mbps"
    }
}
