server.js

require('dotenv').config();
const express = require('express');
const path = require('path');
const cookieParser = require("cookie-parser");
const session = require('./middleware/sessionConfig.js'); // Сессии вынесены в отдельный файл
const { engine } = require('express-handlebars');

/* const helpers = require('./helpers/handlebarsHelpers');  */
const authRoutes = require('./routes/authRoutes'); // Роуты для аутентификации
const viewRoutes = require('./routes/viewRoutes'); // Роуты для рендеринга страниц
const likesRoutes = require('./routes/likesRoutes'); // Подключаем лайки для ленты новостей
const settingsRoutes = require('./routes/settingsRoutes'); // Подключаем лайки для ленты новостей
const chatRoutes = require('./routes/chatRoutes');




const app = express();

app.use(cookieParser(process.env.SECRET_KEY));

const helpers = {
    formatDate: function(dateString) {
        const date = new Date(dateString);
        return date.toLocaleString('ru-RU');
    },
    isEqual: function(a, b) {
        return a === b;
    }
};
// Настройка Handlebars
app.engine('handlebars', engine({
    extname: 'handlebars',
    partialsDir: 'views/partials/',
    defaultLayout: null,
    helpers: helpers
  }));
app.set('view engine', 'handlebars');


const Handlebars = require('handlebars');

Handlebars.registerHelper('truncate', function(str, length) {
    if (!str) return '';  // Если строка пустая или undefined, возвращаем пустую строку
    if (str.length > length) {
        return str.substring(0, length) + '...';
    }
    return str;
});
// Подключаем статику
app.use(express.static(path.join(__dirname, 'frontend')));
app.use('/files', express.static(path.join(__dirname, 'post_files')));


// Поддержка JSON и URL-encoded данных
app.use(express.json());
app.use(express.urlencoded({ extended: true }));

// Подключаем сессии
app.use(session);

// Подключаем маршруты
app.use(authRoutes);
app.use(viewRoutes);
app.use(settingsRoutes);
app.use(likesRoutes);
app.use(chatRoutes);

const statsRouter = require('./routes/statsRoutes.js');
app.use(statsRouter);

// Подключаем маршрут поиска
const searchRoute = require('./routes/search');
app.use(searchRoute);

// Запуск сервера
const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
    console.log(`Сервер запущен на порту ${PORT}`);
});

// index - UPDATE LATER

const mysql = require('mysql2/promise');

// Создаем подключение к базе данных
// Создаем пул соединений с поддержкой промисов
const pool = mysql.createPool({
    host: process.env.DB_HOST,
    user: process.env.DB_USER, 
    password: process.env.DB_PASSWORD, 
    database: process.env.DB_NAME,
    queueLimit: 5
});

