// Управление плагинами (FR-028)
let pluginsData = [];
let currentConfigPlugin = null;
let currentLogsPlugin = null;
let searchTimeout = null;

// Инициализация при загрузке страницы
document.addEventListener('DOMContentLoaded', function() {
    refreshPlugins();
    // Поиск с задержкой при вводе
    const searchEl = document.getElementById('pluginSearch');
    if (searchEl) {
        searchEl.addEventListener('input', function() {
            clearTimeout(searchTimeout);
            searchTimeout = setTimeout(refreshPlugins, 300);
        });
    }
    ['pluginStatusFilter', 'pluginCompatibleFilter', 'pluginRequiredFilter'].forEach(function(id) {
        const el = document.getElementById(id);
        if (el) el.addEventListener('change', refreshPlugins);
    });
    // Автообновление каждые 30 секунд
    setInterval(refreshPlugins, 30000);
    document.getElementById('order-tab').addEventListener('shown.bs.tab', function() {
        loadExecutionOrder();
    });
    document.getElementById('metrics-tab').addEventListener('shown.bs.tab', function() {
        refreshMetrics();
    });
});

// Формирование URL с параметрами фильтрации (FR-028)
function getPluginsApiUrl() {
    const params = new URLSearchParams();
    const includeAvailable = document.getElementById('pluginIncludeAvailable');
    if (includeAvailable && includeAvailable.checked) params.set('include_available', 'true');
    const search = document.getElementById('pluginSearch');
    if (search && search.value.trim()) params.set('search', search.value.trim());
    const status = document.getElementById('pluginStatusFilter');
    if (status && status.value) params.set('status', status.value);
    const compatible = document.getElementById('pluginCompatibleFilter');
    if (compatible && compatible.value) params.set('compatible', compatible.value);
    const required = document.getElementById('pluginRequiredFilter');
    if (required && required.value) params.set('required', required.value);
    const qs = params.toString();
    return '/api/v1/admin/plugins' + (qs ? '?' + qs : '');
}

// Обновление списка плагинов
async function refreshPlugins() {
    try {
        const url = getPluginsApiUrl();
        const response = await fetch(url);
        const data = await response.json();
        if (data.success) {
            pluginsData = Object.entries(data.plugins || {}).map(([name, plugin]) => ({
                name: name,
                ...plugin
            }));
            renderPlugins();
        } else {
            showError('Ошибка загрузки плагинов: ' + (data.error || 'Неизвестная ошибка'));
        }
    } catch (error) {
        showError('Ошибка при загрузке плагинов: ' + error.message);
    }
}

// Бейдж совместимости (FR-028)
function getCompatibilityBadge(plugin) {
    const comp = plugin.compatibility;
    if (!comp) return '<span class="badge bg-secondary">—</span>';
    if (comp.is_compatible === true) return '<span class="badge bg-success">Совместим</span>';
    return '<span class="badge bg-danger" title="' + escapeHtml(comp.error || '') + '">Не совместим</span>';
}

