const express = require('express');
const multer = require('multer');
const path = require('path');
const fs = require('fs');
const session = require('express-session');
const fetch = require('node-fetch');
require('dotenv').config();

const { db, logActivity, createUserTaskFolder, saveTaskMetadata, updateTaskMetadata, checkTaskAccess } = require('./database');
const authService = require('./auth');
const adminRouter = require('./admin-server');
const postgresLogger = require('./postgres');

const app = express();
const PORT = process.env.PORT || 3000;

app.use(express.json());
app.use(express.urlencoded({ extended: true }));
app.use(express.static('public'));
app.use('/uploads', express.static(path.join(__dirname, 'data', 'uploads')));
app.use(session({
    secret: process.env.SESSION_SECRET || 'fallback_secret_change_in_production',
    resave: true,
    saveUninitialized: false,
    cookie: { 
        secure: false, 
        maxAge: 24 * 60 * 60 * 1000,
        httpOnly: true
    }
}));

app.use(adminRouter);

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

const storage = multer.diskStorage({
    destination: (req, file, cb) => {
        const taskId = req.body.taskId || req.params.taskId;
        const userLogin = req.session.user.login;
        
        if (taskId) {
            const userFolder = createUserTaskFolder(taskId, userLogin);
            cb(null, userFolder);
        } else {
            const tempDir = path.join(__dirname, 'data', 'uploads', 'temp');
            if (!fs.existsSync(tempDir)) {
                fs.mkdirSync(tempDir, { recursive: true });
            }
            cb(null, tempDir);
        }
    },
    filename: (req, file, cb) => {
        const uniqueSuffix = Date.now() + '-' + Math.round(Math.random() * 1E9);
        cb(null, uniqueSuffix + path.extname(file.originalname));
    }
});

const upload = multer({
    storage: storage,
    limits: {
        fileSize: 300 * 1024 * 1024,
        files: 15
    }
});

const createDirIfNotExists = (dirPath) => {
    if (!fs.existsSync(dirPath)) {
        fs.mkdirSync(dirPath, { recursive: true });
    }
};

function checkIfOverdue(dueDate, status) {
    if (!dueDate || status === 'completed') return false;
    const now = new Date();
    const due = new Date(dueDate);
    return due < now;
}

function checkOverdueTasks() {
    const now = new Date().toISOString();
    
    const query = `
        SELECT ta.id, ta.task_id, ta.user_id, ta.status, ta.due_date
        FROM task_assignments ta
        JOIN tasks t ON ta.task_id = t.id
        WHERE ta.due_date IS NOT NULL 
        AND ta.due_date < ? 
        AND ta.status NOT IN ('completed', 'overdue')
        AND t.status = 'active'
        AND t.closed_at IS NULL
    `;

    db.all(query, [now], (err, assignments) => {
        if (err) {
            console.error('Ошибка при проверке просроченных задач:', err);
            return;
        }

        assignments.forEach(assignment => {
            db.run(
                "UPDATE task_assignments SET status = 'overdue' WHERE id = ?",
                [assignment.id]
            );
            logActivity(assignment.task_id, assignment.user_id, 'STATUS_CHANGED', 'Задача просрочена');
        });
    });
}

function checkUpcomingDeadlines() {
    const now = new Date();
    const in48Hours = new Date(now.getTime() + 48 * 60 * 60 * 1000).toISOString();
    const in24Hours = new Date(now.getTime() + 24 * 60 * 60 * 1000).toISOString();
    const nowISO = now.toISOString();

    const query = `
        SELECT DISTINCT ta.*, t.title, t.description, t.created_by, u.name as user_name, u.email as user_email,
               creator.name as creator_name, creator.email as creator_email
        FROM task_assignments ta
        JOIN tasks t ON ta.task_id = t.id
        JOIN users u ON ta.user_id = u.id
        JOIN users creator ON t.created_by = creator.id
        WHERE ta.due_date IS NOT NULL 
        AND ta.due_date > ?
        AND ta.due_date <= ?
        AND ta.status NOT IN ('completed', 'overdue')
        AND t.status = 'active'
        AND t.closed_at IS NULL
    `;

    db.all(query, [nowISO, in48Hours], async (err, assignments) => {
        if (err) {
            console.error('Ошибка при проверке сроков задач:', err);
            return;
        }

        for (const assignment of assignments) {
            const dueDate = new Date(assignment.due_date);
            const timeLeft = dueDate.getTime() - now.getTime();
            const hoursLeft = Math.floor(timeLeft / (60 * 60 * 1000));

            if (hoursLeft <= 48 && hoursLeft > 24) {
                await sendDeadlineNotification(assignment, 48);
            } else if (hoursLeft <= 24) {
                await sendDeadlineNotification(assignment, 24);
            }
        }
    });
}