app.get('/api/posts', async (req, res) => {
    const { offset = 0, limit = 10, search } = req.query;
    const userId = req.session.user ? req.session.user.id : null; 
    const userRole = req.session.user ? req.session.user.role_id : null;

    try {
        let query = `
            SELECT 
                p.id, 
                p.content, 
                p.created_at, 
                p.status_id, 
                p.group_id, 
                p.user_id, 
                u.username, 
                u.avatar_path, 
                u.id as user_id,
                g.name as group_name
            FROM Posts p 
            JOIN Users u ON p.user_id = u.id 
            LEFT JOIN UserGroups g ON p.group_id = g.id
            WHERE (p.status_id = 1 OR p.status_id IS NULL) 
        `;

        // Если есть параметр поиска, добавляем условия поиска
        if (search) {
            // Экранируем специальные символы для LIKE
            const searchTerm = search.replace(/[%_]/g, '\\$&');
            query += ` AND (p.content LIKE '%${searchTerm}%' OR u.username LIKE '%${searchTerm}%')`;
        }

        // Если пользователь авторизован, добавляем возможность видеть свои посты со статусом 2
        if (userId) {
            query += ` OR (p.status_id = 2 AND p.user_id = ${userId})`;
        }

        // Если пользователь админ (role_id = 3), добавляем возможность видеть все посты
        if (userRole === 3) {
            query = `
                SELECT 
                    p.id, 
                    p.content, 
                    p.created_at, 
                    p.status_id, 
                    p.group_id, 
                    p.user_id, 
                    u.username, 
                    u.avatar_path, 
                    u.id as user_id,
                    g.name as group_name
                FROM Posts p 
                JOIN Users u ON p.user_id = u.id 
                LEFT JOIN UserGroups g ON p.group_id = g.id
            `;
            
            // Если есть параметр поиска и пользователь админ
            if (search) {
                const searchTerm = search.replace(/[%_]/g, '\\$&');
                query += ` WHERE (p.content LIKE '%${searchTerm}%' OR u.username LIKE '%${searchTerm}%')`;
            }
        }

        query += ` ORDER BY p.created_at DESC LIMIT ? OFFSET ?`;

        const [posts] = await pool.query(query, [Number(limit), Number(offset)]);

        // Остальной код обработки постов остается без изменений
        for (let post of posts) {
            // Получаем медиафайлы
            const [files] = await pool.query(
                `SELECT file_path, file_type 
                 FROM PostFiles 
                 WHERE post_id = ?`, 
                [post.id]
            );
            post.files = files.map(file => ({
                url: `/files/${file.file_path.split('/').pop()}`,
                type: file.file_type
            }));

            // Подсчет всех реакций
            const [reactions] = await pool.query(
                `SELECT reaction_type, COUNT(*) AS count 
                 FROM PostReactions 
                 WHERE post_id = ? 
                 GROUP BY reaction_type`, 
                [post.id]
            );

            const reactionCount = reactions.reduce((acc, reaction) => {
                if (reaction.reaction_type === 'like') acc.likes = reaction.count;
                if (reaction.reaction_type === 'dislike') acc.dislikes = reaction.count;
                return acc;
            }, { likes: 0, dislikes: 0 });

            post.likes = reactionCount.likes;
            post.dislikes = reactionCount.dislikes;

            // Получаем реакцию текущего пользователя (если залогинен)
            if (userId) {
                const [userReaction] = await pool.query(
                    `SELECT reaction_type 
                     FROM PostReactions 
                     WHERE post_id = ? AND user_id = ? 
                     LIMIT 1`, 
                    [post.id, userId]
                );

                post.userReaction = userReaction.length > 0 ? userReaction[0].reaction_type : null;
            } else {
                post.userReaction = null;
            }
        }

        res.json(posts);
    } catch (err) {
        console.error(err);
        res.status(500).json({ error: 'Ошибка при получении постов' });
    }
});


// Изменение статуса поста
app.put('/api/posts/:postId/status', async (req, res) => {
    const { postId } = req.params;
    const { status_id } = req.body;
    const userId = req.session.user?.id;
    const userRole = req.session.user?.role_id;

    if (!userId) {
        return res.status(401).json({ error: 'Необходима авторизация' });
    }

    try {
        // Получаем информацию о посте
        const [post] = await pool.query(
            'SELECT user_id, status_id FROM Posts WHERE id = ?', 
            [postId]
        );

        if (post.length === 0) {
            return res.status(404).json({ error: 'Пост не найден' });
        }

        const currentPost = post[0];
        
        // Проверяем права пользователя
        const isOwner = currentPost.user_id === userId;
        const isModerator = userRole === 2;
        const isAdmin = userRole === 3;
        
        // Владелец может менять статус своего поста
        // Модератор и админ могут менять статус любого поста
        if (!isOwner && !isModerator && !isAdmin) {
            return res.status(403).json({ error: 'Недостаточно прав' });
        }

        // Проверяем, что новый статус валиден
        if (status_id !== 1 && status_id !== 2) {
            return res.status(400).json({ error: 'Некорректный статус' });
        }

        // Обновляем статус
        await pool.query(
            'UPDATE Posts SET status_id = ? WHERE id = ?', 
            [status_id, postId]
        );

        res.json({ 
            message: 'Статус поста обновлен',
            newStatus: status_id
        });

    } catch (err) {
        console.error('Ошибка при изменении статуса:', err);
        res.status(500).json({ error: 'Ошибка сервера' });
    }
});

