const express = require('express');
const router = express.Router();
const { ensureAuthenticated, ensureAdmin } = require('../../middleware/auth');
const User = require('../../models/User');
const Category = require('../../models/Category');
const Post = require('../../models/Post');
const Comment = require('../../models/Comment');
const Link = require('../../models/Link');
const { paginateQuery } = require('../../utils/pagination');


// 后台管理首页
router.get('/', ensureAuthenticated, ensureAdmin, (req, res) => {
    res.render('admin/index', {
        user: req.user,
        template: 'index'
    });
});

// 用户管理路由
router.get('/users', ensureAuthenticated, ensureAdmin, async (req, res) => {
    try {
        // 获取分页参数
        const page = parseInt(req.query.page) || 1;
        const limit = 10; // 每页显示10个用户

        // 获取用户（带分页）
        const usersResult = await paginateQuery(
            User,
            {},
            { sort: { createdAt: -1 } },
            page,
            limit
        );

        res.render('admin/index', {
            user: req.user,
            template: 'users/list',
            users: usersResult.data,
            pagination: usersResult.pagination,
            baseUrl: '/admin/users',
            query: {}
        });
    } catch (error) {
        console.error('获取用户列表失败:', error);
        res.status(500).send('服务器错误');
    }
});

// 分类管理路由
router.get('/categories', ensureAuthenticated, ensureAdmin, async (req, res) => {
    const categories = await Category.find().sort({ order: 1 });
    res.render('admin/index', {
        user: req.user,
        template: 'categories/list',
        categories
    });
});

// 获取分类列表API - 供前端使用
router.get('/api/categories', ensureAuthenticated, ensureAdmin, async (req, res) => {
    try {
        const categories = await Category.find().sort({ order: 1 });
        res.json(categories);
    } catch (err) {
        console.error(err);
        res.status(500).json({ error: '获取分类失败' });
    }
});



// 文章管理路由
router.get('/posts', ensureAuthenticated, ensureAdmin, async (req, res) => {
    try {
        // 获取分页参数
        const page = parseInt(req.query.page) || 1;
        const limit = 10; // 每页显示10篇文章
        // 获取文章（带分页）
        const postsResult = await paginateQuery(
            Post,
            {},
            {
                populate: 'category author',
                sort: { createdAt: -1 }
            },
            page,
            limit
        );
        res.render('admin/index', {
            user: req.user,
            template: 'posts/list',
            posts: postsResult.data,
            pagination: postsResult.pagination,
            baseUrl: '/admin/posts',
            query: {}
        });
    } catch (error) {
        console.error('获取文章列表失败:', error);
        res.status(500).send('服务器错误');
    }
});

// 创建文章 - POST
router.post('/posts', ensureAuthenticated, ensureAdmin, async (req, res) => {
    try {
        const { title, content, category, author, isPublished, isTop } = req.body;
        const newPost = new Post({
            title,
            content,
            category,
            author,
            isPublished: isPublished === 'on' || isPublished === true,
            isTop: isTop === 'on' || isTop === true
        });
        await newPost.save();
        res.json({ success: true, post: newPost });
    } catch (err) {
        console.error(err);
        res.status(500).json({ success: false, message: '创建文章失败' });
    }
});

// 更新文章 - PUT
router.put('/posts/:id', ensureAuthenticated, ensureAdmin, async (req, res) => {
    try {
        const { title, content, category, author, isPublished, isTop } = req.body;
        const updatedPost = await Post.findByIdAndUpdate(
            req.params.id,
            {
                title,
                content,
                category,
                author,
                isPublished: isPublished === 'on' || isPublished === true,
                isTop: isTop === 'on' || isTop === true,
                updatedAt: Date.now()
            },
            { new: true }
        );

        if (!updatedPost) {
            return res.status(404).json({ success: false, message: '文章未找到' });
        }

        res.json({ success: true, post: updatedPost });
    } catch (err) {
        console.error(err);
        res.status(500).json({ success: false, message: '更新文章失败' });
    }
});

// 删除文章 - DELETE
router.delete('/posts/:id', ensureAuthenticated, ensureAdmin, async (req, res) => {
    try {
        const deletedPost = await Post.findByIdAndDelete(req.params.id);

        if (!deletedPost) {
            return res.status(404).json({ success: false, message: '文章未找到' });
        }

        // 同时删除相关评论
        await Comment.deleteMany({ post: req.params.id });

        res.json({ success: true });
    } catch (err) {
        console.error(err);
        res.status(500).json({ success: false, message: '删除文章失败' });
    }
});