// Отображение списка плагинов
function renderPlugins() {
    const container = document.getElementById('pluginsContainer');
    if (pluginsData.length === 0) {
        container.innerHTML = '<div class="alert alert-info">Плагины не найдены. Включите «Показать доступные», чтобы увидеть незагруженные плагины.</div>';
        return;
    }
    let html = '<div class="table-responsive"><table class="admin-table table table-hover table-sm">';
    html += '<thead><tr><th>Имя</th><th>Версия</th><th>Описание</th><th>Статус</th><th>Совместимость</th><th>Разрешения</th><th>Действия</th></tr></thead><tbody>';
    pluginsData.forEach(plugin => {
        const statusBadge = getStatusBadge(plugin.status);
        const compBadge = getCompatibilityBadge(plugin);
        const permissions = (plugin.permissions || []).join(', ') || 'Нет';
        const isAvailable = plugin.status === 'available' || plugin.is_loaded === false;
        const requiredBadge = plugin.is_required ? ' <span class="badge bg-warning text-dark">Обязательный</span>' : '';
        let actions = '';
        if (isAvailable) {
            actions = '<button class="btn btn-success btn-sm" onclick="loadPlugin(\'' + plugin.name + '\')" title="Загрузить"><i class="bi bi-download"></i> Загрузить</button>';
        } else {
            actions = '<div class="btn-group btn-group-sm">';
            if (plugin.status === 'started') {
                actions += '<button class="btn btn-warning" onclick="stopPlugin(\'' + plugin.name + '\')" title="Остановить"><i class="bi bi-stop"></i></button>';
            } else {
                actions += '<button class="btn btn-success" onclick="startPlugin(\'' + plugin.name + '\')" title="Запустить"><i class="bi bi-play"></i></button>';
            }
            actions += '<button class="btn btn-primary" onclick="reloadPlugin(\'' + plugin.name + '\')" title="Перезагрузить"><i class="bi bi-arrow-clockwise"></i></button>';
            actions += '<button class="btn btn-info" onclick="showPluginConfig(\'' + plugin.name + '\')" title="Конфигурация"><i class="bi bi-gear"></i></button>';
            actions += '<button class="btn btn-secondary" onclick="showPluginLogs(\'' + plugin.name + '\')" title="Логи"><i class="bi bi-file-text"></i></button>';
            actions += '<button class="btn btn-danger" onclick="unloadPlugin(\'' + plugin.name + '\')" title="Выгрузить"' + (plugin.is_required ? ' disabled' : '') + '><i class="bi bi-x-circle"></i></button>';
            actions += '</div>';
        }
        actions += ' <button class="btn btn-outline-secondary btn-sm" onclick="showPluginInfo(\'' + plugin.name + '\')" title="Подробнее"><i class="bi bi-info-circle"></i></button>';
        html += '<tr>' +
            '<td><strong>' + escapeHtml(plugin.name) + '</strong>' + requiredBadge + '</td>' +
            '<td>' + escapeHtml(plugin.version) + '</td>' +
            '<td><small>' + escapeHtml((plugin.description || '').slice(0, 60)) + (plugin.description && plugin.description.length > 60 ? '…' : '') + '</small></td>' +
            '<td>' + statusBadge + '</td>' +
            '<td>' + compBadge + '</td>' +
            '<td><small>' + escapeHtml(permissions) + '</small></td>' +
            '<td>' + actions + '</td></tr>';
    });
    html += '</tbody></table></div>';
    container.innerHTML = html;
}

// Загрузка плагина (FR-028 — доступные плагины)
async function loadPlugin(name) {
    try {
        const response = await fetch('/api/v1/admin/plugins/' + encodeURIComponent(name) + '/load', { method: 'POST' });
        const data = await response.json();
        if (data.success) {
            showSuccess('Плагин загружен и запущен');
            refreshPlugins();
            loadExecutionOrder();
        } else {
            showError('Ошибка: ' + (data.error || 'Неизвестная ошибка'));
        }
    } catch (error) {
        showError('Ошибка при загрузке плагина: ' + error.message);
    }
}

// Подробная информация о плагине (FR-028)
async function showPluginInfo(pluginName) {
    document.getElementById('infoPluginName').textContent = pluginName;
    const container = document.getElementById('pluginInfoContainer');
    container.innerHTML = '<div class="text-center"><div class="spinner-border text-primary"></div></div>';
    const modal = new bootstrap.Modal(document.getElementById('infoModal'));
    modal.show();
    try {
        const response = await fetch('/api/v1/admin/plugins/' + encodeURIComponent(pluginName) + '/info');
        const data = await response.json();
        if (data.success) {
            const p = data.plugin;
            let body = '<dl class="row mb-0">';
            body += '<dt class="col-sm-4">Версия</dt><dd class="col-sm-8">' + escapeHtml(p.version || '—') + '</dd>';
            body += '<dt class="col-sm-4">Описание</dt><dd class="col-sm-8">' + escapeHtml(p.description || '—') + '</dd>';
            body += '<dt class="col-sm-4">Автор</dt><dd class="col-sm-8">' + escapeHtml(p.author || '—') + '</dd>';
            body += '<dt class="col-sm-4">Статус</dt><dd class="col-sm-8">' + getStatusBadge(p.status) + (p.is_required ? ' <span class="badge bg-warning text-dark">Обязательный</span>' : '') + '</dd>';
            body += '<dt class="col-sm-4">Загружен</dt><dd class="col-sm-8">' + (p.is_loaded ? 'Да' : 'Нет') + '</dd>';
            if (p.compatibility) {
                body += '<dt class="col-sm-4">Совместимость</dt><dd class="col-sm-8">' + getCompatibilityBadge(p) + (p.compatibility.error ? ' <small class="text-muted">' + escapeHtml(p.compatibility.error) + '</small>' : '') + '</dd>';
            }
            if ((p.dependencies || []).length) {
                body += '<dt class="col-sm-4">Зависимости</dt><dd class="col-sm-8">' + escapeHtml(p.dependencies.join(', ')) + '</dd>';
            }
            if ((p.containers || []).length) {
                body += '<dt class="col-sm-4">Контейнеры</dt><dd class="col-sm-8"><ul class="list-unstyled mb-0">';
                p.containers.forEach(function(c) {
                    body += '<li><code>' + escapeHtml(c.name || c.id || JSON.stringify(c)) + '</code></li>';
                });
                body += '</ul></dd>';
            }
            body += '</dl>';
            container.innerHTML = body;
        } else {
            container.innerHTML = '<div class="alert alert-danger">' + escapeHtml(data.error || 'Не удалось загрузить информацию') + '</div>';
        }
    } catch (error) {
        container.innerHTML = '<div class="alert alert-danger">' + escapeHtml(error.message) + '</div>';
    }
}

