/**
 * JavaScript для управления контейнерами (FR-025).
 * Сначала проверяется доступность Docker API; при недоступности показывается уведомление вместо списка.
 */

let currentContainerId = null;
let containersData = [];
let containersAvailable = false;
let refreshIntervalId = null;

document.addEventListener('DOMContentLoaded', function() {
    checkContainersAvailability();

    document.getElementById('containerSearch').addEventListener('input', function(e) {
        filterContainers(e.target.value);
    });

    const retryBtn = document.getElementById('containersRetryButton');
    if (retryBtn) {
        retryBtn.addEventListener('click', function() {
            checkContainersAvailability();
        });
    }

    const resourcesTab = document.getElementById('resources-tab');
    if (resourcesTab) {
        resourcesTab.addEventListener('shown.bs.tab', function() {
            if (currentContainerId) {
                loadContainerResources(currentContainerId);
            }
        });
    }

    const eventsTab = document.getElementById('events-tab');
    if (eventsTab) {
        eventsTab.addEventListener('shown.bs.tab', function() {
            if (currentContainerId) {
                loadContainerEvents(currentContainerId);
            }
        });
    }
});

/**
 * Проверка доступности управления контейнерами (Docker API).
 * При доступности показывается таблица и загружается список; при недоступности — уведомление.
 */
async function checkContainersAvailability() {
    const listCard = document.getElementById('containersListCard');
    const unavailableBlock = document.getElementById('containersUnavailableBlock');
    const messageEl = document.getElementById('containersUnavailableMessage');
    const tbody = document.getElementById('containersTableBody');

    try {
        const response = await fetch('/api/admin/containers/status');
        const data = await response.json();
        if (data.success && data.available) {
            containersAvailable = true;
            if (unavailableBlock) unavailableBlock.classList.add('d-none');
            if (listCard) listCard.classList.remove('d-none');
            if (refreshIntervalId) clearInterval(refreshIntervalId);
            refreshIntervalId = setInterval(loadContainers, 10000);
            loadContainers();
        } else {
            containersAvailable = false;
            if (refreshIntervalId) {
                clearInterval(refreshIntervalId);
                refreshIntervalId = null;
            }
            if (listCard) listCard.classList.add('d-none');
            if (unavailableBlock) {
                unavailableBlock.classList.remove('d-none');
                if (messageEl && data.message) {
                    messageEl.innerHTML = 'Docker API недоступен: ' + escapeHtml(data.message) + '. ' +
                        'Установите Docker на сервере или убедитесь, что демон запущен и приложение имеет к нему доступ (например, сокет <code>/var/run/docker.sock</code>).';
                }
            }
            if (tbody) {
                tbody.innerHTML = '';
            }
        }
    } catch (error) {
        console.error('Ошибка проверки доступности контейнеров:', error);
        containersAvailable = false;
        if (listCard) listCard.classList.add('d-none');
        if (unavailableBlock) {
            unavailableBlock.classList.remove('d-none');
            if (messageEl) {
                messageEl.textContent = 'Не удалось проверить доступность Docker: ' + error.message;
            }
        }
    }
}

/**
 * Загрузка списка контейнеров (вызывается только при доступном Docker).
 */
async function loadContainers() {
    if (!containersAvailable) return;
    try {
        const response = await fetch('/api/admin/containers/list');
        const data = await response.json();
        if (data.success) {
            containersData = data.containers || [];
            renderContainers(containersData);
        } else {
            showError('Ошибка загрузки контейнеров: ' + (data.error || 'Неизвестная ошибка'));
        }
    } catch (error) {
        console.error('Ошибка загрузки контейнеров:', error);
        showError('Ошибка загрузки контейнеров: ' + error.message);
    }
}

/**
 * Отображение списка контейнеров
 */