async function sendDeadlineNotification(assignment, hoursLeft) {
    try {
        if (!process.env.NOTIFICATION_SERVICE_URL || 
            !process.env.NOTIFICATION_SERVICE_LOGIN || 
            !process.env.NOTIFICATION_SERVICE_PASSWORD) {
            return;
        }

        const notificationKey = `deadline_${hoursLeft}h_task_${assignment.task_id}_user_${assignment.user_id}`;
        const lastSent = await getLastNotificationSent(notificationKey);
        const now = new Date();

        if (lastSent) {
            const timeSinceLast = now.getTime() - new Date(lastSent).getTime();
            if (timeSinceLast < 12 * 60 * 60 * 1000) {
                return;
            }
        }

        const subject = `⚠️ До окончания срока задачи осталось менее ${hoursLeft} часов`;
        const content = `Задача: ${assignment.title}\n\n` +
                       `Описание: ${assignment.description || 'Без описания'}\n` +
                       `Срок выполнения: ${new Date(assignment.due_date).toLocaleString('ru-RU')}\n` +
                       `Осталось времени: ${hoursLeft} часов\n\n` +
                       `Пожалуйста, завершите задачу в срок.`;

        const recipients = [
            { id: assignment.user_id, name: assignment.user_name, email: assignment.user_email },
            { id: assignment.created_by, name: assignment.creator_name, email: assignment.creator_email }
        ].filter((value, index, self) => 
            self.findIndex(r => r.id === value.id) === index
        );

        const recipientIds = recipients.map(r => r.id);

        const authHeader = Buffer.from(
            `${process.env.NOTIFICATION_SERVICE_LOGIN}:${process.env.NOTIFICATION_SERVICE_PASSWORD}`
        ).toString('base64');

        const FormData = require('form-data');
        const formData = new FormData();
        formData.append('subject', subject);
        formData.append('content', content);
        formData.append('recipients', JSON.stringify(recipientIds));
        formData.append('deliveryMethods', JSON.stringify(['email', 'telegram', 'vk']));

        const response = await fetch(process.env.NOTIFICATION_SERVICE_URL, {
            method: 'POST',
            headers: {
                'Authorization': `Basic ${authHeader}`
            },
            body: formData
        });

        if (response.ok) {
            await saveNotificationSent(notificationKey);
            console.log(`✅ Уведомление о сроке (${hoursLeft}ч) отправлено для задачи ${assignment.task_id}`);
        }
    } catch (error) {
        console.error('❌ Ошибка отправки уведомления о сроке:', error);
    }
}

function getLastNotificationSent(key) {
    return new Promise((resolve) => {
        db.get("SELECT created_at FROM notification_logs WHERE notification_key = ? ORDER BY created_at DESC LIMIT 1", 
            [key], (err, row) => {
                resolve(row ? row.created_at : null);
            }
        );
    });
}

function saveNotificationSent(key) {
    db.run("INSERT INTO notification_logs (notification_key) VALUES (?)", [key]);
}

function encodeBasicAuth(login, password) {
    return Buffer.from(`${login}:${password}`).toString('base64');
}

