/**
 * JavaScript для управления сервисами (FR-022)
 */

let services = {};
let filteredServices = {};
let currentServiceName = null;
let logsEventSource = null;

// Загрузка списка сервисов
async function loadServices() {
    try {
        const response = await fetch('/api/v1/admin/services/list');
        const data = await response.json();
        if (data.success) {
            services = data.services;
            filteredServices = services;
            renderServices();
            updateServicesCount();
        } else {
            showAlert('Ошибка загрузки сервисов: ' + data.error, 'danger');
        }
    } catch (error) {
        showAlert('Ошибка при загрузке сервисов: ' + error.message, 'danger');
    }
}

// Фильтрация сервисов
function filterServices() {
    const searchText = document.getElementById('searchInput').value.toLowerCase();
    const statusFilter = document.getElementById('statusFilter').value;
    const environmentFilter = document.getElementById('environmentFilter').value;
    const tagsFilter = document.getElementById('tagsFilter').value.trim();
    
    filteredServices = {};
    
    for (const [serviceName, serviceData] of Object.entries(services)) {
        // Поиск по имени
        if (searchText && !serviceName.toLowerCase().includes(searchText)) {
            continue;
        }
        
        // Фильтр по окружению
        const metadata = serviceData.metadata || {};
        const environment = metadata.environment || '';
        if (environmentFilter && environment !== environmentFilter) {
            continue;
        }
        
        // Фильтр по тегам (FR-022)
        if (tagsFilter) {
            const serviceTags = metadata.tags || [];
            const filterTags = tagsFilter.split(',').map(t => t.trim()).filter(t => t);
            if (filterTags.length > 0) {
                // Проверяем, есть ли хотя бы один тег из фильтра
                const hasMatchingTag = filterTags.some(tag => serviceTags.includes(tag));
                if (!hasMatchingTag) {
                    continue;
                }
            }
        }
        
        // Фильтр по статусу
        if (statusFilter) {
            const endpoints = serviceData.endpoints || [];
            let hasMatchingStatus = false;
            for (const endpoint of endpoints) {
                const health = endpoint.health || {};
                const status = health.status || 'unknown';
                if (status === statusFilter) {
                    hasMatchingStatus = true;
                    break;
                }
            }
            if (!hasMatchingStatus) {
                continue;
            }
        }
        
        filteredServices[serviceName] = serviceData;
    }
    
    renderServices();
    updateServicesCount();
}

// Сброс фильтров
function clearFilters() {
    document.getElementById('searchInput').value = '';
    document.getElementById('statusFilter').value = '';
    document.getElementById('environmentFilter').value = '';
    document.getElementById('tagsFilter').value = '';
    filteredServices = services;
    renderServices();
    updateServicesCount();
}

// Обновление счетчика сервисов
function updateServicesCount() {
    const count = Object.keys(filteredServices).length;
    document.getElementById('servicesCount').textContent = count;
}

