// users.js - Управление пользователями
let users = [];
let allUsers = [];
let filteredUsers = [];
let selectedUsers = [];
let editSelectedUsers = [];
let copySelectedUsers = [];
// добавить переменную для отслеживания загрузки
let isUsersLoading = false;

// Добавьте переменную для хранения групп пользователей
let userGroupsCache = {};

async function loadUsers() {
    try {
        const response = await fetch('/api/users');
        const allUsersData = await response.json();
        //users = await response.json();
        // Сохраняем всех пользователей
        allUsers = allUsersData;
        // Фильтруем пользователей в зависимости от прав текущего пользователя
        users = filterAssignableUsers(allUsersData);
        filteredUsers = [...users];
        renderUsersChecklist();
        renderEditUsersChecklist();
        renderCopyUsersChecklist();
        populateFilterDropdowns();
    } catch (error) {
        console.error('Ошибка загрузки пользователей:', error);
    }
}

// Добавьте функцию для получения групп пользователя
async function getUserGroups(userId) {
    if (userGroupsCache[userId]) {
        return userGroupsCache[userId];
    }
    
    try {
        const response = await fetch(`/api2/idusers/user/${userId}/groups`);
        if (!response.ok) return [];
        
        const groups = await response.json();
        userGroupsCache[userId] = groups || [];
        return userGroupsCache[userId];
    } catch (error) {
        console.error('Ошибка получения групп пользователя:', error);
        return [];
    }
}

// Обновите функцию filterAssignableUsers
function filterAssignableUsers(allUsers, taskType = 'regular') {
    if (!currentUser) return [];
    
    // Для задач типа "document" - только пользователи из группы "Секретарь"
    if (taskType === 'document') {
        return allUsers.filter(async (user) => {
            if (user.id === currentUser.id) return false;
            
            // Получаем группы пользователя
            const groups = await getUserGroups(user.id);
            
            // Проверяем, есть ли группа "Секретарь"
            const hasSecretaryGroup = groups.some(group => 
                group.name === 'Секретарь' || 
                (typeof group === 'string' && group.includes('Секретарь'))
            );
            
            return hasSecretaryGroup;
        });
    }
    // Для задач типа "it" - только пользователи из группы "ИТ специалист"
    if (taskType === 'it') {
        return allUsers.filter(async (user) => {
            if (user.id === currentUser.id) return false;
            
            // Получаем группы пользователя
            const groups = await getUserGroups(user.id);
            
            // Проверяем, есть ли группа "Секретарь"
            const hasSecretaryGroup = groups.some(group => 
                group.name === 'ИТ специалист' || 
                (typeof group === 'string' && group.includes('ИТ специалист'))
            );
            
            return hasSecretaryGroup;
        });
    }
    
    // Для других типов задач - обычная фильтрация
    // Администратор видит всех пользователей
    if (currentUser.role === 'admin') {
        return allUsers.filter(user => user.id !== currentUser.id);
    }
    if (currentUser.role === 'secretary') {
        return allUsers.filter(user => user.id !== currentUser.id);
    }
    if (currentUser.role === 'ithelp') {
        return allUsers.filter(user => 
            (user.role === 'teacher' || user.role === 'tasks' || user.role === 'help' || user.role === 'request' || user.role === 'ithelp') &&
            user.id !== currentUser.id
        );
    }
    if (currentUser.role === 'request') {
        return allUsers.filter(user => 
            (user.role === 'teacher' || user.role === 'tasks' || user.role === 'help' || user.role === 'request' || user.role === 'ithelp') &&
            user.id !== currentUser.id
        );
    }
    // tasks видит учителей и других tasks
    if (currentUser.role === 'help') {
        return allUsers.filter(user => 
            (user.role === 'teacher' || user.role === 'tasks' || user.role === 'help' || user.role === 'request' || user.role === 'ithelp') &&
            user.id !== currentUser.id
        );
    }
    // tasks видит учителей и других tasks
    if (currentUser.role === 'tasks') {
        return allUsers.filter(user => 
            (user.role === 'teacher' || user.role === 'tasks' || user.role === 'help' || user.role === 'request' || user.role === 'ithelp') &&
            user.id !== currentUser.id
        );
    }
    // Учитель видит только учителей
    if (currentUser.role === 'teacher') {
        return allUsers.filter(user => 
            (user.role === 'help' || user.role === 'request' || user.role === 'ithelp') && 
            user.id !== currentUser.id
        );
    }
    
    return [];
}
function populateFilterDropdowns() {
    const creatorFilter = document.getElementById('creator-filter');
    const assigneeFilter = document.getElementById('assignee-filter');
    
    creatorFilter.innerHTML = '<option value="">Все заказчики</option>';
    assigneeFilter.innerHTML = '<option value="">Все исполнители</option>';
    
    users.forEach(user => {
        const creatorOption = document.createElement('option');
        creatorOption.value = user.id;
        creatorOption.textContent = `${user.name} (${user.login})`;
        creatorFilter.appendChild(creatorOption.cloneNode(true));
        
        const assigneeOption = creatorOption.cloneNode(true);
        assigneeFilter.appendChild(assigneeOption);
    });
}