// Получение бейджа статуса
function getStatusBadge(status) {
    const badges = {
        'loaded': '<span class="badge bg-secondary">Загружен</span>',
        'started': '<span class="badge bg-success">Запущен</span>',
        'stopped': '<span class="badge bg-warning">Остановлен</span>',
        'available': '<span class="badge bg-info">Доступен</span>',
        'error': '<span class="badge bg-danger">Ошибка</span>',
        'disabled': '<span class="badge bg-dark">Отключен</span>'
    };
    return badges[status] || '<span class="badge bg-secondary">' + escapeHtml(String(status)) + '</span>';
}

// Управление плагинами
async function startPlugin(name) {
    try {
        const response = await fetch(`/api/v1/admin/plugins/${name}/start`, { method: 'POST' });
        const data = await response.json();
        
        if (data.success) {
            showSuccess('Плагин запущен');
            refreshPlugins();
        } else {
            showError('Ошибка: ' + (data.error || 'Неизвестная ошибка'));
        }
    } catch (error) {
        showError('Ошибка при запуске плагина: ' + error.message);
    }
}

async function stopPlugin(name) {
    if (!confirm(`Остановить плагин "${name}"?`)) return;
    
    try {
        const response = await fetch(`/api/v1/admin/plugins/${name}/stop`, { method: 'POST' });
        const data = await response.json();
        
        if (data.success) {
            showSuccess('Плагин остановлен');
            refreshPlugins();
        } else {
            showError('Ошибка: ' + (data.error || 'Неизвестная ошибка'));
        }
    } catch (error) {
        showError('Ошибка при остановке плагина: ' + error.message);
    }
}

async function reloadPlugin(name) {
    try {
        const response = await fetch(`/api/v1/admin/plugins/${name}/reload`, { method: 'POST' });
        const data = await response.json();
        
        if (data.success) {
            showSuccess('Плагин перезагружен');
            refreshPlugins();
        } else {
            showError('Ошибка: ' + (data.error || 'Неизвестная ошибка'));
        }
    } catch (error) {
        showError('Ошибка при перезагрузке плагина: ' + error.message);
    }
}

async function unloadPlugin(name) {
    if (!confirm(`Выгрузить плагин "${name}"? Это действие нельзя отменить.`)) return;
    
    try {
        const response = await fetch(`/api/v1/admin/plugins/${name}/unload`, { method: 'POST' });
        const data = await response.json();
        
        if (data.success) {
            showSuccess('Плагин выгружен');
            refreshPlugins();
        } else {
            showError('Ошибка: ' + (data.error || 'Неизвестная ошибка'));
        }
    } catch (error) {
        showError('Ошибка при выгрузке плагина: ' + error.message);
    }
}

// Конфигурация плагина
async function showPluginConfig(pluginName) {
    currentConfigPlugin = pluginName;
    document.getElementById('configPluginName').textContent = pluginName;
    
    try {
        const response = await fetch(`/api/v1/admin/plugins/${pluginName}/config`);
        const data = await response.json();
        
        if (data.success) {
            const configJson = JSON.stringify(data.config, null, 2);
            document.getElementById('configEditor').innerHTML = 
                `<textarea class="form-control" id="configTextarea" style="font-family: monospace; min-height: 300px;">${escapeHtml(configJson)}</textarea>`;
            
            const modal = new bootstrap.Modal(document.getElementById('configModal'));
            modal.show();
        } else {
            showError('Ошибка загрузки конфигурации: ' + (data.error || 'Неизвестная ошибка'));
        }
    } catch (error) {
        showError('Ошибка при загрузке конфигурации: ' + error.message);
    }
}

