// signature.js - Универсальный скрипт для подписания задач (только логика, без встройки в интерфейс)
(function() {
    'use strict';

    // Конфигурация
    const CONFIG = {
        signerGroup: 'Подписант',
        apiEndpoint: '/api2/idusers',
        usersEndpoint: '/api/users',
        replaceEndpoint: '/api/tasks/${taskId}/replace-assignee',
        replaceAllEndpoint: '/api/tasks/${taskId}/replace-all-assignees',
        taskTypeDocument: 'document'
    };

    // Текущий пользователь
    let currentUser = null;
    // Является ли текущий пользователь подписантом
    let isCurrentUserSigner = false;

    // Получение текущего пользователя
    async function getCurrentUser() {
        try {
            const response = await fetch('/api/user');
            const data = await response.json();
            if (data.user) {
                currentUser = data.user;
                await checkIfUserIsSigner();
            }
            return currentUser;
        } catch (error) {
            console.error('❌ Signature: ошибка получения пользователя', error);
            return null;
        }
    }

    // Проверка, является ли текущий пользователь подписантом
    async function checkIfUserIsSigner() {
        if (!currentUser) return false;
        try {
            const signers = await getSigners();
            isCurrentUserSigner = signers.some(signer => 
                signer.id === currentUser.id || 
                signer.login === currentUser.login ||
                signer.name === currentUser.name
            );
            return isCurrentUserSigner;
        } catch (error) {
            console.error('❌ Signature: ошибка проверки подписанта', error);
            return false;
        }
    }

    // Получение подписантов
    async function getSigners() {
        try {
            const response = await fetch(CONFIG.apiEndpoint);
            if (!response.ok) return await getSignersFallback();
            const data = await response.json();
            const signers = data.filter(user => 
                user.is_active && (
                    user.group_name?.toLowerCase().includes(CONFIG.signerGroup.toLowerCase()) ||
                    user.metadata?.groups?.some(g => g.toLowerCase().includes(CONFIG.signerGroup.toLowerCase())) ||
                    user.ldap_group?.toLowerCase().includes(CONFIG.signerGroup.toLowerCase())
                )
            );
            return signers.map(s => ({
                id: s.user_id,
                name: s.user_name || s.login || 'Неизвестно',
                login: s.user_login || s.login || ''
            }));
        } catch {
            return await getSignersFallback();
        }
    }

    // Запасной метод получения подписантов
    async function getSignersFallback() {
        try {
            const res = await fetch(CONFIG.usersEndpoint);
            if (!res.ok) return [];
            const users = await res.json();
            return users.filter(u => u.role === 'admin' || u.role === 'signer')
                .map(u => ({ id: u.id, name: u.name || u.login, login: u.login }));
        } catch {
            return [];
        }
    }

    // Основная функция подписания
    window.signTask = async function(taskId, userId) {
        const targetUserId = userId || currentUser?.id;
        if (!targetUserId) {
            alert('❌ Не удалось определить текущего пользователя');
            return false;
        }

        try {
            const signers = await getSigners();
            if (!signers.length) {
                alert('❌ Секретари не найдены в системе');
                return false;
            }

            const names = signers.map(s => `• ${s.name} (${s.login})`).join('\n');
            const msg = signers.length === 1 
                ? `✍️ Назначить подписанта?\n\n${names}`
                : `✍️ Назначить подписантов?\n\n${names}`;
            if (!confirm(msg)) return false;

            let response;
            if (signers.length > 1) {
                const url = CONFIG.replaceAllEndpoint.replace('${taskId}', taskId);
                response = await fetch(url, {
                    method: 'PUT',
                    headers: { 'Content-Type': 'application/json' },
                    body: JSON.stringify({ newAssigneeIds: signers.map(s => s.id) })
                });
            } else {
                const url = CONFIG.replaceEndpoint.replace('${taskId}', taskId);
                response = await fetch(url, {
                    method: 'PUT',
                    headers: { 'Content-Type': 'application/json' },
                    body: JSON.stringify({ 
                        oldAssigneeId: targetUserId, 
                        newAssigneeId: signers[0].id 
                    })
                });
            }

            if (response.ok) {
                alert(`✅ Задача ${signers.length > 1 ? 'назначена подписантам' : 'переназначена подписанту'}`);
                // Пробуем перезагрузить задачи
                if (window.TasksType && typeof window.TasksType.loadTasks === 'function') {
                    window.TasksType.loadTasks();
                } else if (window.loadTasks && typeof window.loadTasks === 'function') {
                    window.loadTasks();
                } else {
                    setTimeout(() => window.location.reload(), 1500);
                }
                return true;
            } else {
                const err = await response.json();
                alert('❌ Ошибка: ' + (err.error || 'Неизвестная ошибка'));
                return false;
            }
        } catch (error) {
            console.error('❌ Signature error:', error);
            alert('❌ Сетевая ошибка: ' + error.message);
            return false;
        }
    };

    // Обновление статуса задачи (может пригодиться)
    window.updateTaskStatus = async function(taskId, userId, status) {
        try {
            const response = await fetch(`/api/tasks/${taskId}/status`, {
                method: 'PUT',
                headers: { 'Content-Type': 'application/json' },
                body: JSON.stringify({ userId, status })
            });
            if (response.ok) {
                if (window.TasksType && typeof window.TasksType.loadTasks === 'function') {
                    window.TasksType.loadTasks();
                } else if (window.loadTasks && typeof window.loadTasks === 'function') {
                    window.loadTasks();
                }
                return true;
            } else {
                const err = await response.json();
                alert('❌ Ошибка: ' + (err.error || 'Неизвестная ошибка'));
                return false;
            }
        } catch (error) {
            console.error('❌ Status update error:', error);
            alert('❌ Сетевая ошибка');
            return false;
        }
    };

    // Инициализация: получаем данные текущего пользователя (без добавления кнопок)
    async function init() {
        await getCurrentUser();
        console.log('✅ Signature module loaded (UI integration removed)');
    }

    // Запускаем инициализацию после загрузки DOM
    if (document.readyState === 'loading') {
        document.addEventListener('DOMContentLoaded', init);
    } else {
        init();
    }

})();