async function sendTaskNotifications(type, taskId, taskTitle, taskDescription, authorId, comment = '', status = '', userName = '') {
    try {
        if (!process.env.NOTIFICATION_SERVICE_URL || 
            !process.env.NOTIFICATION_SERVICE_LOGIN || 
            !process.env.NOTIFICATION_SERVICE_PASSWORD) {
            console.log('⚠️ Настройки сервиса уведомлений не заданы');
            
            // Логируем в PostgreSQL даже если уведомления не отправляются
            await logNotificationToPostgres({
                type,
                taskId,
                taskTitle,
                taskDescription,
                authorId,
                comment,
                status,
                userName,
                error: 'Сервис уведомлений не настроен'
            });
            
            return;
        }

        console.log(`📢 Начинаем отправку уведомлений для задачи ${taskId}:`);
        console.log(`   Тип: ${type}, Автор действия: ${authorId}, Название: ${taskTitle}`);

        // Получаем заказчика (создателя задачи) ОТДЕЛЬНО
        const creator = await new Promise((resolve, reject) => {
            db.get(`
                SELECT t.created_by as user_id, u.name as user_name, u.login as user_login, u.email
                FROM tasks t
                LEFT JOIN users u ON t.created_by = u.id
                WHERE t.id = ?
            `, [taskId], (err, row) => {
                if (err) reject(err);
                else resolve(row);
            });
        });

        // Получаем исполнителей ОТДЕЛЬНО
        const assignees = await new Promise((resolve, reject) => {
            db.all(`
                SELECT ta.user_id, u.name as user_name, u.login as user_login, u.email
                FROM task_assignments ta
                LEFT JOIN users u ON ta.user_id = u.id
                WHERE ta.task_id = ?
            `, [taskId], (err, rows) => {
                if (err) reject(err);
                else resolve(rows || []);
            });
        });

        // Собираем всех участников
        const participants = [];
        if (creator) {
            participants.push({
                ...creator,
                role: 'creator',
                is_creator: true
            });
        }
        
        if (assignees && assignees.length > 0) {
            assignees.forEach(assignee => {
                participants.push({
                    ...assignee,
                    role: 'assignee',
                    is_creator: false
                });
            });
        }

        // Получаем информацию об авторе действия
        const author = await new Promise((resolve, reject) => {
            db.get("SELECT name, login FROM users WHERE id = ?", [authorId], (err, row) => {
                if (err) reject(err);
                else resolve(row);
            });
        });

        const authorName = author ? author.name : 'Система';
        const authorLogin = author ? author.login : 'system';
        
        // Логируем в PostgreSQL
        const postgresLogIds = await logNotificationToPostgres({
            type,
            taskId,
            taskTitle,
            taskDescription,
            authorId,
            authorName,
            authorLogin,
            participants,
            comment,
            status,
            userName
        });

        let subject, content;

        switch (type) {
            case 'created':
                subject = `Новая задача: ${taskTitle}`;
                content = `Создана новая задача:\n\n` +
                         `📋 ${taskTitle}\n` +
                         `📝 ${taskDescription || 'Без описания'}\n` +
                         `👤 Автор: ${authorName}\n\n` +
                         `Для просмотра перейдите в систему управления задачами.`;
                break;

            case 'updated':
                subject = `Обновлена задача: ${taskTitle}`;
                content = `Задача была обновлена:\n\n` +
                         `📋 ${taskTitle}\n` +
                         `📝 ${taskDescription || 'Без описания'}\n` +
                         `👤 Изменено: ${authorName}\n\n` +
                         `Для просмотра изменений перейдите в систему управления задачами.`;
                break;

            case 'rework':
                subject = `Задача возвращена на доработку: ${taskTitle}`;
                content = `Задача возвращена на доработку:\n\n` +
                         `📋 ${taskTitle}\n` +
                         `📝 Комментарий: ${comment}\n` +
                         `👤 Автор замечания: ${authorName}\n\n` +
                         `Пожалуйста, исправьте замечания и обновите статус задачи.`;
                break;

            case 'closed':
                subject = `Задача закрыта: ${taskTitle}`;
                content = `Задача была закрыта:\n\n` +
                         `📋 ${taskTitle}\n` +
                         `👤 Закрыта: ${authorName}\n\n` +
                         `Задача завершена и перемещена в архив.`;
                break;

            case 'status_changed':
                const statusText = getStatusText(status);
                subject = `Изменен статус задачи: ${taskTitle}`;
                content = `Статус задачи изменен:\n\n` +
                         `📋 ${taskTitle}\n` +
                         `🔄 Новый статус: ${statusText}\n` +
                         `👤 Изменил: ${userName || authorName}\n\n` +
                         `Для просмотра перейдите в систему управления задачами.`;
                break;

            default:
                console.log(`⚠️ Неизвестный тип уведомления: ${type}`);
                return;
        }

        // Фильтруем получателей: исключаем автора действия
        const recipientIds = participants
            .filter(p => {
                const shouldExclude = p.user_id === authorId;
                if (shouldExclude) {
                    console.log(`   ✋ Исключаем автора действия: ${p.user_name} (ID: ${p.user_id})`);
                }
                return !shouldExclude;
            })
            .map(p => p.user_id);

        if (recipientIds.length === 0) {
            console.log('❌ Нет получателей для уведомления (все участники - автор изменения)');
            
            // Обновляем статус в PostgreSQL
            await updatePostgresLogStatus(postgresLogIds, 'no_recipients', 'Нет получателей после фильтрации');
            return;
        }

        const authHeader = encodeBasicAuth(
            process.env.NOTIFICATION_SERVICE_LOGIN,
            process.env.NOTIFICATION_SERVICE_PASSWORD
        );

        const FormData = require('form-data');
        const formData = new FormData();
        formData.append('subject', subject);
        formData.append('content', content);
        formData.append('recipients', JSON.stringify(recipientIds));
        formData.append('deliveryMethods', JSON.stringify(['email', 'telegram', 'vk']));

        console.log(`🚀 Отправляем запрос на сервис уведомлений...`);

        try {
            const response = await fetch(process.env.NOTIFICATION_SERVICE_URL, {
                method: 'POST',
                headers: {
                    'Authorization': `Basic ${authHeader}`
                },
                body: formData
            });

            if (!response.ok) {
                throw new Error(`HTTP error! status: ${response.status}`);
            }

            const result = await response.json();
            console.log(`✅ Уведомления успешно отправлены для задачи ${taskId}`);
            
            // Обновляем статус в PostgreSQL
            await updatePostgresLogStatus(postgresLogIds, 'sent', null, new Date().toISOString());
            
            console.log(`   Результат от сервиса:`, result);

        } catch (error) {
            console.error('❌ Ошибка отправки уведомлений:', error);
            
            // Обновляем статус в PostgreSQL
            await updatePostgresLogStatus(postgresLogIds, 'failed', error.message);
            
            console.error('   Детали ошибки:', {
                taskId,
                type,
                authorId,
                errorMessage: error.message,
                stack: error.stack
            });
        }

    } catch (error) {
        console.error('❌ Общая ошибка при обработке уведомлений:', error);
    }
}