async function savePluginConfig() {
    if (!currentConfigPlugin) return;
    
    try {
        const configText = document.getElementById('configTextarea').value;
        const config = JSON.parse(configText);
        
        const response = await fetch(`/api/v1/admin/plugins/${currentConfigPlugin}/config`, {
            method: 'POST',
            headers: { 'Content-Type': 'application/json' },
            body: JSON.stringify({ config: config })
        });
        
        const data = await response.json();
        
        if (data.success) {
            showSuccess('Конфигурация сохранена');
            bootstrap.Modal.getInstance(document.getElementById('configModal')).hide();
        } else {
            showError('Ошибка сохранения: ' + (data.error || 'Неизвестная ошибка'));
        }
    } catch (error) {
        showError('Ошибка при сохранении конфигурации: ' + error.message);
    }
}

// Логи плагина
async function showPluginLogs(pluginName) {
    currentLogsPlugin = pluginName;
    document.getElementById('logsPluginName').textContent = pluginName;
    
    const modal = new bootstrap.Modal(document.getElementById('logsModal'));
    modal.show();
    
    refreshPluginLogs();
}

async function refreshPluginLogs() {
    if (!currentLogsPlugin) return;
    
    const level = document.getElementById('logLevelFilter').value;
    const url = `/api/v1/admin/plugins/${currentLogsPlugin}/logs?limit=100${level ? '&level=' + level : ''}`;
    
    try {
        const response = await fetch(url);
        const data = await response.json();
        
        if (data.success) {
            renderPluginLogs(data.logs || []);
        } else {
            showError('Ошибка загрузки логов: ' + (data.error || 'Неизвестная ошибка'));
        }
    } catch (error) {
        showError('Ошибка при загрузке логов: ' + error.message);
    }
}

function renderPluginLogs(logs) {
    const container = document.getElementById('pluginLogsContainer');
    
    if (logs.length === 0) {
        container.innerHTML = '<div class="alert alert-info">Логи не найдены</div>';
        return;
    }
    
    let html = '<div class="table-responsive"><table class="admin-table table table-sm table-hover">';
    html += '<thead><tr><th>Время</th><th>Уровень</th><th>Сообщение</th></tr></thead><tbody>';
    
    logs.reverse().forEach(log => {
        const timestamp = new Date(log.timestamp * 1000).toLocaleString();
        const levelBadge = getLogLevelBadge(log.level);
        
        html += `<tr>
            <td><small>${timestamp}</small></td>
            <td>${levelBadge}</td>
            <td>${escapeHtml(log.message)}</td>
        </tr>`;
    });
    
    html += '</tbody></table></div>';
    container.innerHTML = html;
}

function getLogLevelBadge(level) {
    const badges = {
        'info': '<span class="badge bg-info">Info</span>',
        'warning': '<span class="badge bg-warning">Warning</span>',
        'error': '<span class="badge bg-danger">Error</span>',
        'debug': '<span class="badge bg-secondary">Debug</span>'
    };
    return badges[level] || '<span class="badge bg-secondary">' + level + '</span>';
}

// Порядок выполнения плагинов
async function loadExecutionOrder() {
    try {
        const response = await fetch('/api/v1/admin/plugins/execution-order');
        const data = await response.json();
        
        if (data.success) {
            renderExecutionOrder(data.order || []);
        } else {
            showError('Ошибка загрузки порядка выполнения: ' + (data.error || 'Неизвестная ошибка'));
        }
    } catch (error) {
        showError('Ошибка при загрузке порядка выполнения: ' + error.message);
    }
}

function renderExecutionOrder(order) {
    const container = document.getElementById('executionOrderContainer');
    
    if (order.length === 0) {
        container.innerHTML = '<div class="alert alert-info">Плагины не найдены</div>';
        return;
    }
    
    let html = '<ul class="list-group" id="executionOrderList">';
    order.forEach((pluginName, index) => {
        html += `<li class="list-group-item d-flex justify-content-between align-items-center" data-plugin="${pluginName}">
            <div>
                <strong>${index + 1}.</strong> ${escapeHtml(pluginName)}
            </div>
            <div>
                <button class="btn btn-sm btn-outline-primary" onclick="movePluginUp('${pluginName}')" ${index === 0 ? 'disabled' : ''}>
                    <i class="bi bi-arrow-up"></i>
                </button>
                <button class="btn btn-sm btn-outline-primary" onclick="movePluginDown('${pluginName}')" ${index === order.length - 1 ? 'disabled' : ''}>
                    <i class="bi bi-arrow-down"></i>
                </button>
            </div>
        </li>`;
    });
    html += '</ul>';
    
    container.innerHTML = html;
}