function renderContainers(containers) {
    const tbody = document.getElementById('containersTableBody');
    tbody.innerHTML = '';
    
    if (containers.length === 0) {
        tbody.innerHTML = '<tr><td colspan="6" class="text-center text-muted">Контейнеры не найдены</td></tr>';
        return;
    }
    
    containers.forEach(container => {
        const tr = document.createElement('tr');
        const statusBadge = container.status === 'running' 
            ? '<span class="badge bg-success-container text-success">Выполняется</span>'
            : `<span class="badge bg-secondary">${escapeHtml(container.status)}</span>`;
        
        tr.innerHTML = `
            <td><code>${escapeHtml(container.short_id)}</code></td>
            <td><strong>${escapeHtml(container.name)}</strong></td>
            <td>${escapeHtml(container.image)}</td>
            <td>${statusBadge}</td>
            <td>
                <button class="btn btn-sm btn-info" onclick="loadContainerResources('${escapeHtml(container.id)}')" title="Просмотр ресурсов">
                    <i class="bi bi-cpu"></i>
                </button>
            </td>
            <td>
                <button class="btn btn-sm btn-primary" onclick="openContainerDetails('${escapeHtml(container.id)}')" title="Детали">
                    <i class="bi bi-info-circle"></i>
                </button>
                <button class="btn btn-sm btn-success" onclick="containerAction('${escapeHtml(container.id)}', 'start')" ${container.status === 'running' ? 'disabled' : ''} title="Старт">
                    <i class="bi bi-play-fill"></i>
                </button>
                <button class="btn btn-sm btn-warning" onclick="containerAction('${escapeHtml(container.id)}', 'restart')" title="Рестарт">
                    <i class="bi bi-arrow-clockwise"></i>
                </button>
                <button class="btn btn-sm btn-danger" onclick="containerAction('${escapeHtml(container.id)}', 'stop')" ${container.status !== 'running' ? 'disabled' : ''} title="Стоп">
                    <i class="bi bi-stop-fill"></i>
                </button>
            </td>
        `;
        tbody.appendChild(tr);
    });
}

/**
 * Фильтрация контейнеров
 */
function filterContainers(query) {
    const lowerQuery = query.toLowerCase();
    const filtered = containersData.filter(container => 
        container.name.toLowerCase().includes(lowerQuery) ||
        container.id.toLowerCase().includes(lowerQuery) ||
        container.image.toLowerCase().includes(lowerQuery)
    );
    renderContainers(filtered);
}

/**
 * Открытие модального окна с деталями контейнера
 */
async function openContainerDetails(containerId) {
    currentContainerId = containerId;
    
    try {
        const response = await fetch(`/api/v1/admin/containers/${containerId}/details`);
        const data = await response.json();
        if (data.success) {
            const container = data.container;
            document.getElementById('modalContainerName').textContent = container.name;
            renderContainerInfo(container);
            
            // Загружаем ресурсы и события
            loadContainerResources(containerId);
            loadContainerEvents(containerId);
            
            const modal = new bootstrap.Modal(document.getElementById('containerDetailsModal'));
            modal.show();
        } else {
            showError('Ошибка загрузки деталей: ' + (data.error || 'Неизвестная ошибка'));
        }
    } catch (error) {
        console.error('Ошибка загрузки деталей:', error);
        showError('Ошибка загрузки деталей: ' + error.message);
    }
}

/**
 * Отображение информации о контейнере
 */
function renderContainerInfo(container) {
    const content = document.getElementById('containerInfoContent');
    content.innerHTML = `
        <div class="row">
            <div class="col-md-6">
                <h6>Основная информация</h6>
                <table class="table table-sm">
                    <tr><td><strong>ID:</strong></td><td><code>${escapeHtml(container.short_id)}</code></td></tr>
                    <tr><td><strong>Имя:</strong></td><td>${escapeHtml(container.name)}</td></tr>
                    <tr><td><strong>Образ:</strong></td><td>${escapeHtml(container.image)}</td></tr>
                    <tr><td><strong>Статус:</strong></td><td>${escapeHtml(container.status)}</td></tr>
                    <tr><td><strong>Создан:</strong></td><td>${escapeHtml(container.created)}</td></tr>
                    <tr><td><strong>Запущен:</strong></td><td>${escapeHtml(container.started_at || 'N/A')}</td></tr>
                </table>
            </div>
            <div class="col-md-6">
                <h6>Конфигурация</h6>
                <table class="table table-sm">
                    <tr><td><strong>Рабочая директория:</strong></td><td>${escapeHtml(container.working_dir || 'N/A')}</td></tr>
                    <tr><td><strong>Команда:</strong></td><td><code>${escapeHtml((container.command || []).join(' '))}</code></td></tr>
                    <tr><td><strong>Entrypoint:</strong></td><td><code>${escapeHtml((container.entrypoint || []).join(' '))}</code></td></tr>
                </table>
            </div>
        </div>
        <div class="row mt-3">
            <div class="col-12">
                <h6>Переменные окружения</h6>
                <pre class="bg-light p-2" style="max-height: 200px; overflow-y: auto;">${escapeHtml((container.env || []).join('\n'))}</pre>
            </div>
        </div>
    `;
}