// 设置/取消置顶 - PUT
router.put('/posts/:id/top', ensureAuthenticated, ensureAdmin, async (req, res) => {
    try {
        const { isTop } = req.body;

        const updatedPost = await Post.findByIdAndUpdate(
            req.params.id,
            { isTop },
            { new: true }
        );

        if (!updatedPost) {
            return res.status(404).json({ success: false, message: '文章未找到' });
        }

        res.json({ success: true, post: updatedPost });
    } catch (err) {
        console.error(err);
        res.status(500).json({ success: false, message: '操作失败' });
    }
});
// 发布/取消发布 - PUT
router.put('/posts/:id/publish', ensureAuthenticated, ensureAdmin, async (req, res) => {
    try {
        const { isPublished } = req.body;

        const updatedPost = await Post.findByIdAndUpdate(
            req.params.id,
            { isPublished },
            { new: true }
        );

        if (!updatedPost) {
            return res.status(404).json({ success: false, message: '文章未找到' });
        }

        res.json({ success: true, post: updatedPost });
    } catch (err) {
        console.error(err);
        res.status(500).json({ success: false, message: '操作失败' });
    }
});

// 获取单篇文章详情 - GET
router.get('/posts/:id', ensureAuthenticated, ensureAdmin, async (req, res) => {
    try {
        const post = await Post.findById(req.params.id);
        if (!post) {
            return res.status(404).json({ success: false, message: '文章未找到' });
        }
        res.json(post);
    } catch (err) {
        console.error(err);
        res.status(500).json({ success: false, message: '获取文章信息失败' });
    }
});

// 评论管理路由
router.get('/comments', ensureAuthenticated, ensureAdmin, async (req, res) => {
    try {
        // 获取分页参数
        const page = parseInt(req.query.page) || 1;
        const limit = 10; // 每页显示10条评论
        // 获取评论（带分页）
        const commentsResult = await paginateQuery(
            Comment,
            {},
            {
                populate: 'author post',
                sort: { createdAt: -1 }
            },
            page,
            limit
        );

        res.render('admin/index', {
            user: req.user,
            template: 'comments/list',
            comments: commentsResult.data,
            pagination: commentsResult.pagination,
            baseUrl: '/admin/comments',
            query: {}
        });
    } catch (error) {
        console.error('获取评论列表失败:', error);
        res.status(500).send('服务器错误');
    }
});

// 友情链接路由
router.get('/links', ensureAuthenticated, ensureAdmin, async (req, res) => {
    try {
        // 获取分页参数
        const page = parseInt(req.query.page) || 1;
        const limit = 10; // 每页显示10条链接

        // 获取友情链接（带分页）
        const linksResult = await paginateQuery(
            Link,
            {},
            {
                sort: { order: 1 }
            },
            page,
            limit
        );

        res.render('admin/index', {
            user: req.user,
            template: 'links/list',
            links: linksResult.data,
            pagination: linksResult.pagination,
            baseUrl: '/admin/links',
            query: {}
        });
    } catch (error) {
        console.error('获取友情链接列表失败:', error);
        res.status(500).send('服务器错误');
    }
});

// 添加友情链接 - POST
router.post('/links', ensureAuthenticated, ensureAdmin, async (req, res) => {
    try {
        const { name, url, description, order } = req.body;

        const newLink = new Link({
            name,
            url,
            description: description || '',
            order: order || 0
        });

        await newLink.save();
        res.json({ success: true, link: newLink });
    } catch (err) {
        console.error(err);
        res.status(500).json({ success: false, message: '添加友情链接失败' });
    }
});

// 更新友情链接 - PUT
router.put('/links/:id', ensureAuthenticated, ensureAdmin, async (req, res) => {
    try {
        const { name, url, description, order } = req.body;

        const updatedLink = await Link.findByIdAndUpdate(
            req.params.id,
            {
                name,
                url,
                description: description || '',
                order: order || 0
            },
            { new: true }
        );

        if (!updatedLink) {
            return res.status(404).json({ success: false, message: '友情链接未找到' });
        }

        res.json({ success: true, link: updatedLink });
    } catch (err) {
        console.error(err);
        res.status(500).json({ success: false, message: '更新友情链接失败' });
    }
});

// 删除友情链接 - DELETE
router.delete('/links/:id', ensureAuthenticated, ensureAdmin, async (req, res) => {
    try {
        const deletedLink = await Link.findByIdAndDelete(req.params.id);

        if (!deletedLink) {
            return res.status(404).json({ success: false, message: '友情链接未找到' });
        }

        res.json({ success: true });
    } catch (err) {
        console.error(err);
        res.status(500).json({ success: false, message: '删除友情链接失败' });
    }
});

module.exports = router;