// Вспомогательные функции для работы с PostgreSQL
async function logNotificationToPostgres(data) {
    try {
        const {
            type,
            taskId,
            taskTitle,
            taskDescription,
            authorId,
            authorName,
            authorLogin,
            participants = [],
            comment = '',
            status = '',
            userName = '',
            error = ''
        } = data;

        // Создаем сообщение
        let messageContent = '';
        switch (type) {
            case 'created':
                messageContent = `Создана новая задача: ${taskTitle}`;
                break;
            case 'updated':
                messageContent = `Обновлена задача: ${taskTitle}`;
                break;
            case 'rework':
                messageContent = `Задача возвращена на доработку: ${taskTitle}. Комментарий: ${comment}`;
                break;
            case 'closed':
                messageContent = `Задача закрыта: ${taskTitle}`;
                break;
            case 'status_changed':
                messageContent = `Изменен статус задачи: ${taskTitle}. Новый статус: ${getStatusText(status)}`;
                break;
        }

        // Логируем для каждого получателя отдельно
        const recipientsToNotify = participants.filter(p => p.user_id !== authorId);
        const logIds = [];

        for (const recipient of recipientsToNotify) {
            const logId = await postgresLogger.logNotification({
                taskId,
                taskTitle,
                taskDescription,
                notificationType: type,
                authorId,
                authorName,
                authorLogin,
                recipientId: recipient.user_id,
                recipientName: recipient.user_name,
                recipientLogin: recipient.user_login,
                messageContent: `${messageContent}\n\nЗадача: ${taskTitle}\nОписание: ${taskDescription || 'Без описания'}\nАвтор: ${authorName}`,
                messageSubject: getNotificationSubject(type, taskTitle),
                deliveryMethods: ['email', 'telegram', 'vk'],
                comments: error ? `Ошибка: ${error}` : comment
            });

            if (logId) {
                logIds.push(logId);
            }
        }

        return logIds;

    } catch (error) {
        console.error('❌ Ошибка логирования в PostgreSQL:', error);
        return [];
    }
}