/**
 * Загрузка ресурсов контейнера
 */
async function loadContainerResources(containerId) {
    try {
        const response = await fetch(`/api/v1/admin/containers/${containerId}/resources`);
        const data = await response.json();
        if (data.success) {
            renderContainerResources(data.resources);
            
            // Заполняем поля для редактирования
            if (data.resources.cpu) {
                document.getElementById('cpuQuota').value = data.resources.cpu.quota || '';
                document.getElementById('cpuPeriod').value = data.resources.cpu.period || '';
            }
            if (data.resources.memory) {
                document.getElementById('memoryLimit').value = data.resources.memory.limit || '';
                document.getElementById('memorySwap').value = data.resources.memory.swap || '';
            }
        } else {
            document.getElementById('containerResourcesContent').innerHTML = 
                '<p class="text-danger">Ошибка загрузки ресурсов: ' + (data.error || 'Неизвестная ошибка') + '</p>';
        }
    } catch (error) {
        console.error('Ошибка загрузки ресурсов:', error);
        document.getElementById('containerResourcesContent').innerHTML = 
            '<p class="text-danger">Ошибка загрузки ресурсов: ' + error.message + '</p>';
    }
}

/**
 * Отображение ресурсов контейнера
 */
function renderContainerResources(resources) {
    const content = document.getElementById('containerResourcesContent');
    
    const cpuPercent = resources.cpu?.usage_percent || 0;
    const memoryPercent = resources.memory?.usage_percent || 0;
    const memoryUsage = formatBytes(resources.memory?.usage || 0);
    const memoryLimit = formatBytes(resources.memory?.limit || 0);
    const networkRx = formatBytes(resources.network?.rx_bytes || 0);
    const networkTx = formatBytes(resources.network?.tx_bytes || 0);
    const diskRead = formatBytes(resources.disk?.read_bytes || 0);
    const diskWrite = formatBytes(resources.disk?.write_bytes || 0);
    
    content.innerHTML = `
        <div class="row">
            <div class="col-md-6 mb-3">
                <div class="card">
                    <div class="card-body">
                        <h6 class="card-title">CPU</h6>
                        <div class="progress mb-2" style="height: 25px;">
                            <div class="progress-bar" role="progressbar" style="width: ${cpuPercent}%">
                                ${cpuPercent.toFixed(1)}%
                            </div>
                        </div>
                        <small class="text-muted">
                            Ядер: ${resources.cpu?.cores || 'N/A'} | 
                            Quota: ${resources.cpu?.quota || 'N/A'} | 
                            Period: ${resources.cpu?.period || 'N/A'}
                        </small>
                    </div>
                </div>
            </div>
            <div class="col-md-6 mb-3">
                <div class="card">
                    <div class="card-body">
                        <h6 class="card-title">Память</h6>
                        <div class="progress mb-2" style="height: 25px;">
                            <div class="progress-bar bg-success" role="progressbar" style="width: ${memoryPercent}%">
                                ${memoryPercent.toFixed(1)}%
                            </div>
                        </div>
                        <small class="text-muted">
                            Использовано: ${memoryUsage} / ${memoryLimit}
                        </small>
                    </div>
                </div>
            </div>
        </div>
        <div class="row">
            <div class="col-md-6 mb-3">
                <div class="card">
                    <div class="card-body">
                        <h6 class="card-title">Сеть</h6>
                        <p class="mb-0">
                            <strong>Получено:</strong> ${networkRx}<br>
                            <strong>Отправлено:</strong> ${networkTx}
                        </p>
                    </div>
                </div>
            </div>
            <div class="col-md-6 mb-3">
                <div class="card">
                    <div class="card-body">
                        <h6 class="card-title">Диск</h6>
                        <p class="mb-0">
                            <strong>Прочитано:</strong> ${diskRead}<br>
                            <strong>Записано:</strong> ${diskWrite}
                        </p>
                    </div>
                </div>
            </div>
        </div>
    `;
}