// Обновите функцию filterUsers с учетом типа задачи
async function filterUsers() {
    const search = document.getElementById('user-search')?.value.toLowerCase() || '';
    const taskType = document.getElementById('task-type')?.value || 'regular';
    
    isUsersLoading = true;
    renderUsersChecklist(); // Показываем загрузку
    
    try {
        if (taskType === 'document' || taskType === 'it' || taskType === 'ahch' || 
            taskType === 'psychologist' || taskType === 'speech_therapist' || 
            taskType === 'hr' || taskType === 'certificate' || taskType === 'e_journal') {
            
            // Фильтруем по поиску
            let tempFiltered = users.filter(user => 
                user.name.toLowerCase().includes(search) ||
                user.login.toLowerCase().includes(search) ||
                user.email.toLowerCase().includes(search)
            );
            
            // Затем проверяем группы
            filteredUsers = [];
            const groupNames = {
                'document': 'Секретарь',
                'it': 'ИТ специалист',
                'ahch': 'АХЧ',
                'psychologist': 'психолог',
                'speech_therapist': 'логопед',
                'hr': 'Диспетчер',
                'certificate': 'Администрация',
                'e_journal': 'Админ ЭЖ'
            };
            
            const targetGroup = groupNames[taskType];
            
            for (const user of tempFiltered) {
                const groups = await getUserGroups(user.id);
                const hasTargetGroup = groups.some(group => 
                    group.name === targetGroup || 
                    (typeof group === 'string' && group.includes(targetGroup))
                );
                
                if (hasTargetGroup) {
                    filteredUsers.push(user);
                }
            }
        } else {
            // Обычная фильтрация
            filteredUsers = users.filter(user => 
                user.name.toLowerCase().includes(search) ||
                user.login.toLowerCase().includes(search) ||
                user.email.toLowerCase().includes(search)
            );
        }
    } catch (error) {
        console.error('Ошибка фильтрации пользователей:', error);
        filteredUsers = [];
    } finally {
        isUsersLoading = false;
        renderUsersChecklist();
    }
}

async function filterEditUsers() {
    const search = document.getElementById('edit-user-search').value.toLowerCase();
    const task = tasks.find(t => t.id === document.getElementById('edit-task-id').value);
    const taskType = task ? task.task_type : 'regular';
    
    let filtered = [];
    
    if (taskType === 'document') {
        // Для задач типа "document" - только секретари
        let tempFiltered = users.filter(user => 
            user.name.toLowerCase().includes(search) ||
            user.login.toLowerCase().includes(search) ||
            user.email.toLowerCase().includes(search)
        );
        
        filtered = [];
        for (const user of tempFiltered) {
            const groups = await getUserGroups(user.id);
            const hasSecretaryGroup = groups.some(group => 
                group.name === 'Секретарь' || 
                (typeof group === 'string' && group.includes('Секретарь'))
            );
            
            if (hasSecretaryGroup) {
                filtered.push(user);
            }
        }
    } else {
        filtered = users.filter(user => 
            user.name.toLowerCase().includes(search) ||
            user.login.toLowerCase().includes(search) ||
            user.email.toLowerCase().includes(search)
        );
    }
    
    renderEditUsersChecklist(filtered);
}