// Рендеринг списка сервисов
function renderServices() {
    const container = document.getElementById('servicesContainer');
    if (Object.keys(filteredServices).length === 0) {
        container.innerHTML = '<p class="text-muted text-center">Сервисы не найдены</p>';
        return;
    }
    
    let html = '';
    for (const [serviceName, serviceData] of Object.entries(filteredServices)) {
        const metadata = serviceData.metadata || {};
        const version = metadata.version || 'unknown';
        const environment = metadata.environment || 'production';
        const tags = metadata.tags || [];
        
        // Определяем общий статус сервиса
        const endpoints = serviceData.endpoints || [];
        let overallStatus = 'unknown';
        let healthyCount = 0;
        let unhealthyCount = 0;
        let unknownCount = 0;
        
        for (const endpoint of endpoints) {
            const health = endpoint.health || {};
            const status = health.status || 'unknown';
            if (status === 'healthy') {
                healthyCount++;
            } else if (status === 'unhealthy') {
                unhealthyCount++;
            } else {
                unknownCount++;
            }
        }
        
        if (endpoints.length > 0) {
            // Если все endpoints здоровы
            if (healthyCount === endpoints.length) {
                overallStatus = 'healthy';
            }
            // Если есть хотя бы один unhealthy (и нет healthy)
            else if (unhealthyCount > 0 && healthyCount === 0) {
                overallStatus = 'unhealthy';
            }
            // Если есть и healthy, и unhealthy
            else if (healthyCount > 0 && unhealthyCount > 0) {
                overallStatus = 'partial';
            }
            // Если все unknown (health checks еще не выполнены)
            else if (unknownCount === endpoints.length) {
                overallStatus = 'unknown';
            }
            // Смешанный статус (healthy + unknown или unhealthy + unknown)
            else {
                overallStatus = 'partial';
            }
        }
        
        const statusClass = overallStatus === 'healthy' ? 'success' : 
                           (overallStatus === 'unhealthy' ? 'danger' : 
                           (overallStatus === 'partial' ? 'warning' : 'secondary'));
        
        html += '<div class="card mb-3">';
        html += `<div class="card-header d-flex justify-content-between align-items-center">`;
        html += `<div>`;
        html += `<h5 class="mb-0"><code>${serviceName}</code></h5>`;
        html += `<div class="mt-1">`;
        html += `<span class="badge bg-info me-1">v${version}</span>`;
        html += `<span class="badge bg-secondary me-1">${environment}</span>`;
        html += `<span class="badge bg-${statusClass} me-1">${healthyCount}/${endpoints.length} здоровых</span>`;
        if (tags.length > 0) {
            tags.forEach(tag => {
                html += `<span class="badge bg-light text-dark me-1">${tag}</span>`;
            });
        }
        html += `</div>`;
        html += `</div>`;
        html += `<div>`;
        html += `<button class="btn btn-sm btn-outline-primary me-1" onclick="showServiceDetails('${serviceName}')">`;
        html += `<i class="bi bi-info-circle"></i> Детали</button>`;
        html += `<button class="btn btn-sm btn-outline-success me-1" onclick="startService('${serviceName}')">`;
        html += `<i class="bi bi-play-circle"></i> Запустить</button>`;
        html += `<button class="btn btn-sm btn-outline-danger me-1" onclick="stopService('${serviceName}')">`;
        html += `<i class="bi bi-stop-circle"></i> Остановить</button>`;
        html += `<button class="btn btn-sm btn-outline-warning" onclick="restartService('${serviceName}')">`;
        html += `<i class="bi bi-arrow-clockwise"></i> Перезапустить</button>`;
        html += `</div>`;
        html += `</div>`;
        html += '<div class="card-body">';
        
        if (endpoints.length === 0) {
            html += '<p class="text-muted mb-0">Нет доступных endpoints</p>';
        } else {
            html += '<table class="table table-sm mb-0">';
            html += '<thead><tr><th>Host</th><th>Port</th><th>Статус</th><th>Последняя проверка</th><th>Действия</th></tr></thead>';
            html += '<tbody>';
            
            endpoints.forEach(endpoint => {
                const health = endpoint.health || {};
                const status = health.status || 'unknown';
                const statusClass = status === 'healthy' ? 'success' : (status === 'unhealthy' ? 'danger' : 'secondary');
                const lastCheck = health.last_check ? new Date(health.last_check).toLocaleString('ru-RU') : 'Никогда';
                
                html += '<tr>';
                html += `<td><code>${endpoint.host}</code></td>`;
                html += `<td>${endpoint.port}</td>`;
                html += `<td><span class="badge bg-${statusClass}">${status}</span></td>`;
                html += `<td>${lastCheck}</td>`;
                html += `<td>`;
                html += `<button class="btn btn-sm btn-outline-primary" onclick="checkHealth('${serviceName}', '${endpoint.host}', ${endpoint.port})">`;
                html += `<i class="bi bi-heart-pulse"></i></button>`;
                html += `</td>`;
                html += '</tr>';
            });
            
            html += '</tbody></table>';
        }
        
        html += '</div></div>';
    }
    
    container.innerHTML = html;
}

// Показать детали сервиса
async function showServiceDetails(serviceName) {
    currentServiceName = serviceName;
    const modal = new bootstrap.Modal(document.getElementById('serviceDetailsModal'));
    document.getElementById('serviceDetailsTitle').textContent = `Сервис: ${serviceName}`;
    
    // Загружаем информацию о сервисе
    await loadServiceInfo(serviceName);
    
    modal.show();
    
    // При переключении табов загружаем соответствующие данные
    document.getElementById('metrics-tab').addEventListener('shown.bs.tab', () => {
        loadServiceMetrics(serviceName);
    });
    document.getElementById('traces-tab').addEventListener('shown.bs.tab', () => {
        loadServiceTraces(serviceName);
    });
}