/**
 * Обновление ресурсов контейнера
 */
async function updateContainerResources() {
    if (!currentContainerId) return;
    
    const cpuQuota = document.getElementById('cpuQuota').value;
    const cpuPeriod = document.getElementById('cpuPeriod').value;
    const memoryLimit = document.getElementById('memoryLimit').value;
    const memorySwap = document.getElementById('memorySwap').value;
    
    const data = {};
    if (cpuQuota) data.cpu_quota = parseInt(cpuQuota);
    if (cpuPeriod) data.cpu_period = parseInt(cpuPeriod);
    if (memoryLimit) data.memory = parseInt(memoryLimit);
    if (memorySwap) data.memory_swap = parseInt(memorySwap);
    
    try {
        const response = await fetch(`/api/v1/admin/containers/${currentContainerId}/resources`, {
            method: 'PUT',
            headers: {
                'Content-Type': 'application/json'
            },
            body: JSON.stringify(data)
        });
        
        const result = await response.json();
        if (result.success) {
            showSuccess('Ресурсы успешно обновлены');
            loadContainerResources(currentContainerId);
        } else {
            showError(result.error || 'Ошибка обновления ресурсов');
        }
    } catch (error) {
        console.error('Ошибка обновления ресурсов:', error);
        showError('Ошибка обновления ресурсов: ' + error.message);
    }
}

/**
 * Загрузка событий контейнера
 */
async function loadContainerEvents(containerId) {
    try {
        const response = await fetch(`/api/v1/admin/containers/${containerId}/events`);
        const data = await response.json();
        if (data.success) {
            renderContainerEvents(data.events);
        } else {
            document.getElementById('containerEventsContent').innerHTML = 
                '<p class="text-danger">Ошибка загрузки событий: ' + (data.error || 'Неизвестная ошибка') + '</p>';
        }
    } catch (error) {
        console.error('Ошибка загрузки событий:', error);
        document.getElementById('containerEventsContent').innerHTML = 
            '<p class="text-danger">Ошибка загрузки событий: ' + error.message + '</p>';
    }
}

/**
 * Отображение событий контейнера
 */
function renderContainerEvents(events) {
    const content = document.getElementById('containerEventsContent');
    
    if (events.length === 0) {
        content.innerHTML = '<p class="text-muted">События не найдены</p>';
        return;
    }
    
    const table = document.createElement('table');
    table.className = 'table table-sm table-hover';
    table.innerHTML = `
        <thead>
            <tr>
                <th>Время</th>
                <th>Тип</th>
                <th>Действие</th>
                <th>Статус</th>
            </tr>
        </thead>
        <tbody>
        </tbody>
    `;
    
    const tbody = table.querySelector('tbody');
    events.forEach(event => {
        const tr = document.createElement('tr');
        const time = new Date(event.time * 1000).toLocaleString();
        tr.innerHTML = `
            <td>${escapeHtml(time)}</td>
            <td>${escapeHtml(event.type || 'N/A')}</td>
            <td>${escapeHtml(event.action || 'N/A')}</td>
            <td>${escapeHtml(event.status || 'N/A')}</td>
        `;
        tbody.appendChild(tr);
    });
    
    content.innerHTML = '';
    content.appendChild(table);
}

/**
 * Действия с контейнером
 */
async function containerAction(containerId, action) {
    try {
        const response = await fetch(`/api/admin/containers/${containerId}/${action}`, {
            method: 'POST'
        });
        const data = await response.json();
        if (data.success) {
            showSuccess(`Контейнер ${action === 'start' ? 'запущен' : action === 'stop' ? 'остановлен' : 'перезапущен'}`);
            loadContainers();
        } else {
            showError(data.error || 'Ошибка выполнения действия');
        }
    } catch (error) {
        console.error('Ошибка выполнения действия:', error);
        showError('Ошибка выполнения действия: ' + error.message);
    }
}

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

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

function formatBytes(bytes) {
    if (bytes === 0) return '0 B';
    const k = 1024;
    const sizes = ['B', '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];
}

function showSuccess(message) {
    alert(message);
}

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