async function updatePostgresLogStatus(logIds, status, errorMessage = null, sentAt = null) {
    if (!logIds || logIds.length === 0) return;

    for (const logId of logIds) {
        await postgresLogger.updateNotificationStatus(logId, status, errorMessage, sentAt);
    }
}

function getNotificationSubject(type, taskTitle) {
    switch (type) {
        case 'created':
            return `Новая задача: ${taskTitle}`;
        case 'updated':
            return `Обновлена задача: ${taskTitle}`;
        case 'rework':
            return `Задача возвращена на доработку: ${taskTitle}`;
        case 'closed':
            return `Задача закрыта: ${taskTitle}`;
        case 'status_changed':
            return `Изменен статус задачи: ${taskTitle}`;
        default:
            return `Уведомление по задаче: ${taskTitle}`;
    }
}

function getStatusText(status) {
    const statusMap = {
        'assigned': 'Назначена',
        'in_progress': 'В работе',
        'completed': 'Завершена',
        'overdue': 'Просрочена',
        'rework': 'На доработке'
    };
    return statusMap[status] || status;
}

app.post('/api/login', async (req, res) => {
    const { login, password } = req.body;

    if (!login || !password) {
        return res.status(400).json({ error: 'Логин и пароль обязательны' });
    }

    try {
        const user = await authService.authenticate(login, password);
        if (user) {
            const sessionUser = {
                id: user.id,
                login: user.login,
                name: user.name,
                email: user.email,
                role: user.role,
                auth_type: user.auth_type,
                groups: user.groups ? (typeof user.groups === 'string' ? JSON.parse(user.groups) : user.groups) : []
            };

            req.session.user = sessionUser;
            
            req.session.save((err) => {
                if (err) {
                    console.error('Ошибка сохранения сессии:', err);
                    return res.status(500).json({ error: 'Ошибка сохранения сессии' });
                }

                console.log(`Успешная авторизация: ${user.name} (${user.login}) через ${user.auth_type}`);
                if (user.groups) {
                    console.log(`Группы пользователя: ${user.groups}`);
                }
                
                res.json({ 
                    success: true, 
                    user: sessionUser
                });
            });
        } else {
            console.log(`Неудачная попытка входа: ${login}`);
            res.status(401).json({ error: 'Неверный логин или пароль' });
        }
    } catch (error) {
        console.error('Ошибка аутентификации:', error);
        res.status(500).json({ error: 'Ошибка сервера при авторизации' });
    }
});

app.post('/api/logout', (req, res) => {
    req.session.destroy((err) => {
        if (err) {
            console.error('Ошибка при выходе:', err);
            return res.status(500).json({ error: 'Ошибка при выходе' });
        }
        res.json({ success: true });
    });
});

