/**
 * JavaScript для страницы нагрузочного тестирования (NFR-001)
 */

let currentBenchmarkId = null;
let metricsInterval = null;
let benchmarkCheckInterval = null;

// Инициализация при загрузке страницы
document.addEventListener('DOMContentLoaded', function() {
    console.log('=== Инициализация страницы нагрузочного тестирования ===');
    
    // Проверяем наличие необходимых элементов
    const form = document.getElementById('benchmarkForm');
    const runBtn = document.getElementById('runBenchmarkBtn');
    const refreshBtn = document.getElementById('refreshMetricsBtn');
    
    console.log('Элементы найдены:', {
        form: !!form,
        runBtn: !!runBtn,
        refreshBtn: !!refreshBtn
    });
    
    if (!form || !runBtn) {
        console.error('Критические элементы не найдены!');
        return;
    }
    
    try {
        loadCurrentMetrics();
        setupFormHandlers();
        
        // Автообновление метрик каждые 5 секунд
        metricsInterval = setInterval(loadCurrentMetrics, 5000);
        console.log('Инициализация завершена успешно');
    } catch (error) {
        console.error('Ошибка при инициализации:', error);
    }
});

// Остановка обновления при уходе со страницы
window.addEventListener('beforeunload', function() {
    if (metricsInterval) {
        clearInterval(metricsInterval);
    }
    if (benchmarkCheckInterval) {
        clearInterval(benchmarkCheckInterval);
    }
});

// Настройка обработчиков формы
function setupFormHandlers() {
    console.log('Настройка обработчиков формы...');
    
    const form = document.getElementById('benchmarkForm');
    const testType = document.getElementById('testType');
    const runBtn = document.getElementById('runBenchmarkBtn');
    const refreshBtn = document.getElementById('refreshMetricsBtn');
    
    if (!form) {
        console.error('Форма benchmarkForm не найдена');
        return;
    }
    
    // Показ/скрытие параметров в зависимости от типа теста
    if (testType) {
        testType.addEventListener('change', function() {
            const type = this.value;
            const rpsParams = document.getElementById('rpsParams');
            const latencyParams = document.getElementById('latencyParams');
            const concurrentParams = document.getElementById('concurrentParams');
            
            if (rpsParams) rpsParams.style.display = (type === 'rps' || type === 'all') ? 'block' : 'none';
            if (latencyParams) latencyParams.style.display = (type === 'latency' || type === 'all') ? 'block' : 'none';
            if (concurrentParams) concurrentParams.style.display = (type === 'concurrent' || type === 'all') ? 'block' : 'none';
        });
        console.log('Обработчик изменения типа теста привязан');
    }
    
    // Обработка клика по кнопке запуска
    if (runBtn) {
        console.log('Кнопка запуска найдена, привязываем обработчик');
        runBtn.addEventListener('click', async function(e) {
            console.log('=== КЛИК ПО КНОПКЕ ЗАПУСКА ТЕСТА ===');
            e.preventDefault();
            e.stopPropagation();
            e.stopImmediatePropagation();
            await runBenchmark();
            return false;
        });
        console.log('Обработчик кнопки запуска привязан');
    } else {
        console.error('Кнопка runBenchmarkBtn не найдена!');
    }
    
    // Кнопка обновления метрик
    if (refreshBtn) {
        refreshBtn.addEventListener('click', function(e) {
            console.log('Клик по кнопке обновления метрик');
            e.preventDefault();
            loadCurrentMetrics();
        });
        console.log('Обработчик кнопки обновления метрик привязан');
    } else {
        console.error('Кнопка refreshMetricsBtn не найдена!');
    }
    
    console.log('Все обработчики настроены');
}