// Загрузка информации о сервисе
async function loadServiceInfo(serviceName) {
    try {
        // Загружаем детальную информацию о сервисе (FR-022)
        const [statusResponse, infoResponse] = await Promise.all([
            fetch(`/api/v1/admin/services/${serviceName}/status`),
            fetch(`/api/v1/admin/services/${serviceName}/info`)
        ]);
        
        const statusData = await statusResponse.json();
        const infoData = await infoResponse.json();
        
        if (statusData.success) {
            const status = statusData.status;
            const info = infoData.success ? infoData.info : null;
            
            let html = '<dl class="row">';
            html += `<dt class="col-sm-3">Имя:</dt><dd class="col-sm-9"><code>${serviceName}</code></dd>`;
            html += `<dt class="col-sm-3">Версия:</dt><dd class="col-sm-9">${status.metadata?.version || 'unknown'}</dd>`;
            html += `<dt class="col-sm-3">Образ:</dt><dd class="col-sm-9"><code>${status.metadata?.image || 'unknown'}</code></dd>`;
            html += `<dt class="col-sm-3">Окружение:</dt><dd class="col-sm-9">${status.metadata?.environment || 'production'}</dd>`;
            html += `<dt class="col-sm-3">Endpoints:</dt><dd class="col-sm-9">${status.total_endpoints || 0}</dd>`;
            html += `<dt class="col-sm-3">Здоровые:</dt><dd class="col-sm-9"><span class="badge bg-success">${status.healthy_endpoints || 0}</span></dd>`;
            html += `<dt class="col-sm-3">Не здоровые:</dt><dd class="col-sm-9"><span class="badge bg-danger">${status.unhealthy_endpoints || 0}</span></dd>`;
            if (status.metadata?.tags && status.metadata.tags.length > 0) {
                html += `<dt class="col-sm-3">Теги:</dt><dd class="col-sm-9">`;
                status.metadata.tags.forEach(tag => {
                    html += `<span class="badge bg-light text-dark me-1">${escapeHtml(tag)}</span>`;
                });
                html += `</dd>`;
            }
            
            // Добавляем информацию о ресурсах (FR-022)
            if (info && info.resources) {
                html += '</dl><hr><h6><i class="bi bi-cpu"></i> Использование ресурсов</h6><dl class="row">';
                const resources = info.resources;
                html += `<dt class="col-sm-3">CPU:</dt><dd class="col-sm-9">${resources.total_cpu_usage?.toFixed(2) || 0}%</dd>`;
                html += `<dt class="col-sm-3">Память:</dt><dd class="col-sm-9">${formatBytes(resources.total_memory_usage || 0)} / ${formatBytes(resources.total_memory_limit || 0)} (${resources.memory_usage_percent?.toFixed(2) || 0}%)</dd>`;
                html += `<dt class="col-sm-3">Сеть (RX):</dt><dd class="col-sm-9">${formatBytes(resources.total_network_rx || 0)}</dd>`;
                html += `<dt class="col-sm-3">Сеть (TX):</dt><dd class="col-sm-9">${formatBytes(resources.total_network_tx || 0)}</dd>`;
                
                // Информация о контейнерах
                if (info.containers && info.containers.length > 0) {
                    html += '</dl><hr><h6><i class="bi bi-box"></i> Контейнеры</h6>';
                    html += '<div class="table-responsive"><table class="table table-sm table-hover">';
                    html += '<thead><tr><th>ID</th><th>Имя</th><th>Образ</th><th>Статус</th><th>CPU</th><th>Память</th></tr></thead><tbody>';
                    info.containers.forEach(container => {
                        html += '<tr>';
                        html += `<td><code>${container.container_id}</code></td>`;
                        html += `<td>${escapeHtml(container.name)}</td>`;
                        html += `<td><code>${escapeHtml(container.image)}</code></td>`;
                        html += `<td><span class="badge bg-${container.status === 'running' ? 'success' : 'secondary'}">${container.status}</span></td>`;
                        html += `<td>${container.cpu_usage?.toFixed(2) || 0}%</td>`;
                        html += `<td>${formatBytes(container.memory_usage || 0)} / ${formatBytes(container.memory_limit || 0)}</td>`;
                        html += '</tr>';
                    });
                    html += '</tbody></table></div>';
                }
            }
            
            html += '</dl>';
            document.getElementById('serviceInfoContent').innerHTML = html;
        }
    } catch (error) {
        document.getElementById('serviceInfoContent').innerHTML = 
            `<div class="alert alert-danger">Ошибка загрузки информации: ${error.message}</div>`;
    }
}

