/**
 * JavaScript для управления балансировкой нагрузки (FR-024)
 */

let currentServiceName = null;
let servicesData = {};
let algorithms = [];

// Загрузка данных при открытии страницы
document.addEventListener('DOMContentLoaded', function() {
    loadAlgorithms();
    loadServices();
    
    // Поиск
    document.getElementById('serviceSearch').addEventListener('input', function(e) {
        filterServices(e.target.value);
    });
    
    // Обновление каждые 10 секунд
    setInterval(loadServices, 10000);
});

/**
 * Загрузка списка доступных алгоритмов
 */
async function loadAlgorithms() {
    try {
        const response = await fetch('/api/v1/admin/load-balancing/algorithms');
        const data = await response.json();
        if (data.success) {
            algorithms = data.algorithms;
            updateAlgorithmSelect();
        }
    } catch (error) {
        console.error('Ошибка загрузки алгоритмов:', error);
    }
}

/**
 * Обновление select с алгоритмами
 */
function updateAlgorithmSelect() {
    const select = document.getElementById('algorithmSelect');
    select.innerHTML = '';
    algorithms.forEach(algo => {
        const option = document.createElement('option');
        option.value = algo.value;
        option.textContent = algo.name;
        select.appendChild(option);
    });
    
    // Обработчик изменения алгоритма
    select.addEventListener('change', function() {
        const selected = algorithms.find(a => a.value === this.value);
        if (selected) {
            document.getElementById('algorithmDescription').textContent = selected.description;
        }
    });
}

/**
 * Загрузка списка сервисов
 */
async function loadServices() {
    try {
        const response = await fetch('/api/v1/admin/load-balancing/services');
        const data = await response.json();
        if (data.success) {
            servicesData = data.services;
            renderServices(servicesData);
        }
    } catch (error) {
        console.error('Ошибка загрузки сервисов:', error);
        showError('Ошибка загрузки сервисов: ' + error.message);
    }
}

/**
 * Отображение списка сервисов
 */
function renderServices(services) {
    const tbody = document.getElementById('servicesTableBody');
    tbody.innerHTML = '';
    
    if (Object.keys(services).length === 0) {
        tbody.innerHTML = '<tr><td colspan="6" class="text-center text-muted">Сервисы не найдены</td></tr>';
        return;
    }
    
    Object.values(services).forEach(service => {
        const tr = document.createElement('tr');
        tr.innerHTML = `
            <td><strong>${escapeHtml(service.name)}</strong></td>
            <td>
                <span class="badge bg-primary-container text-primary">${escapeHtml(service.algorithm)}</span>
            </td>
            <td>${service.total_endpoints}</td>
            <td>
                <span class="badge ${service.healthy_endpoints === service.total_endpoints ? 'bg-success-container text-success' : 'bg-warning-container text-warning'}">
                    ${service.healthy_endpoints}/${service.total_endpoints}
                </span>
            </td>
            <td>${service.total_connections}</td>
            <td>
                <button class="btn btn-sm btn-primary" onclick="openLoadBalancingModal('${escapeHtml(service.name)}')">
                    <i class="bi bi-gear"></i> Настроить
                </button>
            </td>
        `;
        tbody.appendChild(tr);
    });
}

/**
 * Фильтрация сервисов
 */
function filterServices(query) {
    const filtered = {};
    const lowerQuery = query.toLowerCase();
    
    Object.values(servicesData).forEach(service => {
        if (service.name.toLowerCase().includes(lowerQuery)) {
            filtered[service.name] = service;
        }
    });
    
    renderServices(filtered);
}

/**
 * Открытие модального окна для настройки балансировки
 */
async function openLoadBalancingModal(serviceName) {
    currentServiceName = serviceName;
    document.getElementById('modalServiceName').textContent = serviceName;
    
    // Загружаем распределение нагрузки
    await loadDistribution(serviceName);
    
    // Устанавливаем текущий алгоритм
    const service = servicesData[serviceName];
    if (service) {
        const select = document.getElementById('algorithmSelect');
        select.value = service.algorithm;
        const selected = algorithms.find(a => a.value === service.algorithm);
        if (selected) {
            document.getElementById('algorithmDescription').textContent = selected.description;
        }
    }
    
    // Загружаем веса
    await loadWeights(serviceName);
    
    // Показываем модальное окно
    const modal = new bootstrap.Modal(document.getElementById('loadBalancingModal'));
    modal.show();
}

/**
 * Загрузка распределения нагрузки
 */
async function loadDistribution(serviceName) {
    try {
        const response = await fetch(`/api/v1/admin/load-balancing/services/${serviceName}/distribution`);
        const data = await response.json();
        if (data.success) {
            renderDistribution(data.distribution);
        }
    } catch (error) {
        console.error('Ошибка загрузки распределения:', error);
    }
}

/**
 * Отображение распределения нагрузки
 */