// Загрузка текущих метрик производительности
async function loadCurrentMetrics() {
    console.log('Загрузка текущих метрик...');
    try {
        const response = await fetch('/api/v1/admin/performance/current');
        console.log('Ответ получен:', response.status, response.statusText);
        
        if (!response.ok) {
            throw new Error(`HTTP ${response.status}: ${response.statusText}`);
        }
        
        const data = await response.json();
        console.log('Данные метрик:', data);
        
        if (data.success) {
            const metrics = data.metrics;
            const validation = data.validation;
            
            // Обновляем метрики
            const rpsEl = document.getElementById('currentRPS');
            const avgLatencyEl = document.getElementById('currentAvgLatency');
            const p99LatencyEl = document.getElementById('currentP99Latency');
            const activeRequestsEl = document.getElementById('currentActiveRequests');
            
            if (rpsEl) rpsEl.textContent = metrics.requests_per_second.toFixed(2);
            if (avgLatencyEl) avgLatencyEl.textContent = metrics.avg_latency_ms.toFixed(2) + ' мс';
            if (p99LatencyEl) p99LatencyEl.textContent = metrics.p99_latency_ms.toFixed(2) + ' мс';
            if (activeRequestsEl) activeRequestsEl.textContent = metrics.active_requests;
            
            // Обновляем статус валидации (только если есть активность)
            const validationDiv = document.getElementById('validationStatus');
            if (validationDiv) {
                validationDiv.className = 'alert';
                
                // Показываем валидацию только если есть реальные запросы
                if (metrics.total_requests > 0) {
                    let statusHtml = '<strong>Проверка производительности:</strong><br>';
                    statusHtml += `RPS >= 10,000: ${validation.rps.status} (${validation.rps.actual.toFixed(2)} / ${validation.rps.target})<br>`;
                    statusHtml += `Latency P99 <= 3 мс: ${validation.latency_p99.status} (${validation.latency_p99.actual.toFixed(2)} / ${validation.latency_p99.target} мс)`;
                    
                    if (validation.overall_status === '✅') {
                        validationDiv.classList.add('validation-success');
                        statusHtml = '<i class="bi bi-check-circle"></i> ' + statusHtml;
                    } else {
                        validationDiv.classList.add('validation-warning');
                        statusHtml = '<i class="bi bi-exclamation-triangle"></i> ' + statusHtml;
                    }
                    
                    validationDiv.innerHTML = statusHtml;
                } else {
                    validationDiv.className = 'alert alert-info';
                    validationDiv.innerHTML = '<i class="bi bi-info-circle"></i> <strong>Нет активности:</strong> Метрики будут отображаться после начала обработки запросов';
                }
            }
        }
    } catch (error) {
        console.error('Ошибка загрузки метрик:', error);
    }
}

// Запуск нагрузочного теста
async function runBenchmark() {
    console.log('=== Запуск нагрузочного теста ===');
    
    const submitBtn = document.getElementById('runBenchmarkBtn');
    const testTypeEl = document.getElementById('testType');
    const testUrlEl = document.getElementById('testUrl');
    
    // Проверяем, что элементы существуют
    if (!submitBtn || !testTypeEl || !testUrlEl) {
        console.error('Необходимые элементы формы не найдены:', {
            submitBtn: !!submitBtn,
            testTypeEl: !!testTypeEl,
            testUrlEl: !!testUrlEl
        });
        showAlert('Ошибка: форма не найдена', 'danger');
        return;
    }
    
    const testType = testTypeEl.value;
    const url = testUrlEl.value.trim();
    
    console.log('Параметры теста:', { testType, url });
    
    if (!url || !testType) {
        console.warn('Не заполнены обязательные поля');
        showAlert('Заполните все обязательные поля', 'warning');
        return;
    }
    
    const requestData = {
        url: url,
        test_type: testType,
        target_rps: parseInt(document.getElementById('targetRPS').value) || 10000,
        duration_seconds: parseInt(document.getElementById('duration').value) || 60,
        max_connections: parseInt(document.getElementById('maxConnections').value) || 100000,
        num_requests: parseInt(document.getElementById('numRequests').value) || 10000
    };
    
    // Если concurrent, используем отдельную длительность
    if (testType === 'concurrent' || testType === 'all') {
        const concurrentDurationEl = document.getElementById('concurrentDuration');
        if (concurrentDurationEl) {
            requestData.duration_seconds = parseInt(concurrentDurationEl.value) || 60;
        }
    }
    
    submitBtn.disabled = true;
    submitBtn.innerHTML = '<i class="bi bi-hourglass-split"></i> Запуск...';
    
    // Показываем секцию результатов сразу
    const resultsSection = document.getElementById('resultsSection');
    if (resultsSection) {
        resultsSection.style.display = 'block';
    }
    
    // Показываем начальный статус
    updateBenchmarkStatus('info', '<i class="bi bi-hourglass-split"></i> Инициализация теста...', 0);
    
    console.log('Отправка запроса на запуск теста:', requestData);
    
    try {
        const response = await fetch('/api/v1/admin/performance/benchmark/run', {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json'
            },
            body: JSON.stringify(requestData)
        });
        
        console.log('Ответ получен:', response.status, response.statusText);
        
        if (!response.ok) {
            const errorText = await response.text();
            console.error('Ошибка HTTP:', response.status, errorText);
            throw new Error(`HTTP ${response.status}: ${response.statusText}`);
        }
        
        const data = await response.json();
        console.log('Данные ответа:', data);
        
        if (data.success) {
            currentBenchmarkId = data.benchmark_id;
            console.log('Тест запущен, ID:', currentBenchmarkId);
            
            addBenchmarkLog(`Тест запущен с ID: ${currentBenchmarkId}`, 'success');
            updateBenchmarkStatus('info', 
                `<i class="bi bi-hourglass-split"></i> Тест выполняется... (ID: ${currentBenchmarkId})`, 
                5);
            
            // Останавливаем предыдущий интервал, если был
            if (benchmarkCheckInterval) {
                clearInterval(benchmarkCheckInterval);
            }
            
            // Начинаем проверку статуса теста каждые 1 секунду
            benchmarkCheckInterval = setInterval(checkBenchmarkStatus, 1000);
            
            showAlert('Нагрузочный тест запущен успешно', 'success');
        } else {
            console.error('Ошибка в ответе:', data.error);
            updateBenchmarkStatus('danger', 
                `<i class="bi bi-x-circle"></i> Ошибка: ${data.error || 'Неизвестная ошибка'}`, 
                0);
            showAlert('Ошибка запуска теста: ' + (data.error || 'Неизвестная ошибка'), 'danger');
            submitBtn.disabled = false;
            submitBtn.innerHTML = '<i class="bi bi-play-fill"></i> Запустить тест';
        }
    } catch (error) {
        console.error('Ошибка запуска теста:', error);
        updateBenchmarkStatus('danger', 
            `<i class="bi bi-x-circle"></i> Ошибка: ${error.message}`, 
            0);
        showAlert('Ошибка запуска теста: ' + error.message, 'danger');
        submitBtn.disabled = false;
        submitBtn.innerHTML = '<i class="bi bi-play-fill"></i> Запустить тест';
    }
}