// Загрузка метрик сервиса
async function loadServiceMetrics(serviceName) {
    try {
        const response = await fetch(`/api/v1/admin/services/${serviceName}/metrics`);
        const data = await response.json();
        if (data.success) {
            const metrics = data.metrics || {};
            let html = '<div class="row">';
            
            // Метрики производительности
            if (metrics.performance_metrics) {
                html += '<div class="col-md-6 mb-3">';
                html += '<h6><i class="bi bi-speedometer2"></i> Метрики производительности</h6>';
                html += '<div class="card">';
                html += '<div class="card-body">';
                html += '<table class="table table-sm table-hover mb-0">';
                html += '<thead><tr><th>Метрика</th><th>Значение</th></tr></thead>';
                html += '<tbody>';
                for (const [key, value] of Object.entries(metrics.performance_metrics)) {
                    const formattedValue = typeof value === 'number' ? value.toFixed(2) : value;
                    html += `<tr><td><code>${escapeHtml(key)}</code></td><td><strong>${formattedValue}</strong></td></tr>`;
                }
                html += '</tbody></table>';
                html += '</div></div></div>';
            }
            
            // Метрики ресурсов
            if (metrics.resource_metrics) {
                html += '<div class="col-md-6 mb-3">';
                html += '<h6><i class="bi bi-cpu"></i> Метрики ресурсов</h6>';
                html += '<div class="card">';
                html += '<div class="card-body">';
                html += '<table class="table table-sm table-hover mb-0">';
                html += '<thead><tr><th>Метрика</th><th>Значение</th></tr></thead>';
                html += '<tbody>';
                for (const [key, value] of Object.entries(metrics.resource_metrics)) {
                    let formattedValue = value;
                    if (typeof value === 'number') {
                        if (key.includes('memory') || key.includes('bytes')) {
                            formattedValue = formatBytes(value);
                        } else {
                            formattedValue = value.toFixed(2);
                        }
                    }
                    html += `<tr><td><code>${escapeHtml(key)}</code></td><td><strong>${formattedValue}</strong></td></tr>`;
                }
                html += '</tbody></table>';
                html += '</div></div></div>';
            }
            
            html += '</div>';
            
            // Метрики здоровья
            if (metrics.health_metrics) {
                html += '<div class="mt-3">';
                html += '<h6><i class="bi bi-heart-pulse"></i> Метрики здоровья</h6>';
                html += '<div class="card">';
                html += '<div class="card-body">';
                html += '<pre class="bg-light p-3 rounded mb-0" style="max-height: 300px; overflow-y: auto;">' + 
                        escapeHtml(JSON.stringify(metrics.health_metrics, null, 2)) + '</pre>';
                html += '</div></div></div>';
            }
            
            if (!metrics.performance_metrics && !metrics.resource_metrics && !metrics.health_metrics) {
                html = '<div class="alert alert-info">Метрики недоступны для этого сервиса</div>';
            }
            
            document.getElementById('serviceMetricsContent').innerHTML = html;
        }
    } catch (error) {
        document.getElementById('serviceMetricsContent').innerHTML = 
            `<div class="alert alert-danger">Ошибка загрузки метрик: ${error.message}</div>`;
    }
}

// Форматирование байтов
function formatBytes(bytes) {
    if (bytes === 0) return '0 Bytes';
    const k = 1024;
    const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB'];
    const i = Math.floor(Math.log(bytes) / Math.log(k));
    return Math.round(bytes / Math.pow(k, i) * 100) / 100 + ' ' + sizes[i];
}

// Загрузка трейсов сервиса
async function loadServiceTraces(serviceName) {
    try {
        const searchText = document.getElementById('traceSearchInput').value;
        let url = `/api/v1/tracing/traces?service=${serviceName}`;
        if (searchText) {
            url += `&trace_id=${searchText}`;
        }
        
        const response = await fetch(url);
        const data = await response.json();
        if (data.success && data.traces) {
            let html = '';
            if (data.traces.length === 0) {
                html = '<p class="text-muted">Трейсы не найдены</p>';
            } else {
                html = '<div class="list-group">';
                data.traces.forEach(trace => {
                    html += `<a href="#" class="list-group-item list-group-item-action" onclick="showTraceDetails('${trace.trace_id}')">`;
                    html += `<div class="d-flex w-100 justify-content-between">`;
                    html += `<h6 class="mb-1">Trace ID: ${trace.trace_id}</h6>`;
                    html += `<small>${new Date(trace.start_time).toLocaleString('ru-RU')}</small>`;
                    html += `</div>`;
                    html += `<p class="mb-1">Spans: ${trace.spans?.length || 0}</p>`;
                    html += `</a>`;
                });
                html += '</div>';
            }
            document.getElementById('tracesList').innerHTML = html;
        }
    } catch (error) {
        document.getElementById('tracesList').innerHTML = 
            `<div class="alert alert-danger">Ошибка загрузки трейсов: ${error.message}</div>`;
    }
}