app.get('/api/user', (req, res) => {
    if (req.session.user) {
        if (req.session.user.auth_type === 'ldap') {
            db.get("SELECT groups FROM users WHERE id = ?", [req.session.user.id], (err, user) => {
                if (err || !user) {
                    req.session.destroy();
                    return res.status(401).json({ error: 'Пользователь не найден' });
                }
                
                let groups = [];
                try {
                    groups = JSON.parse(user.groups || '[]');
                } catch (e) {
                    groups = [];
                }
                
                const allowedGroups = process.env.ALLOWED_GROUPS ? 
                    process.env.ALLOWED_GROUPS.split(',').map(g => g.trim()) : [];
                
                const isAdmin = groups.some(group => allowedGroups.includes(group));
                const actualRole = isAdmin ? 'admin' : 'teacher';
                
                if (req.session.user.role !== actualRole) {
                    console.log(`Обновлена роль пользователя ${req.session.user.login} с ${req.session.user.role} на ${actualRole}`);
                    
                    db.run(
                        "UPDATE users SET role = ?, updated_at = datetime('now') WHERE id = ?",
                        [actualRole, req.session.user.id]
                    );
                    
                    req.session.user.role = actualRole;
                }
                
                res.json({ user: req.session.user });
            });
        } else {
            res.json({ user: req.session.user });
        }
    } else {
        res.status(401).json({ error: 'Не аутентифицирован' });
    }
});

app.get('/api/users', requireAuth, (req, res) => {
    const search = req.query.search || '';
    
    let query = `
        SELECT id, login, name, email, role, auth_type 
        FROM users 
        WHERE role IN ('admin', 'teacher') 
    `;
    
    const params = [];
    
    if (search) {
        query += ` AND (login LIKE ? OR name LIKE ? OR email LIKE ?)`;
        const searchPattern = `%${search}%`;
        params.push(searchPattern, searchPattern, searchPattern);
    }
    
    query += " ORDER BY name";
    
    db.all(query, params, (err, rows) => {
        if (err) {
            res.status(500).json({ error: err.message });
            return;
        }
        res.json(rows);
    });
});

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 || '';

    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 (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";

    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);
        });
    });
});

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);
        });
    });
});

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;

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

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

    db.serialize(() => {
        const startDate = new Date().toISOString();
        
        db.run(
            "INSERT INTO tasks (title, description, created_by, original_task_id, start_date, due_date) VALUES (?, ?, ?, ?, ?, ?)",
            [title, description, createdBy, originalTaskId || null, startDate, dueDate || null],
            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) VALUES (?, ?, ?, ?, ?, ?)",
                    [newTitle, originalTask.description, createdBy, taskId, startDate, dueDate || null],
                    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 FROM tasks WHERE id = ? AND status = 'active'", [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.serialize(() => {
            db.run(
                "UPDATE tasks SET title = ?, description = ?, due_date = ?, updated_at = CURRENT_TIMESTAMP WHERE id = ?",
                [title, description, dueDate || null, 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, 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) {
                        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 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.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 (req.session.user.role !== 'admin' && task.created_by !== currentUserId) {
            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 FROM tasks WHERE id = ? AND status = 'active'", [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 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: 'Статус обновлен' });
                }
            );
        });
    });
});

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

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, message: 'Файлы успешно загружены' });
    });
});