// Обновление статуса теста с прогресс-баром
function updateBenchmarkStatus(type, message, progress) {
    const benchmarkStatus = document.getElementById('benchmarkStatus');
    if (!benchmarkStatus) return;
    
    benchmarkStatus.style.display = 'block';
    
    const alertClass = type === 'info' ? 'alert-info' : 
                      type === 'success' ? 'alert-success' : 
                      type === 'warning' ? 'alert-warning' : 'alert-danger';
    
    benchmarkStatus.className = `alert ${alertClass}`;
    
    let progressHtml = '';
    if (progress > 0 && progress < 100) {
        progressHtml = `
            <div class="progress mt-2" style="height: 25px;">
                <div class="progress-bar progress-bar-striped progress-bar-animated bg-${type === 'info' ? 'primary' : type}" 
                     role="progressbar" 
                     style="width: ${progress}%"
                     aria-valuenow="${progress}" 
                     aria-valuemin="0" 
                     aria-valuemax="100">
                    ${progress.toFixed(0)}%
                </div>
            </div>
        `;
    } else if (progress >= 100) {
        progressHtml = `
            <div class="progress mt-2" style="height: 25px;">
                <div class="progress-bar bg-success" 
                     role="progressbar" 
                     style="width: 100%"
                     aria-valuenow="100" 
                     aria-valuemin="0" 
                     aria-valuemax="100">
                    100% - Завершено
                </div>
            </div>
        `;
    }
    
    benchmarkStatus.innerHTML = message + progressHtml;
    
    // Добавляем в лог
    addBenchmarkLog(message, type);
}