async function filterCopyUsers() {
    const search = document.getElementById('copy-user-search').value.toLowerCase();
    const taskId = document.getElementById('copy-task-id').value;
    const task = tasks.find(t => t.id === taskId);
    const taskType = task ? task.task_type : 'regular';
    
    let filtered = [];
    
    if (taskType === 'document') {
        // Для задач типа "document" - только секретари
        let tempFiltered = users.filter(user => 
            user.name.toLowerCase().includes(search) ||
            user.login.toLowerCase().includes(search) ||
            user.email.toLowerCase().includes(search)
        );
        
        filtered = [];
        for (const user of tempFiltered) {
            const groups = await getUserGroups(user.id);
            const hasSecretaryGroup = groups.some(group => 
                group.name === 'Секретарь' || 
                (typeof group === 'string' && group.includes('Секретарь'))
            );
            
            if (hasSecretaryGroup) {
                filtered.push(user);
            }
        }
    } else {
        filtered = users.filter(user => 
            user.name.toLowerCase().includes(search) ||
            user.login.toLowerCase().includes(search) ||
            user.email.toLowerCase().includes(search)
        );
    }
    
    renderCopyUsersChecklist(filtered);
}

function renderUsersChecklist() {
    const container = document.getElementById('users-checklist');
    
    if (isUsersLoading) {
        container.innerHTML = '<div class="loading-spinner">⏳ Загрузка пользователей...</div>';
        return;
    }
    
    if (!filteredUsers || filteredUsers.length === 0) {
        container.innerHTML = '<div class="no-users">Нет доступных пользователей</div>';
        return;
    }
    
    container.innerHTML = filteredUsers
        .filter(user => user.id !== currentUser?.id)
        .map(user => `
        <div class="checkbox-item">
            <label>
                <input type="checkbox" name="assignedUsers" value="${user.id}" 
                       onchange="toggleUserSelection(this, ${user.id})"
                       ${selectedUsers.includes(user.id) ? 'checked' : ''}>
                ${user.name} 
                ${getUserTypeLabel(user, document.getElementById('task-type')?.value)}
            </label>
        </div>
    `).join('');
}
// Вспомогательная функция для отображения типа пользователя
function getUserTypeLabel(user, taskType) {
    const labels = {
        'document': '(Секретарь)',
        'it': '(ИТ специалист)',
        'ahch': '(АХЧ)',
        'psychologist': '(Психолог)',
        'speech_therapist': '(Логопед)',
        'hr': '(Диспетчер)',
        'certificate': '(Администрация)',
        'e_journal': '(Админ ЭЖ)'
    };
    return labels[taskType] || '';
}
function renderEditUsersChecklist(filtered = users) {
    const container = document.getElementById('edit-users-checklist');
    container.innerHTML = filtered
        .filter(user => user.id !== currentUser.id)
        .map(user => `
        <div class="checkbox-item">
            <label>
                <input type="checkbox" name="assignedUsers" value="${user.id}" 
                       onchange="toggleEditUserSelection(this, ${user.id})">
                ${user.name} (${user.email})
                ${user.auth_type === 'ldap' ? '<small style="color: #666;"> - LDAP</small>' : ''}
            </label>
        </div>
    `).join('');
}

function renderCopyUsersChecklist(filtered = users) {
    const container = document.getElementById('copy-users-checklist');
    container.innerHTML = filtered
        .filter(user => user.id !== currentUser.id)
        .map(user => `
        <div class="checkbox-item">
            <label>
                <input type="checkbox" name="assignedUsers" value="${user.id}" 
                       onchange="toggleCopyUserSelection(this, ${user.id})">
                ${user.name} (${user.email})
                ${user.auth_type === 'ldap' ? '<small style="color: #666;"> - LDAP</small>' : ''}
            </label>
        </div>
    `).join('');
}

function toggleUserSelection(checkbox, userId) {
    if (checkbox.checked) {
        selectedUsers.push(userId);
    } else {
        selectedUsers = selectedUsers.filter(id => id !== userId);
    }
}

function toggleEditUserSelection(checkbox, userId) {
    if (checkbox.checked) {
        editSelectedUsers.push(userId);
    } else {
        editSelectedUsers = editSelectedUsers.filter(id => id !== userId);
    }
}

function toggleCopyUserSelection(checkbox, userId) {
    if (checkbox.checked) {
        copySelectedUsers.push(userId);
    } else {
        copySelectedUsers = copySelectedUsers.filter(id => id !== userId);
    }
}