function renderDistribution(distribution) {
    const container = document.getElementById('distributionChart');
    container.innerHTML = '';
    
    if (distribution.endpoints.length === 0) {
        container.innerHTML = '<p class="text-muted">Нет endpoints</p>';
        return;
    }
    
    // Создаем таблицу с распределением
    const table = document.createElement('table');
    table.className = 'table table-sm';
    table.innerHTML = `
        <thead>
            <tr>
                <th>Endpoint</th>
                <th>Статус</th>
                <th>Вес</th>
                <th>Соединения</th>
                <th>Процент нагрузки</th>
            </tr>
        </thead>
        <tbody>
        </tbody>
    `;
    
    const tbody = table.querySelector('tbody');
    const totalConnections = distribution.total_connections || 1;
    
    distribution.endpoints.forEach(endpoint => {
        const percentage = totalConnections > 0 
            ? ((endpoint.connections / totalConnections) * 100).toFixed(1)
            : 0;
        
        const tr = document.createElement('tr');
        tr.innerHTML = `
            <td>${escapeHtml(endpoint.endpoint)}</td>
            <td>
                <span class="badge ${endpoint.health === 'healthy' ? 'bg-success-container text-success' : 'bg-danger-container text-danger'}">
                    ${escapeHtml(endpoint.health)}
                </span>
            </td>
            <td>${endpoint.weight}</td>
            <td>${endpoint.connections}</td>
            <td>
                <div class="progress" style="height: 20px;">
                    <div class="progress-bar" role="progressbar" style="width: ${percentage}%">
                        ${percentage}%
                    </div>
                </div>
            </td>
        `;
        tbody.appendChild(tr);
    });
    
    container.appendChild(table);
}

/**
 * Загрузка весов для endpoints
 */
async function loadWeights(serviceName) {
    try {
        const response = await fetch(`/api/v1/admin/load-balancing/services/${serviceName}/distribution`);
        const data = await response.json();
        if (data.success) {
            renderWeights(data.distribution.endpoints);
        }
    } catch (error) {
        console.error('Ошибка загрузки весов:', error);
    }
}

/**
 * Отображение весов для редактирования
 */
function renderWeights(endpoints) {
    const container = document.getElementById('weightsList');
    container.innerHTML = '';
    
    if (endpoints.length === 0) {
        container.innerHTML = '<p class="text-muted">Нет endpoints</p>';
        return;
    }
    
    endpoints.forEach(endpoint => {
        const div = document.createElement('div');
        div.className = 'mb-3';
        div.innerHTML = `
            <label for="weight_${escapeHtml(endpoint.endpoint)}" class="form-label">
                ${escapeHtml(endpoint.endpoint)}
                <span class="badge ${endpoint.health === 'healthy' ? 'bg-success-container text-success' : 'bg-danger-container text-danger'} ms-2">
                    ${escapeHtml(endpoint.health)}
                </span>
            </label>
            <input type="number" 
                   class="form-control" 
                   id="weight_${escapeHtml(endpoint.endpoint)}" 
                   value="${endpoint.weight}" 
                   min="1" 
                   max="100"
                   data-endpoint="${escapeHtml(endpoint.endpoint)}">
        `;
        container.appendChild(div);
    });
}

/**
 * Сохранение алгоритма
 */
async function saveAlgorithm() {
    if (!currentServiceName) return;
    
    const algorithm = document.getElementById('algorithmSelect').value;
    if (!algorithm) {
        showError('Выберите алгоритм');
        return;
    }
    
    try {
        const response = await fetch(`/api/v1/admin/load-balancing/services/${currentServiceName}/algorithm`, {
            method: 'PUT',
            headers: {
                'Content-Type': 'application/json'
            },
            body: JSON.stringify({ algorithm })
        });
        
        const data = await response.json();
        if (data.success) {
            showSuccess('Алгоритм успешно сохранен');
            loadServices();
        } else {
            showError(data.error || 'Ошибка сохранения алгоритма');
        }
    } catch (error) {
        console.error('Ошибка сохранения алгоритма:', error);
        showError('Ошибка сохранения алгоритма: ' + error.message);
    }
}

/**
 * Сохранение весов
 */
async function saveWeights() {
    if (!currentServiceName) return;
    
    const weights = {};
    const inputs = document.querySelectorAll('#weightsList input[type="number"]');
    
    inputs.forEach(input => {
        const endpoint = input.getAttribute('data-endpoint');
        const weight = parseInt(input.value);
        if (endpoint && weight > 0) {
            weights[endpoint] = weight;
        }
    });
    
    if (Object.keys(weights).length === 0) {
        showError('Установите веса для endpoints');
        return;
    }
    
    try {
        const response = await fetch(`/api/v1/admin/load-balancing/services/${currentServiceName}/weights`, {
            method: 'PUT',
            headers: {
                'Content-Type': 'application/json'
            },
            body: JSON.stringify({ weights })
        });
        
        const data = await response.json();
        if (data.success) {
            showSuccess('Веса успешно сохранены');
            loadDistribution(currentServiceName);
            loadServices();
        } else {
            showError(data.error || 'Ошибка сохранения весов');
        }
    } catch (error) {
        console.error('Ошибка сохранения весов:', error);
        showError('Ошибка сохранения весов: ' + error.message);
    }
}

/**
 * Обновление списка сервисов
 */
function refreshServices() {
    loadServices();
    showSuccess('Список сервисов обновлен');
}

/**
 * Утилиты
 */
function escapeHtml(text) {
    const div = document.createElement('div');
    div.textContent = text;
    return div.innerHTML;
}

function showSuccess(message) {
    // Можно использовать toast или alert
    alert(message);
}

function showError(message) {
    alert('Ошибка: ' + message);
}
