// task-endpoints.js
const path = require('path');
const fs = require('fs');
// Функция для добавления кнопки чата в HTML задачи
function addChatButtonToTask(taskElement, taskId) {
    const chatButton = document.createElement('button');
    chatButton.className = 'task-chat-btn';
    chatButton.innerHTML = '💬 Чат';
    chatButton.onclick = (e) => {
        e.stopPropagation();
        openTaskChat(taskId);
    };
    
    // Добавляем кнопку в шапку задачи или в actions
    const header = taskElement.querySelector('.task-header');
    if (header) {
        header.appendChild(chatButton);
    }
}
function getApproverUsers(groupId) {
    return new Promise((resolve) => {
        db.all(`
            SELECT u.id, u.login, u.name, u.email
            FROM users u
            JOIN user_group_memberships ugm ON u.id = ugm.user_id
            WHERE ugm.group_id = ?
        `, [groupId], (err, users) => {
            resolve(err ? [] : users);
        });
    });
}

function setupTaskEndpoints(app, db, upload) {
    const { logActivity, createUserTaskFolder, saveTaskMetadata, updateTaskMetadata, checkTaskAccess } = require('./database');
    const { sendTaskNotifications } = require('./notifications');
    
    function checkIfOverdue(dueDate, status) {
        if (!dueDate || status === 'completed') return false;
        const now = new Date();
        const due = new Date(dueDate);
        return due < now;
    }

    // Функция проверки прав редактирования
    function canUserEditTask(task, user) {
        if (!user) return false;
        
        // Администратор может всё
        if (user.role === 'admin') return true;
    // Пользователи с ролью 'tasks' могут редактировать любые задачи
    if (user.role === 'tasks') return true;

        // Создатель может редактировать свою задачу только если она не назначена другим
        if (parseInt(task.created_by) === user.id) {
            if (task.assignments && task.assignments.length > 0) {
                // Проверяем, назначена ли задача другим пользователям
                const assignedToOthers = task.assignments.some(assignment => 
                    parseInt(assignment.user_id) !== user.id
                );
                
                if (assignedToOthers) {
                    // Создатель не может редактировать задачу, назначенную другим
                    return false;
                }
            }
            return true;
        }
            // Исполнитель может загружать файлы в свою задачу
    // Проверяем, назначен ли пользователь на эту задачу
    if (task.assignments && task.assignments.length > 0) {
        const isAssigned = task.assignments.some(assignment => 
            parseInt(assignment.user_id) === user.id
        );
        if (isAssigned) {
            return true; // Исполнитель может загружать файлы
        }
    }
        return false;
    }

    // Middleware для аутентификации
    function requireAuth(req, res, next) {
        if (!req.session.user) {
            return res.status(401).json({ error: 'Требуется аутентификация' });
        }
        next();
    }

    // API для задач
app.get('/api/tasks', requireAuth, (req, res) => {
    const userId = req.session.user.id;
    const showDeleted = req.session.user.role === 'admin' && req.query.showDeleted === 'true';
    const search = req.query.search || '';
    const statusFilter = req.query.status || 'active,in_progress,assigned,overdue,rework';
    const creatorFilter = req.query.creator || '';
    const assigneeFilter = req.query.assignee || '';
    const deadlineFilter = req.query.deadline || '';
    const taskType = req.query.task_type || ''; // Новый параметр для фильтрации по типу задачи

    let query = `
        SELECT DISTINCT
            t.*,
            u.name as creator_name,
            u.login as creator_login,
            ot.title as original_task_title,
            ou.name as original_creator_name,
            GROUP_CONCAT(DISTINCT ta.user_id) as assigned_user_ids,
            GROUP_CONCAT(DISTINCT u2.name) as assigned_user_names
        FROM tasks t
        LEFT JOIN users u ON t.created_by = u.id
        LEFT JOIN tasks ot ON t.original_task_id = ot.id
        LEFT JOIN users ou ON ot.created_by = ou.id
        LEFT JOIN task_assignments ta ON t.id = ta.task_id
        LEFT JOIN users u2 ON ta.user_id = u2.id
        WHERE 1=1
    `;

    const params = [];

    // ===== ДОБАВЛЯЕМ ФИЛЬТР ПО ТИПУ ЗАДАЧИ =====
    if (taskType) {
        query += ` AND t.task_type = ?`;
        params.push(taskType);
    }

    if (req.session.user.role !== 'admin') {
        query += ` AND (t.created_by = ? OR ta.user_id = ?)`;
        params.push(userId, userId);
    }

    if (!showDeleted) {
        query += " AND t.status = 'active'";
    }

    if (statusFilter && statusFilter !== 'all') {
        const statuses = statusFilter.split(',');
        
        if (statuses.includes('closed')) {
            if (req.session.user.role !== 'admin') {
                query += ` AND (t.closed_at IS NOT NULL AND t.created_by = ?)`;
                params.push(userId);
            } else {
                query += ` AND t.closed_at IS NOT NULL`;
            }
        } else {
            query += ` AND t.closed_at IS NULL`;
            
            if (statuses.length > 0 && !statuses.includes('all')) {
                query += ` AND EXISTS (
                    SELECT 1 FROM task_assignments ta2 
                    WHERE ta2.task_id = t.id AND ta2.status IN (${statuses.map(() => '?').join(',')})
                )`;
                statuses.forEach(status => params.push(status));
            }
        }
    } else {
        if (req.session.user.role !== 'admin') {
            query += ` AND (t.closed_at IS NULL OR t.created_by = ?)`;
            params.push(userId);
        }
    }

    if (creatorFilter) {
        query += ` AND t.created_by = ?`;
        params.push(creatorFilter);
    }

    if (assigneeFilter) {
        query += ` AND ta.user_id = ?`;
        params.push(assigneeFilter);
    }

    if (deadlineFilter) {
        const now = new Date();
        let hours = 48;
        if (deadlineFilter === '24h') hours = 24;
        
        const deadlineTime = new Date(now.getTime() + hours * 60 * 60 * 1000);
        const deadlineISO = deadlineTime.toISOString();
        const nowISO = now.toISOString();
        
        query += ` AND ta.due_date IS NOT NULL 
                   AND ta.due_date > ? 
                   AND ta.due_date <= ?
                   AND ta.status NOT IN ('completed', 'overdue')`;
        params.push(nowISO, deadlineISO);
    }

    if (search) {
        query += ` AND (t.title LIKE ? OR t.description LIKE ?)`;
        const searchPattern = `%${search}%`;
        params.push(searchPattern, searchPattern);
    }

    query += " GROUP BY t.id ORDER BY t.created_at DESC";

    console.log('SQL Query:', query);
    console.log('Params:', params);

    db.all(query, params, (err, tasks) => {
        if (err) {
            res.status(500).json({ error: err.message });
            return;
        }

        const taskPromises = tasks.map(task => {
            return new Promise((resolve) => {
                db.all(`
                    SELECT ta.*, u.name as user_name, u.login as user_login
                    FROM task_assignments ta 
                    LEFT JOIN users u ON ta.user_id = u.id 
                    WHERE ta.task_id = ?
                `, [task.id], (err, assignments) => {
                    if (err) {
                        task.assignments = [];
                        resolve(task);
                        return;
                    }

                    assignments.forEach(assignment => {
                        if (checkIfOverdue(assignment.due_date, assignment.status) && assignment.status !== 'completed') {
                            assignment.status = 'overdue';
                        }
                    });

                    task.assignments = assignments || [];
                    resolve(task);
                });
            });
        });

        Promise.all(taskPromises).then(completedTasks => {
            res.json(completedTasks);
        });
    });
});
    // API для задач по типу
app.get('/api/tasks_by_type', requireAuth, (req, res) => {
    const userId = req.session.user.id;
    const userRole = req.session.user.role;
    
    // Получаем параметры фильтрации из query string
    const showDeleted = userRole === 'admin' && req.query.showDeleted === 'true';
    const search = req.query.search || '';
    const statusFilter = req.query.status || 'active,in_progress,assigned,overdue,rework';
    const creatorFilter = req.query.creator || '';
    const assigneeFilter = req.query.assignee || '';
    const deadlineFilter = req.query.deadline || '';
    const taskType = req.query.task_type || ''; // Новый параметр для фильтрации по типу задачи

    let query = `
        SELECT DISTINCT
            t.*,
            u.name as creator_name,
            u.login as creator_login,
            ot.title as original_task_title,
            ou.name as original_creator_name,
            GROUP_CONCAT(DISTINCT ta.user_id) as assigned_user_ids,
            GROUP_CONCAT(DISTINCT u2.name) as assigned_user_names
        FROM tasks t
        LEFT JOIN users u ON t.created_by = u.id
        LEFT JOIN tasks ot ON t.original_task_id = ot.id
        LEFT JOIN users ou ON ot.created_by = ou.id
        LEFT JOIN task_assignments ta ON t.id = ta.task_id
        LEFT JOIN users u2 ON ta.user_id = u2.id
        WHERE 1=1
    `;

    const params = [];

    // Фильтрация по типу задачи
    if (taskType) {
        if (taskType.includes(',')) {
            // Если перечислено несколько типов через запятую
            const types = taskType.split(',');
            query += ` AND t.task_type IN (${types.map(() => '?').join(',')})`;
            types.forEach(type => params.push(type));
        } else {
            // Один конкретный тип
            query += ` AND t.task_type = ?`;
            params.push(taskType);
        }
    }

    // Фильтрация по правам доступа
    if (userRole !== 'admin') {
        query += ` AND (t.created_by = ? OR ta.user_id = ?)`;
        params.push(userId, userId);
    }

    // Фильтрация по удаленным задачам
    if (!showDeleted) {
        query += " AND t.status = 'active'";
    }

    // Фильтрация по статусу
    if (statusFilter && statusFilter !== 'all') {
        const statuses = statusFilter.split(',');
        
        if (statuses.includes('closed')) {
            if (userRole !== 'admin') {
                query += ` AND (t.closed_at IS NOT NULL AND t.created_by = ?)`;
                params.push(userId);
            } else {
                query += ` AND t.closed_at IS NOT NULL`;
            }
        } else {
            query += ` AND t.closed_at IS NULL`;
            
            if (statuses.length > 0 && !statuses.includes('all')) {
                query += ` AND EXISTS (
                    SELECT 1 FROM task_assignments ta2 
                    WHERE ta2.task_id = t.id AND ta2.status IN (${statuses.map(() => '?').join(',')})
                )`;
                statuses.forEach(status => params.push(status));
            }
        }
    } else {
        if (userRole !== 'admin') {
            query += ` AND (t.closed_at IS NULL OR t.created_by = ?)`;
            params.push(userId);
        }
    }

    // Фильтрация по создателю
    if (creatorFilter) {
        query += ` AND t.created_by = ?`;
        params.push(creatorFilter);
    }

    // Фильтрация по исполнителю
    if (assigneeFilter) {
        query += ` AND ta.user_id = ?`;
        params.push(assigneeFilter);
    }

    // Фильтрация по дедлайну
    if (deadlineFilter) {
        const now = new Date();
        let hours = 48;
        if (deadlineFilter === '24h') hours = 24;
        
        const deadlineTime = new Date(now.getTime() + hours * 60 * 60 * 1000);
        const deadlineISO = deadlineTime.toISOString();
        const nowISO = now.toISOString();
        
        query += ` AND ta.due_date IS NOT NULL 
                   AND ta.due_date > ? 
                   AND ta.due_date <= ?
                   AND ta.status NOT IN ('completed', 'overdue')`;
        params.push(nowISO, deadlineISO);
    }

    // Поиск по тексту
    if (search) {
        query += ` AND (t.title LIKE ? OR t.description LIKE ?)`;
        const searchPattern = `%${search}%`;
        params.push(searchPattern, searchPattern);
    }

    query += " GROUP BY t.id ORDER BY t.created_at DESC";

    db.all(query, params, (err, tasks) => {
        if (err) {
            res.status(500).json({ error: err.message });
            return;
        }

        const taskPromises = tasks.map(task => {
            return new Promise((resolve) => {
                db.all(`
                    SELECT ta.*, u.name as user_name, u.login as user_login
                    FROM task_assignments ta 
                    LEFT JOIN users u ON ta.user_id = u.id 
                    WHERE ta.task_id = ?
                `, [task.id], (err, assignments) => {
                    if (err) {
                        task.assignments = [];
                        resolve(task);
                        return;
                    }

                    assignments.forEach(assignment => {
                        if (checkIfOverdue(assignment.due_date, assignment.status) && assignment.status !== 'completed') {
                            assignment.status = 'overdue';
                        }
                    });

                    task.assignments = assignments || [];
                    resolve(task);
                });
            });
        });

        Promise.all(taskPromises).then(completedTasks => {
            // Добавляем мета-информацию о фильтрации
            const response = {
                tasks: completedTasks,
                meta: {
                    total: completedTasks.length,
                    filters: {
                        task_type: taskType || 'all',
                        status: statusFilter,
                        creator: creatorFilter || 'all',
                        assignee: assigneeFilter || 'all',
                        deadline: deadlineFilter || 'none',
                        search: search || 'none'
                    }
                }
            };
            
            res.json(response);
        });
    });
});
    app.get('/api/tasks/no-date', requireAuth, (req, res) => {
        const userId = req.session.user.id;
        
        const query = `
            SELECT DISTINCT
                t.*,
                u.name as creator_name,
                u.login as creator_login,
                ot.title as original_task_title,
                ou.name as original_creator_name,
                GROUP_CONCAT(DISTINCT ta.user_id) as assigned_user_ids,
                GROUP_CONCAT(DISTINCT u2.name) as assigned_user_names
            FROM tasks t
            LEFT JOIN users u ON t.created_by = u.id
            LEFT JOIN tasks ot ON t.original_task_id = ot.id
            LEFT JOIN users ou ON ot.created_by = ou.id
            LEFT JOIN task_assignments ta ON t.id = ta.task_id
            LEFT JOIN users u2 ON ta.user_id = u2.id
            WHERE t.status = 'active'
            AND t.closed_at IS NULL
            AND (t.due_date IS NULL OR t.due_date = '')
            AND (ta.due_date IS NULL OR ta.due_date = '')
        `;

        const params = [];
        
        if (req.session.user.role !== 'admin') {
            query += ` AND (t.created_by = ? OR ta.user_id = ?)`;
            params.push(userId, userId);
        }
        
        query += " GROUP BY t.id ORDER BY t.created_at DESC";

        db.all(query, params, (err, tasks) => {
            if (err) {
                res.status(500).json({ error: err.message });
                return;
            }

            const taskPromises = tasks.map(task => {
                return new Promise((resolve) => {
                    db.all(`
                        SELECT ta.*, u.name as user_name, u.login as user_login
                        FROM task_assignments ta 
                        LEFT JOIN users u ON ta.user_id = u.id 
                        WHERE ta.task_id = ?
                    `, [task.id], (err, assignments) => {
                        if (err) {
                            task.assignments = [];
                            resolve(task);
                            return;
                        }

                        task.assignments = assignments || [];
                        resolve(task);
                    });
                });
            });

            Promise.all(taskPromises).then(completedTasks => {
                res.json(completedTasks);
            });
        });
    });

    // API для Канбан-доски с фильтром
    app.get('/api/kanban-tasks', requireAuth, (req, res) => {
        const userId = req.session.user.id;
        const days = parseInt(req.query.days) || 7;
        const filter = req.query.filter || 'all'; // 'all', 'created', 'assigned'
        
        const now = new Date();
        const futureDate = new Date(now.getTime() + days * 24 * 60 * 60 * 1000);
        const futureISO = futureDate.toISOString();
        
        let query = `
            SELECT DISTINCT
                t.*,
                u.name as creator_name,
                u.login as creator_login,
                GROUP_CONCAT(DISTINCT ta.user_id) as assigned_user_ids,
                GROUP_CONCAT(DISTINCT u2.name) as assigned_user_names
            FROM tasks t
            LEFT JOIN users u ON t.created_by = u.id
            LEFT JOIN task_assignments ta ON t.id = ta.task_id
            LEFT JOIN users u2 ON ta.user_id = u2.id
            WHERE t.status = 'active'
            AND t.closed_at IS NULL
            AND (t.due_date IS NULL OR t.due_date <= ?)
        `;
        
        const params = [futureISO];
        
        // Применяем фильтр
        if (filter === 'created') {
            // Задачи, которые я создал
            query += ` AND t.created_by = ?`;
            params.push(userId);
        } else if (filter === 'assigned') {
            // Задачи, которые мне назначены
            query += ` AND ta.user_id = ?`;
            params.push(userId);
        } else {
            // Все задачи (по умолчанию)
            query += ` AND (t.created_by = ? OR ta.user_id = ?)`;
            params.push(userId, userId);
        }
        
        query += " GROUP BY t.id ORDER BY t.due_date ASC, t.created_at DESC";
        
        db.all(query, params, async (err, tasks) => {
            if (err) {
                res.status(500).json({ error: err.message });
                return;
            }
            
            // Добавляем статус для Канбана и загружаем файлы
            const tasksWithKanban = await Promise.all(tasks.map(async (task) => {
                // Получаем назначения для задачи
                const assignments = await new Promise((resolve) => {
                    db.all(`
                        SELECT ta.*, u.name as user_name, u.login as user_login
                        FROM task_assignments ta 
                        LEFT JOIN users u ON ta.user_id = u.id 
                        WHERE ta.task_id = ?
                    `, [task.id], (err, rows) => {
                        resolve(rows || []);
                    });
                });
                
                // Определяем статус для Канбана
                let kanbanStatus = 'unassigned';
                
                if (assignments.length === 0) {
                    kanbanStatus = 'unassigned';
                } else {
                    const hasAssigned = assignments.some(a => a.status === 'assigned');
                    const hasInProgress = assignments.some(a => a.status === 'in_progress');
                    const hasOverdue = assignments.some(a => a.status === 'overdue');
                    const hasRework = assignments.some(a => a.status === 'rework');
                    const allCompleted = assignments.every(a => a.status === 'completed');
                    
                    if (allCompleted) {
                        kanbanStatus = 'completed';
                    } else if (hasRework) {
                        kanbanStatus = 'rework';
                    } else if (hasOverdue) {
                        kanbanStatus = 'overdue';
                    } else if (hasInProgress) {
                        kanbanStatus = 'in_progress';
                    } else if (hasAssigned) {
                        kanbanStatus = 'assigned';
                    }
                }
                
                // Загружаем файлы
                const files = await new Promise((resolve) => {
                    db.all(`
                        SELECT tf.*, u.name as user_name
                        FROM task_files tf 
                        LEFT JOIN users u ON tf.user_id = u.id 
                        WHERE tf.task_id = ?
                        ORDER BY tf.uploaded_at DESC
                    `, [task.id], (err, rows) => {
                        resolve(rows || []);
                    });
                });
                
                // Определяем роль пользователя в задаче
                let userRole = 'observer';
                if (parseInt(task.created_by) === userId) {
                    userRole = 'creator';
                } else if (assignments.some(a => parseInt(a.user_id) === userId)) {
                    userRole = 'assignee';
                }
                
                return {
                    ...task,
                    kanbanStatus,
                    assignments,
                    files,
                    userRole,
                    canEdit: canUserEditTask(task, req.session.user)
                };
            }));
            
            res.json({ 
                tasks: tasksWithKanban,
                filter: filter,
                userRole: req.session.user.role
            });
        });
    });

    // API для статистики Канбана
    app.get('/api/kanban-stats', requireAuth, (req, res) => {
        const userId = req.session.user.id;
        const filter = req.query.filter || 'all';
        
        const now = new Date();
        const futureDate = new Date(now.getTime() + 7 * 24 * 60 * 60 * 1000);
        const futureISO = futureDate.toISOString();
        
        let query = `
            SELECT 
                COUNT(DISTINCT t.id) as total_tasks,
                COUNT(DISTINCT CASE WHEN ta.status = 'assigned' THEN t.id END) as assigned_count,
                COUNT(DISTINCT CASE WHEN ta.status = 'in_progress' THEN t.id END) as in_progress_count,
                COUNT(DISTINCT CASE WHEN ta.status = 'rework' THEN t.id END) as rework_count,
                COUNT(DISTINCT CASE WHEN ta.status = 'overdue' THEN t.id END) as overdue_count,
                COUNT(DISTINCT CASE WHEN ta.status = 'completed' THEN t.id END) as completed_count,
                COUNT(DISTINCT CASE WHEN ta.user_id IS NULL THEN t.id END) as unassigned_count,
                COUNT(DISTINCT CASE WHEN t.created_by = ? THEN t.id END) as created_by_me,
                COUNT(DISTINCT CASE WHEN ta.user_id = ? THEN t.id END) as assigned_to_me
            FROM tasks t
            LEFT JOIN task_assignments ta ON t.id = ta.task_id AND ta.user_id = ?
            WHERE t.status = 'active'
            AND t.closed_at IS NULL
            AND (t.due_date IS NULL OR t.due_date <= ?)
        `;
        
        const params = [userId, userId, userId, futureISO];
        
        // Применяем фильтр
        if (filter === 'created') {
            query += ` AND t.created_by = ?`;
            params.push(userId);
        } else if (filter === 'assigned') {
            query += ` AND ta.user_id = ?`;
            params.push(userId);
        } else {
            query += ` AND (t.created_by = ? OR ta.user_id = ?)`;
            params.push(userId, userId);
        }
        
        db.get(query, params, (err, stats) => {
            if (err) {
                res.status(500).json({ error: err.message });
                return;
            }
            
            res.json({
                stats: stats || {
                    total_tasks: 0,
                    assigned_count: 0,
                    in_progress_count: 0,
                    rework_count: 0,
                    overdue_count: 0,
                    completed_count: 0,
                    unassigned_count: 0,
                    created_by_me: 0,
                    assigned_to_me: 0
                },
                filter: filter,
                timestamp: new Date().toISOString()
            });
        });
    });
// API для создания задачи согласования документов
app.post('/api/document-approval-tasks', requireAuth, upload.array('files', 15), (req, res) => {
    const { title, description, approverGroupId, documentId, dueDate } = req.body;
    const createdBy = req.session.user.id;

    if (!title) {
        return res.status(400).json({ error: 'Название задачи обязательно' });
    }

    if (!approverGroupId) {
        return res.status(400).json({ error: 'Выберите группу для согласования' });
    }

    if (!dueDate) {
        return res.status(400).json({ error: 'Дата и время выполнения обязательны' });
    }

    // Проверяем, может ли группа согласовывать документы
    db.get("SELECT can_approve_documents FROM user_groups WHERE id = ?", 
        [approverGroupId], (err, group) => {
        if (err || !group || !group.can_approve_documents) {
            return res.status(400).json({ error: 'Выбранная группа не может согласовывать документы' });
        }

        db.serialize(async () => {
            const startDate = new Date().toISOString();
            
            // Создаем задачу с типом "document_approval"
            db.run(
                `INSERT INTO tasks (title, description, created_by, task_type, 
                 approver_group_id, document_id, start_date, due_date) 
                 VALUES (?, ?, ?, 'document_approval', ?, ?, ?, ?)`,
                [title, description, createdBy, approverGroupId, documentId || null, startDate, dueDate || null],
                async function(err) {
                    if (err) {
                        res.status(500).json({ error: err.message });
                        return;
                    }

                    const taskId = this.lastID;
                    
                    // Сохраняем метаданные
                    saveTaskMetadata(taskId, title, description, createdBy, null, startDate, dueDate);
                    
                    // Получаем всех пользователей из группы согласующих
                    const approvers = await getApproverUsers(approverGroupId);
                    
                    // Назначаем задачу всем согласующим в группе
                    if (approvers.length > 0) {
                        approvers.forEach(approver => {
                            db.run(
                                "INSERT INTO task_assignments (task_id, user_id, status, start_date, due_date) VALUES (?, ?, 'assigned', ?, ?)",
                                [taskId, approver.id, startDate, dueDate || null]
                            );
                        });
                        
                        // Отправляем уведомления
                        sendTaskNotifications('created', taskId, title, description, createdBy);
                    }
                    
                    logActivity(taskId, createdBy, 'DOCUMENT_APPROVAL_TASK_CREATED', 
                        `Создана задача согласования документа для группы ${approverGroupId}`);

                    // Загрузка файлов (если есть)
                    if (req.files && req.files.length > 0) {
                        const userFolder = createUserTaskFolder(taskId, req.session.user.login);
                        
                        req.files.forEach(file => {
                            const newPath = path.join(userFolder, path.basename(file.filename));
                            fs.renameSync(file.path, newPath);

                            const originalName = file.originalname;

                            db.run(
                                "INSERT INTO task_files (task_id, user_id, filename, original_name, file_path, file_size) VALUES (?, ?, ?, ?, ?, ?)",
                                [taskId, createdBy, path.basename(file.filename), originalName, newPath, file.size]
                            );

                            logActivity(taskId, createdBy, 'FILE_UPLOADED', `Загружен файл: ${originalName}`);
                        });
                    }

                    res.json({ 
                        success: true, 
                        taskId: taskId,
                        message: 'Задача согласования документа создана',
                        approversCount: approvers.length
                    });
                }
            );
        });
    });
});

// API для получения задач согласования документов
app.get('/api/document-approval-tasks', requireAuth, (req, res) => {
    const userId = req.session.user.id;
    
    const query = `
        SELECT DISTINCT
            t.*,
            u.name as creator_name,
            u.login as creator_login,
            g.name as approver_group_name,
            g.color as approver_group_color,
            GROUP_CONCAT(DISTINCT ta.user_id) as assigned_user_ids,
            GROUP_CONCAT(DISTINCT u2.name) as assigned_user_names
        FROM tasks t
        LEFT JOIN users u ON t.created_by = u.id
        LEFT JOIN user_groups g ON t.approver_group_id = g.id
        LEFT JOIN task_assignments ta ON t.id = ta.task_id
        LEFT JOIN users u2 ON ta.user_id = u2.id
        WHERE t.task_type = 'document_approval'
        AND t.status = 'active'
        AND t.closed_at IS NULL
    `;
    
    const params = [];
    
    if (req.session.user.role !== 'admin') {
        query += ` AND (t.created_by = ? OR ta.user_id = ?)`;
        params.push(userId, userId);
    }
    
    query += " GROUP BY t.id ORDER BY t.created_at DESC";
    
    db.all(query, params, (err, tasks) => {
        if (err) {
            res.status(500).json({ error: err.message });
            return;
        }
        
        const taskPromises = tasks.map(task => {
            return new Promise((resolve) => {
                // Получаем назначения
                db.all(`
                    SELECT ta.*, u.name as user_name, u.login as user_login
                    FROM task_assignments ta 
                    LEFT JOIN users u ON ta.user_id = u.id 
                    WHERE ta.task_id = ?
                `, [task.id], (err, assignments) => {
                    if (err) {
                        task.assignments = [];
                    } else {
                        assignments.forEach(assignment => {
                            if (checkIfOverdue(assignment.due_date, assignment.status) && assignment.status !== 'completed') {
                                assignment.status = 'overdue';
                            }
                        });
                        task.assignments = assignments || [];
                    }
                    
                    // Получаем информацию о группе согласующих
                    if (task.approver_group_id) {
                        db.get(`
                            SELECT name, color, can_approve_documents 
                            FROM user_groups 
                            WHERE id = ?
                        `, [task.approver_group_id], (err, group) => {
                            task.approver_group = group || null;
                            resolve(task);
                        });
                    } else {
                        resolve(task);
                    }
                });
            });
        });
        
        Promise.all(taskPromises).then(completedTasks => {
            res.json(completedTasks);
        });
    });
});
    // API для обновления статуса в Канбане
    app.put('/api/kanban-tasks/:taskId/status', requireAuth, (req, res) => {
        const { taskId } = req.params;
        const { status } = req.body;
        const currentUserId = req.session.user.id;
        
        if (!status) {
            return res.status(400).json({ error: 'Статус обязателен' });
        }
        
        // Проверяем, что пользователь назначен на задачу
        db.get("SELECT 1 FROM task_assignments WHERE task_id = ? AND user_id = ?", 
            [taskId, currentUserId], (err, assignment) => {
            if (err || !assignment) {
                return res.status(403).json({ error: 'Вы не назначены на эту задачу' });
            }
            
            // Определяем реальный статус из канбан-статуса
            let actualStatus = status;
            if (status === 'unassigned') {
                actualStatus = 'assigned'; // Нельзя вернуть в не назначенные
            }
            
            db.run(
                "UPDATE task_assignments SET status = ?, updated_at = CURRENT_TIMESTAMP WHERE task_id = ? AND user_id = ?",
                [actualStatus, taskId, currentUserId],
                function(err) {
                    if (err) {
                        res.status(500).json({ error: err.message });
                        return;
                    }
                    
                    if (this.changes === 0) {
                        return res.status(404).json({ error: 'Назначение не найдено' });
                    }
                    
                    logActivity(taskId, currentUserId, 'STATUS_CHANGED', `Статус изменен на: ${actualStatus} через Канбан`);
                    
                    // Отправляем уведомление
                    db.get("SELECT title, description FROM tasks WHERE id = ?", [taskId], (err, taskData) => {
                        if (!err && taskData) {
                            sendTaskNotifications(
                                'status_changed', 
                                taskId, 
                                taskData.title, 
                                taskData.description, 
                                currentUserId,
                                '',
                                actualStatus,
                                req.session.user.name
                            );
                        }
                    });
                    
                    res.json({ success: true, message: 'Статус обновлен' });
                }
            );
        });
    });

    app.post('/api/tasks', requireAuth, upload.array('files', 15), (req, res) => {
        const { title, description, assignedUsers, originalTaskId, dueDate } = req.body;
        const createdBy = req.session.user.id;
        
    // ПРОВЕРКА ЧТО ПРИХОДИТ В ЗАПРОСЕ
    console.log('📋 ДАННЫЕ ИЗ ЗАПРОСА:');
    console.log('req.body:', JSON.stringify(req.body, null, 2));
    console.log('req.body.taskType:', req.body.taskType);
    console.log('Все поля req.body:', Object.keys(req.body));
    
    // Проверяем заголовки запроса
    console.log('Content-Type заголовок:', req.headers['content-type']);

        if (!title) {
            return res.status(400).json({ error: 'Название задачи обязательно' });
        }

        if (!dueDate) {
            return res.status(400).json({ error: 'Дата и время выполнения обязательны' });
        }

        db.serialize(() => {
            const startDate = new Date().toISOString();
            const taskType = req.body.taskType || 'regular';

            db.run(
    "INSERT INTO tasks (title, description, created_by, original_task_id, start_date, due_date, task_type) VALUES (?, ?, ?, ?, ?, ?, ?)",
    [title, description, createdBy, originalTaskId || null, startDate, dueDate || null, taskType],
    function(err) {
                    if (err) {
                        res.status(500).json({ error: err.message });
                        return;
                    }

                    const taskId = this.lastID;
                    
                    saveTaskMetadata(taskId, title, description, createdBy, originalTaskId, startDate, dueDate);

                    const action = originalTaskId ? 'TASK_COPIED' : 'TASK_CREATED';
                    const details = originalTaskId ? 
                        `Создана копия задачи: ${title}` : 
                        `Создана задача: ${title}`;

                    logActivity(taskId, createdBy, action, details);

                    if (req.files && req.files.length > 0) {
                        const userFolder = createUserTaskFolder(taskId, req.session.user.login);
                        
                        req.files.forEach(file => {
                            const newPath = path.join(userFolder, path.basename(file.filename));
                            fs.renameSync(file.path, newPath);

                            const originalName = file.originalname;

                            db.run(
                                "INSERT INTO task_files (task_id, user_id, filename, original_name, file_path, file_size) VALUES (?, ?, ?, ?, ?, ?)",
                                [taskId, createdBy, path.basename(file.filename), originalName, newPath, file.size]
                            );

                            logActivity(taskId, createdBy, 'FILE_UPLOADED', `Загружен файл: ${originalName}`);
                        });

                        const tempDir = path.join(__dirname, 'data', 'uploads', 'temp');
                        if (fs.existsSync(tempDir)) {
                            fs.rmSync(tempDir, { recursive: true, force: true });
                        }
                    }

                    if (assignedUsers) {
                        const userIds = Array.isArray(assignedUsers) ? assignedUsers : [assignedUsers];
                        
                        userIds.forEach(userId => {
                            db.run(
                                "INSERT INTO task_assignments (task_id, user_id, start_date, due_date) VALUES (?, ?, ?, ?)",
                                [taskId, userId, startDate, dueDate || null]
                            );

                            logActivity(taskId, createdBy, 'TASK_ASSIGNED', `Задача назначена пользователю ${userId}`);
                        });

                        sendTaskNotifications('created', taskId, title, description, createdBy);
                    }

                    res.json({ 
                        success: true, 
                        taskId: taskId,
                        message: originalTaskId ? 'Копия задачи создана' : 'Задача успешно создана'
                    });
                }
            );
        });
    });

    app.post('/api/tasks/:taskId/copy', requireAuth, (req, res) => {
        const { taskId } = req.params;
        const { assignedUsers, dueDate } = req.body;
        const createdBy = req.session.user.id;

        if (!dueDate) {
            return res.status(400).json({ error: 'Дата и время выполнения обязательны для копии задачи' });
        }
        
        checkTaskAccess(createdBy, taskId, (err, hasAccess) => {
            if (err || !hasAccess) {
                return res.status(404).json({ error: 'Задача не найдена или у вас нет прав доступа' });
            }

            db.serialize(() => {
                db.get("SELECT title, description FROM tasks WHERE id = ?", [taskId], (err, originalTask) => {
                    if (err || !originalTask) {
                        return res.status(404).json({ error: 'Оригинальная задача не найдена' });
                    }

                    const newTitle = `Копия: ${originalTask.title}`;
                    const startDate = new Date().toISOString();
                    
                    db.run(
    "INSERT INTO tasks (title, description, created_by, original_task_id, start_date, due_date, task_type) VALUES (?, ?, ?, ?, ?, ?, ?)",
    [newTitle, originalTask.description, createdBy, taskId, startDate, dueDate || null, originalTask.task_type || 'regular'],
                        function(err) {
                            if (err) {
                                res.status(500).json({ error: err.message });
                                return;
                            }

                            const newTaskId = this.lastID;

                            saveTaskMetadata(newTaskId, newTitle, originalTask.description, createdBy, taskId, startDate, dueDate);

                            logActivity(newTaskId, createdBy, 'TASK_COPIED', `Создана копия задачи: ${newTitle}`);
                            
                            db.all("SELECT * FROM task_files WHERE task_id = ?", [taskId], (err, originalFiles) => {
                                if (!err && originalFiles && originalFiles.length > 0) {
                                    originalFiles.forEach(originalFile => {
                                        const originalFilePath = originalFile.file_path;
                                        const newFilename = Date.now() + '-' + Math.round(Math.random() * 1E9) + path.extname(originalFile.original_name);
                                        const userFolder = createUserTaskFolder(newTaskId, req.session.user.login);
                                        const newFilePath = path.join(userFolder, newFilename);

                                        if (fs.existsSync(originalFilePath)) {
                                            fs.copyFileSync(originalFilePath, newFilePath);

                                            db.run(
                                                "INSERT INTO task_files (task_id, user_id, filename, original_name, file_path, file_size) VALUES (?, ?, ?, ?, ?, ?)",
                                                [newTaskId, createdBy, newFilename, originalFile.original_name, newFilePath, originalFile.file_size]
                                            );

                                            logActivity(newTaskId, createdBy, 'FILE_COPIED', `Скопирован файл: ${originalFile.original_name}`);
                                        }
                                    });
                                }
                            });

                            if (assignedUsers && assignedUsers.length > 0) {
                                assignedUsers.forEach(userId => {
                                    db.run(
                                        "INSERT INTO task_assignments (task_id, user_id, start_date, due_date) VALUES (?, ?, ?, ?)",
                                        [newTaskId, userId, startDate, dueDate || null]
                                    );
                                });
                                
                                logActivity(newTaskId, createdBy, 'TASK_ASSIGNED', `Задача назначена пользователям: ${assignedUsers.join(', ')}`);

                                sendTaskNotifications('created', newTaskId, newTitle, originalTask.description, createdBy);
                            }

                            res.json({ 
                                success: true, 
                                taskId: newTaskId,
                                message: 'Копия задачи успешно создана'
                            });
                        }
                    );
                });
            });
        });
    });

    app.put('/api/tasks/:taskId', requireAuth, upload.array('files', 15), (req, res) => {
        const { taskId } = req.params;
        const { title, description, assignedUsers, dueDate } = req.body;
        const userId = req.session.user.id;

        if (!title) {
            return res.status(400).json({ error: 'Название задачи обязательно' });
        }

        if (!dueDate) {
            return res.status(400).json({ error: 'Дата и время выполнения обязательны' });
        }

        db.get("SELECT created_by, status, closed_at FROM tasks WHERE id = ?", [taskId], (err, task) => {
            if (err || !task) {
                return res.status(404).json({ error: 'Задача не найдена' });
            }

            // Проверяем права на редактирование
            if (!canUserEditTask(task, req.session.user)) {
                return res.status(403).json({ error: 'У вас нет прав для редактирования этой задачи' });
            }
            const taskType = req.body.taskType || 'regular';
            db.serialize(() => {
                db.run(
    "UPDATE tasks SET title = ?, description = ?, due_date = ?, task_type = ?, updated_at = CURRENT_TIMESTAMP WHERE id = ?",
    [title, description, dueDate || null, taskType, taskId],
                    function(err) {
                        if (err) {
                            res.status(500).json({ error: err.message });
                            return;
                        }

                        updateTaskMetadata(taskId, { title, description, due_date: dueDate });

                        logActivity(taskId, userId, 'TASK_UPDATED', `Задача обновлена: ${title}`);

                        if (req.files && req.files.length > 0) {
                            const userFolder = createUserTaskFolder(taskId, req.session.user.login);
                            
                            req.files.forEach(file => {
                                const newPath = path.join(userFolder, path.basename(file.filename));
                                fs.renameSync(file.path, newPath);

                                const originalName = file.originalname;

                                db.run(
                                    "INSERT INTO task_files (task_id, user_id, filename, original_name, file_path, file_size) VALUES (?, ?, ?, ?, ?, ?)",
                                    [taskId, userId, path.basename(file.filename), originalName, newPath, file.size]
                                );

                                logActivity(taskId, userId, 'FILE_UPLOADED', `Загружен файл: ${originalName}`);
                            });

                            const tempDir = path.join(__dirname, 'data', 'uploads', 'temp');
                            if (fs.existsSync(tempDir)) {
                                fs.rmSync(tempDir, { recursive: true, force: true });
                            }
                        }

                        if (assignedUsers) {
                            db.run("DELETE FROM task_assignments WHERE task_id = ?", [taskId], (err) => {
                                if (err) {
                                    console.error('❌ Ошибка удаления старых назначений:', err);
                                }

                                const userIds = Array.isArray(assignedUsers) ? assignedUsers : [assignedUsers];
                                userIds.forEach(userId => {
                                    const startDate = new Date().toISOString();
                                    db.run(
                                        "INSERT INTO task_assignments (task_id, user_id, start_date, due_date) VALUES (?, ?, ?, ?)",
                                        [taskId, userId, startDate, dueDate || null]
                                    );
                                });

                                logActivity(taskId, userId, 'TASK_ASSIGNMENTS_UPDATED', `Назначения обновлены`);

                                sendTaskNotifications('updated', taskId, title, description, userId);
                            });
                        } else {
                            sendTaskNotifications('updated', taskId, title, description, userId);
                        }

                        res.json({ success: true, message: 'Задача обновлена' });
                    }
                );
            });
        });
    });

    app.post('/api/tasks/:taskId/rework', requireAuth, (req, res) => {
        const { taskId } = req.params;
        const { comment } = req.body;
        const userId = req.session.user.id;

        db.get("SELECT created_by, status FROM tasks WHERE id = ?", [taskId], (err, task) => {
            if (err || !task) {
                return res.status(404).json({ error: 'Задача не найдена' });
            }

            // Проверяем права на возврат на доработку
            if (!canUserEditTask(task, req.session.user)) {
                return res.status(403).json({ error: 'У вас нет прав для возврата задачи на доработку' });
            }

            db.serialize(() => {
                db.run(
                    "UPDATE tasks SET rework_comment = ?, updated_at = CURRENT_TIMESTAMP WHERE id = ?",
                    [comment || 'Требуется доработка', taskId],
                    function(err) {
                        if (err) {
                            res.status(500).json({ error: err.message });
                            return;
                        }

                        db.run(
                            "UPDATE task_assignments SET status = 'rework', rework_comment = ?, updated_at = CURRENT_TIMESTAMP WHERE task_id = ?",
                            [comment || 'Требуется доработка', taskId],
                            function(err) {
                                if (err) {
                                    res.status(500).json({ error: err.message });
                                    return;
                                }

                                logActivity(taskId, userId, 'TASK_SENT_FOR_REWORK', `Задача возвращена на доработку: ${comment}`);

                                db.get("SELECT title, description FROM tasks WHERE id = ?", [taskId], (err, taskData) => {
                                    if (!err && taskData) {
                                        sendTaskNotifications('rework', taskId, taskData.title, taskData.description, userId, comment);
                                    }
                                });

                                res.json({ success: true, message: 'Задача возвращена на доработку' });
                            }
                        );
                    }
                );
            });
        });
    });

    app.post('/api/tasks/:taskId/close', requireAuth, (req, res) => {
        const { taskId } = req.params;
        const userId = req.session.user.id;

        db.get("SELECT created_by FROM tasks WHERE id = ?", [taskId], (err, task) => {
            if (err || !task) {
                return res.status(404).json({ error: 'Задача не найдена' });
            }

            // Создатель и администратор могут закрывать задачу
            if (req.session.user.role !== 'admin' && task.created_by !== userId) {
                return res.status(403).json({ error: 'У вас нет прав для закрытия этой задачи' });
            }

            db.run(
                "UPDATE tasks SET closed_at = CURRENT_TIMESTAMP, closed_by = ?, updated_at = CURRENT_TIMESTAMP WHERE id = ?",
                [userId, taskId],
                function(err) {
                    if (err) {
                        res.status(500).json({ error: err.message });
                        return;
                    }

                    logActivity(taskId, userId, 'TASK_CLOSED', `Задача закрыта`);

                    db.get("SELECT title FROM tasks WHERE id = ?", [taskId], (err, taskData) => {
                        if (!err && taskData) {
                            sendTaskNotifications('closed', taskId, taskData.title, '', userId);
                        }
                    });

                    res.json({ success: true, message: 'Задача закрыта' });
                }
            );
        });
    });

    app.post('/api/tasks/:taskId/reopen', requireAuth, (req, res) => {
        const { taskId } = req.params;
        const userId = req.session.user.id;

        db.get("SELECT created_by FROM tasks WHERE id = ?", [taskId], (err, task) => {
            if (err || !task) {
                return res.status(404).json({ error: 'Задача не найдена' });
            }

            // Создатель и администратор могут открывать задачу
            if (req.session.user.role !== 'admin' && task.created_by !== userId) {
                return res.status(403).json({ error: 'У вас нет прав для открытия этой задачи' });
            }

            db.run(
                "UPDATE tasks SET closed_at = NULL, closed_by = NULL, updated_at = CURRENT_TIMESTAMP WHERE id = ?",
                [taskId],
                function(err) {
                    if (err) {
                        res.status(500).json({ error: err.message });
                        return;
                    }

                    logActivity(taskId, userId, 'TASK_REOPENED', `Задача открыта`);

                    res.json({ success: true, message: 'Задача открыта' });
                }
            );
        });
    });

    app.put('/api/tasks/:taskId/assignment/:userId', requireAuth, (req, res) => {
        const { taskId, userId } = req.params;
        const { dueDate } = req.body;
        const currentUserId = req.session.user.id;

        if (!dueDate) {
            return res.status(400).json({ error: 'Дата и время выполнения обязательны' });
        }

        db.get("SELECT created_by FROM tasks WHERE id = ?", [taskId], (err, task) => {
            if (err || !task) {
                return res.status(404).json({ error: 'Задача не найдена' });
            }

            // Проверяем права на изменение сроков
            if (!canUserEditTask(task, req.session.user)) {
                return res.status(403).json({ error: 'У вас нет прав для редактирования сроков' });
            }

            db.run(
                "UPDATE task_assignments SET due_date = ?, updated_at = CURRENT_TIMESTAMP WHERE task_id = ? AND user_id = ?",
                [dueDate || null, taskId, userId],
                function(err) {
                    if (err) {
                        res.status(500).json({ error: err.message });
                        return;
                    }

                    if (this.changes === 0) {
                        return res.status(404).json({ error: 'Назначение не найдено' });
                    }

                    logActivity(taskId, currentUserId, 'ASSIGNMENT_UPDATED', `Обновлены сроки для пользователя ${userId}`);

                    db.get("SELECT title, description FROM tasks WHERE id = ?", [taskId], (err, taskData) => {
                        if (!err && taskData) {
                            sendTaskNotifications('updated', taskId, taskData.title, taskData.description, currentUserId);
                        }
                    });

                    res.json({ success: true, message: 'Сроки обновлены' });
                }
            );
        });
    });

    app.delete('/api/tasks/:taskId', requireAuth, (req, res) => {
        const { taskId } = req.params;
        const userId = req.session.user.id;

        db.get("SELECT created_by, status FROM tasks WHERE id = ? AND status = 'active'", [taskId], (err, task) => {
            if (err || !task) {
                return res.status(404).json({ error: 'Задача не найдена' });
            }

            // Проверяем права на удаление
            if (!canUserEditTask(task, req.session.user)) {
                return res.status(403).json({ error: 'У вас нет прав для удаления этой задачи' });
            }

            db.run(
                "UPDATE tasks SET status = 'deleted', deleted_at = CURRENT_TIMESTAMP, deleted_by = ? WHERE id = ?",
                [userId, taskId],
                function(err) {
                    if (err) {
                        res.status(500).json({ error: err.message });
                        return;
                    }

                    updateTaskMetadata(taskId, { 
                        status: 'deleted', 
                        deleted_at: new Date().toISOString(),
                        deleted_by: userId
                    });

                    logActivity(taskId, userId, 'TASK_DELETED', `Задача помечена как удаленная`);

                    res.json({ success: true, message: 'Задача удалена' });
                }
            );
        });
    });

    app.post('/api/tasks/:taskId/restore', requireAuth, (req, res) => {
        const { taskId } = req.params;
        const userId = req.session.user.id;

        if (req.session.user.role !== 'admin') {
            return res.status(403).json({ error: 'Недостаточно прав' });
        }

        db.run(
            "UPDATE tasks SET status = 'active', deleted_at = NULL, deleted_by = NULL WHERE id = ?",
            [taskId],
            function(err) {
                if (err) {
                    res.status(500).json({ error: err.message });
                    return;
                }

                if (this.changes === 0) {
                    return res.status(404).json({ error: 'Задача не найдена' });
                }

                updateTaskMetadata(taskId, { 
                    status: 'active', 
                    deleted_at: null,
                    deleted_by: null
                });

                logActivity(taskId, userId, 'TASK_RESTORED', `Задача восстановлена`);

                res.json({ success: true, message: 'Задача восстановлена' });
            }
        );
    });

    app.put('/api/tasks/:taskId/status', requireAuth, (req, res) => {
        const { taskId } = req.params;
        const { userId: targetUserId, status } = req.body;
        const currentUserId = req.session.user.id;

        if (parseInt(targetUserId) !== currentUserId) {
            return res.status(403).json({ error: 'Недостаточно прав' });
        }

        if (!targetUserId || !status) {
            return res.status(400).json({ error: 'userId и status обязательны' });
        }

        db.get("SELECT 1 FROM task_assignments WHERE task_id = ? AND user_id = ?", [taskId, currentUserId], (err, assignment) => {
            if (err || !assignment) {
                return res.status(403).json({ error: 'Вы не назначены на эту задачу' });
            }

            db.get(`
                SELECT t.title, t.description, u.name as user_name 
                FROM tasks t 
                LEFT JOIN users u ON u.id = ? 
                WHERE t.id = ?
            `, [currentUserId, taskId], (err, taskData) => {
                if (err) {
                    console.error('❌ Ошибка получения данных задачи:', err);
                }

                const finalStatus = status === 'completed' ? 'completed' : status;

                db.run(
                    "UPDATE task_assignments SET status = ?, updated_at = CURRENT_TIMESTAMP WHERE task_id = ? AND user_id = ?",
                    [finalStatus, taskId, targetUserId],
                    function(err) {
                        if (err) {
                            res.status(500).json({ error: err.message });
                            return;
                        }

                        if (this.changes === 0) {
                            res.status(404).json({ error: 'Назначение не найдено' });
                            return;
                        }

                        logActivity(taskId, targetUserId, 'STATUS_CHANGED', `Статус изменен на: ${finalStatus}`);
                        
                        if (taskData) {
                            sendTaskNotifications(
                                'status_changed', 
                                taskId, 
                                taskData.title, 
                                taskData.description, 
                                currentUserId,
                                '',
                                finalStatus,
                                taskData.user_name || req.session.user.name
                            );
                        }

                        res.json({ success: true, message: 'Статус обновлен' });
                    }
                );
            });
        });
    });
// API для отправки конкретного исполнителя на доработку
app.put('/api/tasks/:taskId/rework-assignment/:userId', requireAuth, (req, res) => {
    const { taskId, userId } = req.params;
    const { comment } = req.body;
    const currentUserId = req.session.user.id;

    console.log('=== ОТПРАВКА НА ДОРАБОТКУ ===');
    console.log('taskId:', taskId);
    console.log('userId:', userId);
    console.log('comment:', comment);
    console.log('==============================');

    if (!comment) {
        return res.status(400).json({ error: 'Комментарий к доработке обязателен' });
    }

    db.get("SELECT created_by, status FROM tasks WHERE id = ?", [taskId], (err, task) => {
        if (err || !task) {
            return res.status(404).json({ error: 'Задача не найдена' });
        }

        // Проверяем права: автор задачи или администратор
        if (req.session.user.role !== 'admin' && parseInt(task.created_by) !== parseInt(currentUserId)) {
            return res.status(403).json({ error: 'Только автор задачи может отправлять на доработку' });
        }

        // Проверяем существование назначения
        db.get("SELECT id, status FROM task_assignments WHERE task_id = ? AND user_id = ?", 
            [taskId, userId], 
            (err, assignment) => {
                if (err) {
                    return res.status(500).json({ error: err.message });
                }
                
                if (!assignment) {
                    return res.status(404).json({ error: 'Исполнитель не назначен на эту задачу' });
                }

                // Обновляем статус конкретного исполнителя
                db.run(
                    `UPDATE task_assignments 
                     SET status = 'rework', 
                         rework_comment = ?, 
                         updated_at = CURRENT_TIMESTAMP 
                     WHERE task_id = ? AND user_id = ?`,
                    [comment, taskId, userId],
                    function(err) {
                        if (err) {
                            res.status(500).json({ error: err.message });
                            return;
                        }

                        // Логируем действие
                        try {
                            logActivity(parseInt(taskId), currentUserId, 'ASSIGNMENT_REWORK', 
                                `Исполнитель ${userId} отправлен на доработку: ${comment.substring(0, 50)}`);
                        } catch (e) {
                            console.error('Ошибка логирования:', e);
                        }

                        // Получаем данные для уведомления
                        db.get(`SELECT t.title, t.description, u.name as executor_name 
                                FROM tasks t 
                                LEFT JOIN users u ON u.id = ? 
                                WHERE t.id = ?`, 
                            [userId, taskId], (err, taskData) => {
                            if (!err && taskData) {
                                try {
                                    sendTaskNotifications(
                                        'rework_assignment', 
                                        taskId, 
                                        taskData.title, 
                                        taskData.description, 
                                        currentUserId,
                                        comment,
                                        'rework',
                                        req.session.user.name,
                                        userId
                                    );
                                } catch (e) {
                                    console.error('Ошибка отправки уведомления:', e);
                                }
                            }
                        });

                        res.json({ 
                            success: true, 
                            message: 'Исполнитель отправлен на доработку' 
                        });
                    }
                );
            }
        );
    });
});

// API для принудительного завершения задачи исполнителем (для автора/админа)
app.put('/api/tasks/:taskId/force-complete/:userId', requireAuth, (req, res) => {
    const { taskId, userId } = req.params;
    const currentUserId = req.session.user.id;

    console.log('=== ПРИНУДИТЕЛЬНОЕ ЗАВЕРШЕНИЕ ===');
    console.log('taskId:', taskId);
    console.log('userId:', userId);
    console.log('currentUserId:', currentUserId);
    console.log('==================================');

    db.get("SELECT created_by, title, description, closed_at FROM tasks WHERE id = ?", [taskId], (err, task) => {
        if (err) {
            console.error('❌ Ошибка при поиске задачи:', err);
            return res.status(500).json({ error: 'Ошибка базы данных' });
        }
        
        if (!task) {
            return res.status(404).json({ error: 'Задача не найдена' });
        }

        // Проверяем права: автор задачи или администратор
        if (req.session.user.role !== 'admin' && parseInt(task.created_by) !== parseInt(currentUserId)) {
            return res.status(403).json({ error: 'Только автор задачи может принудительно завершать выполнение' });
        }

        // Проверяем, что задача не закрыта
        if (task.closed_at) {
            return res.status(400).json({ error: 'Задача уже закрыта' });
        }

        // Проверяем существование назначения
        db.get("SELECT id, status FROM task_assignments WHERE task_id = ? AND user_id = ?", 
            [taskId, userId], 
            (err, assignment) => {
                if (err) {
                    console.error('❌ Ошибка при поиске назначения:', err);
                    return res.status(500).json({ error: 'Ошибка базы данных' });
                }

                if (!assignment) {
                    return res.status(404).json({ error: 'Исполнитель не назначен на эту задачу' });
                }

                // Если уже выполнено, просто возвращаем успех
                if (assignment.status === 'completed') {
                    return res.json({ 
                        success: true, 
                        message: 'Задача уже была отмечена как выполненная' 
                    });
                }

                // Обновляем статус конкретного исполнителя на "completed"
                db.run(
                    `UPDATE task_assignments 
                     SET status = 'completed', 
                         updated_at = CURRENT_TIMESTAMP 
                     WHERE task_id = ? AND user_id = ?`,
                    [taskId, userId],
                    function(err) {
                        if (err) {
                            console.error('❌ Ошибка при обновлении статуса:', err);
                            return res.status(500).json({ error: err.message });
                        }

                        console.log(`✅ Статус исполнителя ${userId} обновлен на completed`);

                        // Логируем действие
                        try {
                            logActivity(parseInt(taskId), currentUserId, 'ASSIGNMENT_FORCE_COMPLETED', 
                                `Исполнитель ${userId} принудительно отмечен как выполнивший задачу`);
                        } catch (e) {
                            console.error('Ошибка логирования:', e);
                        }

                        // Проверяем, все ли исполнители выполнили задачу
                        db.all(
                            "SELECT status FROM task_assignments WHERE task_id = ?",
                            [taskId],
                            (err, assignments) => {
                                if (!err && assignments && assignments.length > 0) {
                                    const allCompleted = assignments.every(a => a.status === 'completed');
                                    
                                    if (allCompleted) {
                                        // Если все исполнители выполнили, автоматически закрываем задачу
                                        db.run(
                                            "UPDATE tasks SET closed_at = CURRENT_TIMESTAMP, closed_by = ?, updated_at = CURRENT_TIMESTAMP WHERE id = ?",
                                            [currentUserId, taskId],
                                            function(err) {
                                                if (!err) {
                                                    console.log(`✅ Задача ${taskId} автоматически закрыта`);
                                                    try {
                                                        logActivity(parseInt(taskId), currentUserId, 'TASK_CLOSED', 
                                                            'Задача автоматически закрыта после выполнения всеми исполнителями');
                                                    } catch (e) {
                                                        console.error('Ошибка логирования:', e);
                                                    }
                                                }
                                            }
                                        );
                                    }
                                }
                            }
                        );

                        res.json({ 
                            success: true, 
                            message: 'Исполнитель отмечен как выполнивший задачу' 
                        });
                    }
                );
            }
        );
    });
});
app.post('/api/tasks/:taskId/files', requireAuth, upload.array('files', 15), (req, res) => {
    const { taskId } = req.params;
    const userId = req.session.user.id;

    if (!req.files || req.files.length === 0) {
        return res.status(400).json({ error: 'Нет файлов для загрузки' });
    }

    // Проверяем доступ к задаче через checkTaskAccess
    const { checkTaskAccess } = require('./database');
    
    checkTaskAccess(userId, taskId, (err, hasAccess) => {
        if (err || !hasAccess) {
            return res.status(403).json({ error: 'Нет доступа к задаче' });
        }

        // Дополнительно проверяем, что задача активна
        db.get("SELECT status, closed_at FROM tasks WHERE id = ?", [taskId], (err, task) => {
            if (err || !task) {
                return res.status(404).json({ error: 'Задача не найдена' });
            }

            if (task.closed_at) {
                return res.status(400).json({ error: 'Задача уже закрыта' });
            }

            const userFolder = createUserTaskFolder(taskId, req.session.user.login);
            
            const uploadPromises = req.files.map(file => {
                return new Promise((resolve, reject) => {
                    const newPath = path.join(userFolder, path.basename(file.filename));
                    fs.renameSync(file.path, newPath);

                    const originalName = file.originalname;

                    db.run(
                        "INSERT INTO task_files (task_id, user_id, filename, original_name, file_path, file_size) VALUES (?, ?, ?, ?, ?, ?)",
                        [taskId, userId, path.basename(file.filename), originalName, newPath, file.size],
                        function(err) {
                            if (err) {
                                reject(err);
                                return;
                            }
                            
                            logActivity(taskId, userId, 'FILE_UPLOADED', `Загружен файл: ${originalName}`);
                            resolve({
                                id: this.lastID,
                                originalName,
                                size: file.size
                            });
                        }
                    );
                });
            });

            Promise.all(uploadPromises)
                .then((uploadedFiles) => {
                    res.json({ 
                        success: true, 
                        message: 'Файлы успешно загружены',
                        files: uploadedFiles,
                        count: uploadedFiles.length
                    });
                })
                .catch((error) => {
                    console.error('Ошибка при загрузке файлов:', error);
                    res.status(500).json({ error: 'Ошибка при сохранении файлов в БД' });
                });
        });
    });
});

    // API для получения одной задачи
    app.get('/api/tasks/:taskId', requireAuth, (req, res) => {
        const { taskId } = req.params;
        const userId = req.session.user.id;

        checkTaskAccess(userId, taskId, (err, hasAccess) => {
            if (err || !hasAccess) {
                return res.status(404).json({ error: 'Задача не найдена или у вас нет прав доступа' });
            }

            const query = `
                SELECT t.*, u.name as creator_name, u.login as creator_login,
                       ot.title as original_task_title, ou.name as original_creator_name
                FROM tasks t
                LEFT JOIN users u ON t.created_by = u.id
                LEFT JOIN tasks ot ON t.original_task_id = ot.id
                LEFT JOIN users ou ON ot.created_by = ou.id
                WHERE t.id = ?
            `;

            db.get(query, [taskId], async (err, task) => {
                if (err || !task) {
                    return res.status(404).json({ error: 'Задача не найдена' });
                }

                // Получаем назначения
                const assignments = await new Promise((resolve) => {
                    db.all(`
                        SELECT ta.*, u.name as user_name, u.login as user_login
                        FROM task_assignments ta 
                        LEFT JOIN users u ON ta.user_id = u.id 
                        WHERE ta.task_id = ?
                    `, [taskId], (err, rows) => {
                        resolve(rows || []);
                    });
                });

                // Получаем файлы
                const files = await new Promise((resolve) => {
                    db.all(`
                        SELECT tf.*, u.name as user_name
                        FROM task_files tf 
                        LEFT JOIN users u ON tf.user_id = u.id 
                        WHERE tf.task_id = ?
                        ORDER BY tf.uploaded_at DESC
                    `, [taskId], (err, rows) => {
                        resolve(rows || []);
                    });
                });

                task.assignments = assignments;
                task.files = files;
                task.canEdit = canUserEditTask(task, req.session.user);

                res.json(task);
            });
        });
    });
    // API для обновления полей документа в задаче
app.put('/api/tasks/:taskId/document-fields', requireAuth, (req, res) => {
    const { taskId } = req.params;
    const { document_n, document_d, document_a } = req.body;
    const userId = req.session.user.id;
    const userLogin = req.session.user.login;

    console.log('📄 Обновление полей документа:');
    console.log('taskId:', taskId);
    console.log('document_n:', document_n);
    console.log('document_d:', document_d);
    console.log('document_a:', document_a || userLogin);
    console.log('userId:', userId);

    // Проверяем доступ к задаче
    checkTaskAccess(userId, taskId, (err, hasAccess) => {
        if (err || !hasAccess) {
            return res.status(404).json({ error: 'Задача не найдена или у вас нет прав доступа' });
        }

        // Проверяем существование задачи
        db.get("SELECT id FROM tasks WHERE id = ?", [taskId], (err, task) => {
            if (err || !task) {
                return res.status(404).json({ error: 'Задача не найдена' });
            }

            // Формируем запрос на обновление
            let query = "UPDATE tasks SET ";
            const updates = [];
            const params = [];

            if (document_n !== undefined) {
                updates.push("document_n = ?");
                params.push(document_n || null);
            }

            if (document_d !== undefined) {
                updates.push("document_d = ?");
                params.push(document_d || null);
            }

            // document_a по умолчанию берем из сессии, если не передан
            const authorValue = document_a !== undefined ? document_a : userLogin;
            updates.push("document_a = ?");
            params.push(authorValue || null);

            if (updates.length === 0) {
                return res.status(400).json({ error: 'Нет данных для обновления' });
            }

            updates.push("updated_at = CURRENT_TIMESTAMP");
            query += updates.join(", ") + " WHERE id = ?";
            params.push(taskId);

            db.run(query, params, function(err) {
                if (err) {
                    console.error('❌ Ошибка обновления полей документа:', err);
                    return res.status(500).json({ error: err.message });
                }

                if (this.changes === 0) {
                    return res.status(404).json({ error: 'Задача не обновлена' });
                }

                // Логируем действие
                logActivity(taskId, userId, 'DOCUMENT_FIELDS_UPDATED', 
                    `Обновлены поля документа: №${document_n || ''}, дата: ${document_d || ''}`);

                console.log('✅ Поля документа успешно обновлены');

                res.json({ 
                    success: true, 
                    message: 'Поля документа обновлены',
                    data: {
                        document_n: document_n || null,
                        document_d: document_d || null,
                        document_a: authorValue
                    }
                });
            });
        });
    });
});

// API для получения полей документа задачи
app.get('/api/tasks/:taskId/document-fields', requireAuth, (req, res) => {
    const { taskId } = req.params;
    const userId = req.session.user.id;

    checkTaskAccess(userId, taskId, (err, hasAccess) => {
        if (err || !hasAccess) {
            return res.status(404).json({ error: 'Задача не найдена или у вас нет прав доступа' });
        }

        db.get(
            "SELECT document_n, document_d, document_a FROM tasks WHERE id = ?",
            [taskId],
            (err, row) => {
                if (err) {
                    console.error('❌ Ошибка получения полей документа:', err);
                    return res.status(500).json({ error: err.message });
                }

                if (!row) {
                    return res.status(404).json({ error: 'Задача не найдена' });
                }

                res.json({
                    success: true,
                    data: {
                        document_n: row.document_n || '',
                        document_d: row.document_d || '',
                        document_a: row.document_a || ''
                    }
                });
            }
        );
    });
});
// API для получения типа задачи
app.get('/api/tasks/:taskId/type', requireAuth, (req, res) => {
    const { taskId } = req.params;
    const userId = req.session.user.id;

    // Проверяем доступ к задаче
    const { checkTaskAccess } = require('./database');
    
    checkTaskAccess(userId, taskId, (err, hasAccess) => {
        if (err || !hasAccess) {
            return res.status(404).json({ error: 'Задача не найдена или у вас нет прав доступа' });
        }

        db.get(
            "SELECT task_type FROM tasks WHERE id = ?",
            [taskId],
            (err, row) => {
                if (err) {
                    console.error('❌ Ошибка получения типа задачи:', err);
                    return res.status(500).json({ error: err.message });
                }

                if (!row) {
                    return res.status(404).json({ error: 'Задача не найдена' });
                }

                res.json({
                    success: true,
                    task_type: row.task_type || 'regular',
                    taskId: taskId
                });
            }
        );
    });
});
}

module.exports = { setupTaskEndpoints,getApproverUsers };