// Добавление записи в лог
function addBenchmarkLog(message, type = 'info') {
    const logsDiv = document.getElementById('benchmarkLogs');
    const logsContent = document.getElementById('benchmarkLogsContent');
    
    if (!logsDiv || !logsContent) return;
    
    logsDiv.style.display = 'block';
    
    const timestamp = new Date().toLocaleTimeString('ru-RU');
    const icon = type === 'info' ? '⏳' : 
                type === 'success' ? '✅' : 
                type === 'warning' ? '⚠️' : '❌';
    
    const logEntry = document.createElement('div');
    logEntry.className = `text-${type === 'info' ? 'primary' : type === 'success' ? 'success' : type === 'warning' ? 'warning' : 'danger'}`;
    logEntry.innerHTML = `<span class="text-muted">[${timestamp}]</span> ${icon} ${message}`;
    
    logsContent.appendChild(logEntry);
    
    // Автопрокрутка вниз
    logsContent.scrollTop = logsContent.scrollHeight;
    
    // Ограничиваем количество записей (последние 50)
    while (logsContent.children.length > 50) {
        logsContent.removeChild(logsContent.firstChild);
    }
}

// Проверка статуса теста
let checkCount = 0;
let startTime = null;

async function checkBenchmarkStatus() {
    if (!currentBenchmarkId) {
        return;
    }
    
    checkCount++;
    if (!startTime) {
        startTime = Date.now();
    }
    
    const elapsed = Math.floor((Date.now() - startTime) / 1000);
    
    try {
        const response = await fetch(`/api/v1/admin/performance/benchmark/${currentBenchmarkId}`);
        
        if (!response.ok) {
            throw new Error(`HTTP ${response.status}`);
        }
        
        const data = await response.json();
        
        if (data.success) {
            const benchmark = data.benchmark;
            
            if (benchmark.status === 'completed') {
                clearInterval(benchmarkCheckInterval);
                console.log('Тест завершен успешно');
                updateBenchmarkStatus('success', 
                    '<i class="bi bi-check-circle"></i> Тест завершен!', 
                    100);
                displayBenchmarkResults(benchmark.result, benchmark.validation);
                const submitBtn = document.getElementById('runBenchmarkBtn');
                if (submitBtn) {
                    submitBtn.disabled = false;
                    submitBtn.innerHTML = '<i class="bi bi-play-fill"></i> Запустить тест';
                }
                checkCount = 0;
                startTime = null;
            } else if (benchmark.status === 'error') {
                clearInterval(benchmarkCheckInterval);
                console.error('Ошибка выполнения теста:', benchmark.error);
                updateBenchmarkStatus('danger', 
                    `<i class="bi bi-x-circle"></i> Ошибка выполнения теста: ${benchmark.error}`, 
                    0);
                const submitBtn = document.getElementById('runBenchmarkBtn');
                if (submitBtn) {
                    submitBtn.disabled = false;
                    submitBtn.innerHTML = '<i class="bi bi-play-fill"></i> Запустить тест';
                }
                checkCount = 0;
                startTime = null;
            } else if (benchmark.status === 'running') {
                // Используем прогресс из API, если есть
                const testType = benchmark.test_type || 'unknown';
                const progress = benchmark.progress || Math.min(10 + (checkCount * 2), 90);
                const statusMessage = benchmark.status_message || `Тест выполняется... (${testType})`;
                
                updateBenchmarkStatus('info', 
                    `<i class="bi bi-hourglass-split"></i> ${statusMessage}<br>
                     <small>Прошло времени: ${elapsed} сек | Прогресс: ${progress}%</small>`, 
                    progress);
            }
        } else {
            console.error('Ошибка в ответе:', data.error);
            updateBenchmarkStatus('warning', 
                `<i class="bi bi-exclamation-triangle"></i> Ошибка получения статуса: ${data.error || 'Неизвестная ошибка'}`, 
                0);
        }
    } catch (error) {
        console.error('Ошибка проверки статуса теста:', error);
        updateBenchmarkStatus('warning', 
            `<i class="bi bi-exclamation-triangle"></i> Ошибка проверки статуса: ${error.message}`, 
            0);
    }
}

// Отображение результатов теста
function displayBenchmarkResults(result, validation) {
    const resultsDiv = document.getElementById('benchmarkResults');
    const statusDiv = document.getElementById('benchmarkStatus');
    
    if (!resultsDiv || !statusDiv) {
        return;
    }
    
    // Если результат - объект с несколькими тестами (test_type === 'all')
    if (result.rps || result.latency || result.concurrent) {
        let html = '<div class="row">';
        
        if (result.rps) {
            html += createResultCard('RPS Test', result.rps, validation);
        }
        if (result.latency) {
            html += createResultCard('Latency Test', result.latency, validation);
        }
        if (result.concurrent) {
            html += createResultCard('Concurrent Connections Test', result.concurrent, validation);
        }
        
        html += '</div>';
        resultsDiv.innerHTML = html;
    } else {
        // Один тест
        resultsDiv.innerHTML = createResultCard('Benchmark Results', result, validation);
    }
    
    statusDiv.innerHTML = '<i class="bi bi-check-circle"></i> Тест завершен';
    statusDiv.className = 'alert alert-success';
}