// Показать детали трейса
async function showTraceDetails(traceId) {
    try {
        const response = await fetch(`/api/v1/tracing/trace/${traceId}`);
        const data = await response.json();
        if (data.success) {
            const trace = data.trace;
            let html = '<h6>Детали трейса</h6>';
            html += `<p><strong>Trace ID:</strong> ${trace.trace_id}</p>`;
            html += `<p><strong>Начало:</strong> ${new Date(trace.start_time).toLocaleString('ru-RU')}</p>`;
            html += `<p><strong>Длительность:</strong> ${trace.duration || 0}ms</p>`;
            html += '<h6 class="mt-3">Spans</h6>';
            html += '<pre class="bg-light p-3 rounded" style="max-height: 300px; overflow-y: auto;">';
            html += JSON.stringify(trace.spans || [], null, 2);
            html += '</pre>';
            
            // Показываем в модальном окне или alert
            alert(html.replace(/<[^>]*>/g, ''));
        }
    } catch (error) {
        showAlert('Ошибка загрузки трейса: ' + error.message, 'danger');
    }
}

// Начать поток логов
function startLogsStream() {
    if (!currentServiceName) return;
    
    stopLogsStream();
    
    const logsOutput = document.getElementById('logsOutput');
    logsOutput.innerHTML = '<div class="text-info">Подключение к потоку логов...</div>';
    
    // Используем Server-Sent Events для потоковой передачи логов
    logsEventSource = new EventSource(`/api/v1/admin/services/${currentServiceName}/logs/stream`);
    
    logsEventSource.onmessage = function(event) {
        const logEntry = JSON.parse(event.data);
        const logLine = document.createElement('div');
        logLine.textContent = `[${new Date(logEntry.timestamp).toLocaleTimeString('ru-RU')}] ${logEntry.message}`;
        logLine.className = logEntry.level === 'ERROR' ? 'text-danger' : 
                           (logEntry.level === 'WARN' ? 'text-warning' : 'text-light');
        logsOutput.appendChild(logLine);
        logsOutput.scrollTop = logsOutput.scrollHeight;
    };
    
    logsEventSource.onerror = function() {
        logsOutput.innerHTML += '<div class="text-danger">Ошибка подключения к потоку логов</div>';
        stopLogsStream();
    };
}

// Остановить поток логов
function stopLogsStream() {
    if (logsEventSource) {
        logsEventSource.close();
        logsEventSource = null;
    }
}

// Управление жизненным циклом сервиса
async function startService(serviceName) {
    if (!confirm(`Запустить сервис ${serviceName}?`)) return;
    
    try {
        const response = await fetch(`/api/v1/admin/services/${serviceName}/start`, {
            method: 'POST'
        });
        const data = await response.json();
        if (data.success) {
            showAlert(`Сервис ${serviceName} запущен`, 'success');
            await loadServices();
        } else {
            showAlert('Ошибка запуска сервиса: ' + data.error, 'danger');
        }
    } catch (error) {
        showAlert('Ошибка при запуске сервиса: ' + error.message, 'danger');
    }
}

async function stopService(serviceName) {
    if (!confirm(`Остановить сервис ${serviceName}?`)) return;
    
    try {
        const response = await fetch(`/api/v1/admin/services/${serviceName}/stop`, {
            method: 'POST'
        });
        const data = await response.json();
        if (data.success) {
            showAlert(`Сервис ${serviceName} остановлен`, 'success');
            await loadServices();
        } else {
            showAlert('Ошибка остановки сервиса: ' + data.error, 'danger');
        }
    } catch (error) {
        showAlert('Ошибка при остановке сервиса: ' + error.message, 'danger');
    }
}