app.get('/api/tasks/:taskId/files', 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.all(`
            SELECT tf.*, u.name as user_name, u.login as user_login
            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, files) => {
            if (err) {
                res.status(500).json({ error: err.message });
                return;
            }
            res.json(files);
        });
    });
});

app.get('/api/files/:fileId/download', requireAuth, (req, res) => {
    const { fileId } = req.params;
    const userId = req.session.user.id;

    db.get("SELECT tf.*, t.id as task_id FROM task_files tf JOIN tasks t ON tf.task_id = t.id WHERE tf.id = ?", [fileId], (err, file) => {
        if (err || !file) {
            return res.status(404).json({ error: 'Файл не найдена' });
        }

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

            if (!fs.existsSync(file.file_path)) {
                return res.status(404).json({ error: 'Файл не найден на сервере' });
            }

            // Исправляем кодировку имени файла
            let decodedFileName = file.original_name;
            
            // Пробуем декодировать если это UTF-8 в Latin-1 (для старых записей)
            try {
                if (/^[A-Za-z0-9\.\-_]+$/.test(decodedFileName)) {
                    // Если имя содержит только латинские символы, оставляем как есть
                } else if (decodedFileName.includes('Ð') || decodedFileName.includes('Ñ')) {
                    // Исправляем неправильно декодированную кириллицу
                    decodedFileName = Buffer.from(decodedFileName, 'binary').toString('utf8');
                }
            } catch (e) {
                console.error('Ошибка декодирования имени файла:', e);
            }
            
            // Кодируем имя файла для безопасной передачи
            const encodedFileName = encodeURIComponent(decodedFileName);
            
            // Устанавливаем заголовки для скачивания
            res.setHeader('Content-Disposition', `attachment; filename*=UTF-8''${encodedFileName}`);
            res.setHeader('Content-Type', 'application/octet-stream');
            
            // Отправляем файл
            res.sendFile(file.file_path);
        });
    });
});

app.get('/api/activity-logs', requireAuth, (req, res) => {
    const userId = req.session.user.id;
    
    let query = `
        SELECT al.*, u.name as user_name, t.title as task_title
        FROM activity_logs al
        LEFT JOIN users u ON al.user_id = u.id
        LEFT JOIN tasks t ON al.task_id = t.id
        WHERE 1=1
    `;

    if (req.session.user.role !== 'admin') {
        query += ` AND (t.created_by = ${userId} OR al.task_id IN (
            SELECT task_id FROM task_assignments WHERE user_id = ${userId}
        ))`;
    }

    query += " ORDER BY al.created_at DESC LIMIT 100";

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

app.get('/admin', (req, res) => {
    if (!req.session.user || req.session.user.role !== 'admin') {
        return res.status(403).send('Доступ запрещен');
    }
    res.sendFile(path.join(__dirname, 'public/admin.html'));
});
// API для получения логов уведомлений
app.get('/api/notification-logs', requireAuth, async (req, res) => {
    try {
        const { 
            taskId, 
            status, 
            startDate, 
            endDate, 
            limit = 50, 
            offset = 0 
        } = req.query;

        const logs = await postgresLogger.getNotifications({
            taskId: taskId ? parseInt(taskId) : null,
            userId: req.session.user.id,
            status,
            startDate,
            endDate,
            limit: parseInt(limit),
            offset: parseInt(offset)
        });

        res.json(logs);
    } catch (error) {
        console.error('Ошибка получения логов уведомлений:', error);
        res.status(500).json({ error: 'Ошибка получения логов' });
    }
});

// API для получения статистики
app.get('/api/notification-stats', requireAuth, async (req, res) => {
    try {
        const { period = 'day' } = req.query;
        
        if (req.session.user.role !== 'admin') {
            return res.status(403).json({ error: 'Недостаточно прав' });
        }

        const stats = await postgresLogger.getStatistics(period);
        res.json(stats);
    } catch (error) {
        console.error('Ошибка получения статистики:', error);
        res.status(500).json({ error: 'Ошибка получения статистики' });
    }
});

// API для проверки состояния PostgreSQL
app.get('/api/postgres-health', requireAuth, async (req, res) => {
    try {
        if (req.session.user.role !== 'admin') {
            return res.status(403).json({ error: 'Недостаточно прав' });
        }

        const health = await postgresLogger.healthCheck();
        res.json(health);
    } catch (error) {
        res.status(500).json({ error: error.message });
    }
});
app.listen(PORT, () => {
    console.log(`CRM сервер запущен на порту ${PORT}`);
    console.log(`Откройте http://localhost:${PORT} в браузере`);
    console.log('Данные хранятся в папке:', path.join(__dirname, 'data'));
    console.log('Тестовые пользователи:');
    console.log('- Логин: director, Пароль: director123 (Администратор)');
    console.log('- Логин: zavuch, Пароль: zavuch123');
    console.log('- Логин: teacher, Пароль: teacher123');
    console.log('LDAP авторизация доступна для пользователей школы');
    console.log(`Разрешенные группы: ${process.env.ALLOWED_GROUPS}`);
    console.log('Система уведомлений активна');
    
    setInterval(checkOverdueTasks, 60000);
    setInterval(checkUpcomingDeadlines, 60000);
});