app.delete('/api/posts/:postId', async (req, res) => {
    const { postId } = req.params;
    const userId = req.session.user?.id;
    const userRole = req.session.user?.role_id;

    if (!userId) {
        return res.status(401).json({ error: 'Необходима авторизация' });
    }

    try {
        // Получаем информацию о посте
        const [post] = await pool.query(
            'SELECT user_id FROM Posts WHERE id = ?', 
            [postId]
        );

        if (post.length === 0) {
            return res.status(404).json({ error: 'Пост не найден' });
        }

        const isOwner = post[0].user_id === userId;
        const isModerator = userRole === 2;
        const isAdmin = userRole === 3;

        // Проверяем права:
        // - Владелец может удалить свой пост
        // - Модератор и админ могут удалить любой пост
        if (!isOwner && !isModerator && !isAdmin) {
            return res.status(403).json({ error: 'Недостаточно прав для удаления поста' });
        }

        // Удаляем связанные данные в правильном порядке
        await pool.query('DELETE FROM PostReactions WHERE post_id = ?', [postId]);
        await pool.query('DELETE FROM Comments WHERE post_id = ?', [postId]);
        await pool.query('DELETE FROM PostFiles WHERE post_id = ?', [postId]);
        
        // Удаляем сам пост
        await pool.query('DELETE FROM Posts WHERE id = ?', [postId]);

        res.json({ 
            success: true,
            message: 'Пост успешно удалён'
        });

    } catch (err) {
        console.error('Ошибка при удалении поста:', err);
        res.status(500).json({ error: 'Ошибка сервера при удалении поста' });
    }
});
/////////////////////////////////////////////////



app.get('/api/posts/:postId/comments', async (req, res) => {
    const { postId } = req.params;
    const userId = req.session.user ? req.session.user.id : null;
    const userRole = req.session.user ? req.session.user.role_id : null;

    try {
        const [comments] = await pool.query(
            `SELECT c.id, c.content, c.created_at, u.username, u.id as user_id, u.avatar_path
             FROM Comments c 
             JOIN Users u ON c.user_id = u.id 
             WHERE c.post_id = ? 
             ORDER BY c.created_at ASC`, 
            [postId]
        );

        // Добавляем флаг canDelete для каждого комментария
        const commentsWithDeleteFlag = comments.map(c => ({
            ...c,
            canDelete: userId === c.user_id || userRole === 3 || userRole === 2
        }));

        res.json(commentsWithDeleteFlag);
    } catch (err) {
        console.error(err);
        res.status(500).json({ error: 'Ошибка загрузки комментариев' });
    }
});

app.post('/api/posts/:postId/comments', async (req, res) => {
    const userId = req.session.user ? req.session.user.id : null;
    if (!userId) return res.status(401).json({ error: 'Вы не авторизованы' });

    const { postId } = req.params;
    const { content } = req.body;
    if (!content) return res.status(400).json({ error: 'Комментарий не может быть пустым' });

    try {
        await pool.query(
            `INSERT INTO Comments (post_id, user_id, content, created_at)
             VALUES (?, ?, ?, NOW())`, 
            [postId, userId, content]
        );
        res.json({ message: 'Комментарий добавлен' });
    } catch (err) {
        console.error(err);
        res.status(500).json({ error: 'Ошибка при добавлении комментария' });
    }
});


app.delete('/api/comments/:commentId', async (req, res) => {
    const userId = req.session.user ? req.session.user.id : null;
    const userRole = req.session.user ? req.session.user.role_id : null;
    if (!userId) return res.status(401).json({ error: 'Вы не авторизованы' });

    const { commentId } = req.params;

    try {
        // Проверяем, может ли пользователь удалить этот комментарий
        const [comment] = await pool.query(
            `SELECT user_id FROM Comments WHERE id = ?`, 
            [commentId]
        );
        
        if (comment.length === 0) {
            return res.status(404).json({ error: 'Комментарий не найден' });
        }

        const isOwner = comment[0].user_id === userId;
        const isAdminOrModerator = userRole === 3 || userRole === 2;

        if (!isOwner && !isAdminOrModerator) {
            return res.status(403).json({ error: 'У вас нет прав для удаления этого комментария' });
        }

        // Удаляем комментарий
        await pool.query(
            `DELETE FROM Comments WHERE id = ?`, 
            [commentId]
        );
        
        res.json({ message: 'Комментарий удален' });
    } catch (err) {
        console.error(err);
        res.status(500).json({ error: 'Ошибка при удалении комментария' });
    }
});