async function restartService(serviceName) {
    if (!confirm(`Перезапустить сервис ${serviceName}?`)) return;
    
    try {
        const response = await fetch(`/api/v1/admin/services/${serviceName}/restart`, {
            method: 'POST'
        });
        const data = await response.json();
        if (data.success) {
            showAlert(`Сервис ${serviceName} перезапущен`, 'success');
            await loadServices();
        } else {
            showAlert('Ошибка перезапуска сервиса: ' + data.error, 'danger');
        }
    } catch (error) {
        showAlert('Ошибка при перезапуске сервиса: ' + error.message, 'danger');
    }
}

// Масштабирование сервиса (FR-022)
async function scaleService() {
    if (!currentServiceName) return;
    
    const scaleCount = parseInt(document.getElementById('scaleCount').value);
    if (isNaN(scaleCount) || scaleCount < 1) {
        showAlert('Укажите корректное количество экземпляров (>= 1)', 'warning');
        return;
    }
    
    if (!confirm(`Масштабировать сервис ${currentServiceName} до ${scaleCount} экземпляров?`)) {
        return;
    }
    
    try {
        const response = await fetch(`/api/v1/admin/services/${currentServiceName}/scale`, {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json'
            },
            body: JSON.stringify({
                replicas: scaleCount
            })
        });
        
        const data = await response.json();
        if (data.success) {
            showAlert(`Сервис ${currentServiceName} масштабирован до ${scaleCount} экземпляров`, 'success');
            await loadServices();
            await loadServiceInfo(currentServiceName);
        } else {
            showAlert('Ошибка масштабирования: ' + data.error, 'danger');
        }
    } catch (error) {
        showAlert('Ошибка при масштабировании: ' + error.message, 'danger');
    }
}

// Обновление списка сервисов
async function refreshServices() {
    await loadServices();
    showAlert('Список сервисов обновлен', 'success');
}

// Проверка здоровья всех сервисов
async function checkAllHealth() {
    showAlert('Проверка здоровья всех сервисов...', 'info');
    await loadServices();
    showAlert('Проверка завершена', 'success');
}

// Проверка здоровья конкретного endpoint
async function checkHealth(serviceName, host, port) {
    try {
        const response = await fetch(`/api/v1/admin/services/${serviceName}/health-check`, {
            method: 'POST'
        });
        const data = await response.json();
        if (data.success) {
            showAlert('Проверка здоровья выполнена', 'success');
            await loadServices();
        } else {
            showAlert('Ошибка проверки здоровья: ' + data.error, 'danger');
        }
    } catch (error) {
        showAlert('Ошибка при проверке здоровья: ' + error.message, 'danger');
    }
}

// Утилита для экранирования HTML
function escapeHtml(text) {
    const div = document.createElement('div');
    div.textContent = text;
    return div.innerHTML;
}

// Утилита для показа алертов
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.appendChild(alertDiv);
    setTimeout(() => alertDiv.remove(), 5000);
}

// Обновление версии сервиса (FR-022)
async function updateServiceVersion() {
    if (!currentServiceName) return;
    
    const newImage = document.getElementById('newImage').value.trim();
    const pullImage = document.getElementById('pullImage').checked;
    
    if (!newImage) {
        showAlert('Укажите новый образ Docker', 'warning');
        return;
    }
    
    if (!confirm(`Обновить сервис ${currentServiceName} до версии ${newImage}?\n\nЭто остановит все контейнеры сервиса, загрузит новый образ и запустит контейнеры с новой версией.`)) {
        return;
    }
    
    try {
        showAlert('Обновление версии сервиса...', 'info');
        const response = await fetch(`/api/v1/admin/services/${currentServiceName}/update-version`, {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json'
            },
            body: JSON.stringify({
                image: newImage,
                pull_image: pullImage
            })
        });
        
        const data = await response.json();
        if (data.success) {
            showAlert(`Сервис ${currentServiceName} успешно обновлен до версии ${newImage}`, 'success');
            // Очищаем поле ввода
            document.getElementById('newImage').value = '';
            // Обновляем список сервисов
            await loadServices();
            // Обновляем информацию о сервисе
            await loadServiceInfo(currentServiceName);
        } else {
            showAlert('Ошибка обновления версии: ' + data.error, 'danger');
        }
    } catch (error) {
        showAlert('Ошибка при обновлении версии: ' + error.message, 'danger');
    }
}

// Очистка при закрытии модального окна
document.getElementById('serviceDetailsModal').addEventListener('hidden.bs.modal', function() {
    stopLogsStream();
    currentServiceName = null;
});

// Автообновление каждые 30 секунд
setInterval(loadServices, 30000);

// Загружаем сервисы при загрузке страницы
document.addEventListener('DOMContentLoaded', loadServices);