// Создание карточки с результатами
function createResultCard(title, result, validation) {
    const validationStatus = validation.overall_status === '✅' ? 'success' : 'warning';
    
    return `
        <div class="col-md-12 mb-4">
            <div class="card">
                <div class="card-header bg-${validationStatus === 'success' ? 'success' : 'warning'} text-white">
                    <h5 class="mb-0">${title}</h5>
                </div>
                <div class="card-body">
                    <div class="row mb-3">
                        <div class="col-md-3">
                            <strong>Всего запросов:</strong><br>
                            <span class="h4">${result.total_requests}</span>
                        </div>
                        <div class="col-md-3">
                            <strong>Успешных:</strong><br>
                            <span class="h4 text-success">${result.successful_requests}</span>
                        </div>
                        <div class="col-md-3">
                            <strong>Неудачных:</strong><br>
                            <span class="h4 text-danger">${result.failed_requests}</span>
                        </div>
                        <div class="col-md-3">
                            <strong>RPS:</strong><br>
                            <span class="h4">${result.requests_per_second.toFixed(2)}</span>
                        </div>
                    </div>
                    <div class="row mb-3">
                        <div class="col-md-12">
                            <h6>Latency (задержка):</h6>
                            <div class="row">
                                <div class="col-md-2">
                                    <small class="text-muted">Средняя:</small><br>
                                    <strong>${result.avg_latency_ms.toFixed(2)} мс</strong>
                                </div>
                                <div class="col-md-2">
                                    <small class="text-muted">P50:</small><br>
                                    <strong>${result.p50_latency_ms.toFixed(2)} мс</strong>
                                </div>
                                <div class="col-md-2">
                                    <small class="text-muted">P95:</small><br>
                                    <strong>${result.p95_latency_ms.toFixed(2)} мс</strong>
                                </div>
                                <div class="col-md-2">
                                    <small class="text-muted">P99:</small><br>
                                    <strong>${result.p99_latency_ms.toFixed(2)} мс</strong>
                                </div>
                                <div class="col-md-2">
                                    <small class="text-muted">Мин:</small><br>
                                    <strong>${result.min_latency_ms.toFixed(2)} мс</strong>
                                </div>
                                <div class="col-md-2">
                                    <small class="text-muted">Макс:</small><br>
                                    <strong>${result.max_latency_ms.toFixed(2)} мс</strong>
                                </div>
                            </div>
                        </div>
                    </div>
                    ${result.concurrent_connections > 0 ? `
                    <div class="row mb-3">
                        <div class="col-md-12">
                            <strong>Одновременных соединений:</strong> ${result.concurrent_connections}
                        </div>
                    </div>
                    ` : ''}
                    <div class="row">
                        <div class="col-md-12">
                            <div class="alert alert-${validationStatus === 'success' ? 'success' : 'warning'}">
                                <strong>Проверка производительности:</strong><br>
                                RPS >= 10,000: ${validation.rps_requirement.status} 
                                (${validation.rps_requirement.actual.toFixed(2)} / ${validation.rps_requirement.target})<br>
                                Latency P99 <= 3 мс: ${validation.latency_requirement.status} 
                                (${validation.latency_requirement.actual_p99.toFixed(2)} / ${validation.latency_requirement.target_p99} мс)<br>
                                <strong>Общий статус: ${validation.overall_status}</strong>
                            </div>
                        </div>
                    </div>
                </div>
            </div>
        </div>
    `;
}

// Показ уведомления
function showAlert(message, type) {
    const alertDiv = document.createElement('div');
    alertDiv.className = `alert alert-${type} alert-dismissible fade show position-fixed top-0 start-50 translate-middle-x mt-3`;
    alertDiv.style.zIndex = '9999';
    alertDiv.innerHTML = `
        ${message}
        <button type="button" class="btn-close" data-bs-dismiss="alert"></button>
    `;
    document.body.insertBefore(alertDiv, document.body.firstChild);
    
    setTimeout(() => {
        if (alertDiv.parentNode) {
            alertDiv.remove();
        }
    }, 5000);
}