function movePluginUp(pluginName) {
    const list = document.getElementById('executionOrderList');
    const items = Array.from(list.children);
    const index = items.findIndex(item => item.dataset.plugin === pluginName);
    
    if (index > 0) {
        list.insertBefore(items[index], items[index - 1]);
    }
}

function movePluginDown(pluginName) {
    const list = document.getElementById('executionOrderList');
    const items = Array.from(list.children);
    const index = items.findIndex(item => item.dataset.plugin === pluginName);
    
    if (index < items.length - 1) {
        list.insertBefore(items[index + 1], items[index]);
    }
}

async function saveExecutionOrder() {
    const list = document.getElementById('executionOrderList');
    const items = Array.from(list.children);
    const order = items.map(item => item.dataset.plugin);
    
    try {
        const response = await fetch('/api/v1/admin/plugins/execution-order', {
            method: 'POST',
            headers: { 'Content-Type': 'application/json' },
            body: JSON.stringify({ order: order })
        });
        
        const data = await response.json();
        
        if (data.success) {
            showSuccess('Порядок выполнения сохранен');
        } else {
            showError('Ошибка сохранения: ' + (data.error || 'Неизвестная ошибка'));
        }
    } catch (error) {
        showError('Ошибка при сохранении порядка выполнения: ' + error.message);
    }
}

// Метрики плагинов
async function refreshMetrics() {
    try {
        const response = await fetch('/api/v1/admin/plugins/metrics');
        const data = await response.json();
        
        if (data.success) {
            renderMetrics(data.metrics || {});
        } else {
            showError('Ошибка загрузки метрик: ' + (data.error || 'Неизвестная ошибка'));
        }
    } catch (error) {
        showError('Ошибка при загрузке метрик: ' + error.message);
    }
}

function renderMetrics(metrics) {
    const container = document.getElementById('metricsContainer');
    
    const pluginNames = Object.keys(metrics);
    if (pluginNames.length === 0) {
        container.innerHTML = '<div class="alert alert-info">Метрики не найдены</div>';
        return;
    }
    
    let html = '<div class="row">';
    pluginNames.forEach(pluginName => {
        const metric = metrics[pluginName];
        html += `<div class="col-md-6 mb-3">
            <div class="card">
                <div class="card-header">
                    <h6 class="mb-0">${escapeHtml(pluginName)}</h6>
                </div>
                <div class="card-body">
                    <dl class="row mb-0">
                        <dt class="col-sm-6">Выполнений:</dt>
                        <dd class="col-sm-6">${metric.execution_count || 0}</dd>
                        <dt class="col-sm-6">Среднее время:</dt>
                        <dd class="col-sm-6">${(metric.avg_execution_time * 1000).toFixed(2)} мс</dd>
                        <dt class="col-sm-6">Мин. время:</dt>
                        <dd class="col-sm-6">${(metric.min_execution_time * 1000).toFixed(2)} мс</dd>
                        <dt class="col-sm-6">Макс. время:</dt>
                        <dd class="col-sm-6">${(metric.max_execution_time * 1000).toFixed(2)} мс</dd>
                        <dt class="col-sm-6">Всего времени:</dt>
                        <dd class="col-sm-6">${(metric.total_execution_time * 1000).toFixed(2)} мс</dd>
                        <dt class="col-sm-6">Запросов:</dt>
                        <dd class="col-sm-6">${metric.request_count || 0}</dd>
                        <dt class="col-sm-6">Ошибок:</dt>
                        <dd class="col-sm-6"><span class="badge bg-${metric.error_count > 0 ? 'danger' : 'success'}">${metric.error_count || 0}</span></dd>
                        <dt class="col-sm-6">Процент ошибок:</dt>
                        <dd class="col-sm-6">${(metric.error_rate * 100).toFixed(2)}%</dd>
                    </dl>
                </div>
            </div>
        </div>`;
    });
    html += '</div>';
    
    container.innerHTML = html;
}

// Утилиты
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);
}
