/**
 * 菜单管理控制器
 * @file menuController.js
 * @description 处理菜单管理相关的请求
 */

const { MenuPermission, Role } = require('../models');
const { Op } = require('sequelize');
const logger = require('../utils/logger');

/**
 * 获取所有菜单
 * @param {Object} req - 请求对象
 * @param {Object} res - 响应对象
 */
exports.getAllMenus = async (req, res) => {
  try {
    // 设置禁用缓存的响应头
    res.setHeader('Cache-Control', 'no-cache, no-store, must-revalidate');
    res.setHeader('Pragma', 'no-cache');
    res.setHeader('Expires', '0');
    
    const { page = 1, pageSize = 10, search = '' } = req.query;
    const offset = (page - 1) * pageSize;
    const limit = parseInt(pageSize);

    // 构建查询条件
    const whereCondition = {};
    if (search) {
      whereCondition[Op.or] = [
        { menu_name: { [Op.like]: `%${search}%` } },
        { menu_path: { [Op.like]: `%${search}%` } }
      ];
    }

    const { count, rows } = await MenuPermission.findAndCountAll({
      where: whereCondition,
      order: [['sort_order', 'ASC'], ['id', 'ASC']],
      offset,
      limit
    });

    res.status(200).json({
      success: true,
      data: {
        list: rows,
        pagination: {
          current: parseInt(page),
          pageSize: limit,
          total: count,
          pages: Math.ceil(count / limit)
        }
      },
      message: '获取菜单列表成功'
    });
  } catch (error) {
    console.error('获取菜单列表失败:', error);
    res.status(500).json({
      success: false,
      message: '获取菜单列表失败',
      error: error.message
    });
  }
};

/**
 * 获取菜单详情
 * @param {Object} req - 请求对象
 * @param {Object} res - 响应对象
 */
exports.getMenuById = async (req, res) => {
  try {
    const { id } = req.params;
    const menu = await MenuPermission.findByPk(id);

    if (!menu) {
      return res.status(404).json({
        success: false,
        message: '菜单不存在'
      });
    }

    res.status(200).json({
      success: true,
      data: menu,
      message: '获取菜单详情成功'
    });
  } catch (error) {
    console.error('获取菜单详情失败:', error);
    res.status(500).json({
      success: false,
      message: '获取菜单详情失败',
      error: error.message
    });
  }
};

/**
 * 创建菜单
 * @param {Object} req - 请求对象
 * @param {Object} res - 响应对象
 */
exports.createMenu = async (req, res) => {
  try {
    const menuData = req.body;
    const menu = await MenuPermission.create(menuData);

    res.status(201).json({
      success: true,
      data: menu,
      message: '菜单创建成功'
    });
  } catch (error) {
    console.error('创建菜单失败:', error);
    res.status(500).json({
      success: false,
      message: '创建菜单失败',
      error: error.message
    });
  }
};

/**
 * 更新菜单
 * @param {Object} req - 请求对象
 * @param {Object} res - 响应对象
 */
exports.updateMenu = async (req, res) => {
  try {
    const { id } = req.params;
    const updateData = req.body;

    const menu = await MenuPermission.findByPk(id);
    if (!menu) {
      return res.status(404).json({
        success: false,
        message: '菜单不存在'
      });
    }

    await menu.update(updateData);

    res.status(200).json({
      success: true,
      data: menu,
      message: '菜单更新成功'
    });
  } catch (error) {
    console.error('更新菜单失败:', error);
    res.status(500).json({
      success: false,
      message: '更新菜单失败',
      error: error.message
    });
  }
};

/**
 * 删除菜单
 * @param {Object} req - 请求对象
 * @param {Object} res - 响应对象
 */
exports.deleteMenu = async (req, res) => {
  try {
    const { id } = req.params;

    const menu = await MenuPermission.findByPk(id);
    if (!menu) {
      return res.status(404).json({
        success: false,
        message: '菜单不存在'
      });
    }

    await menu.destroy();

    res.status(200).json({
      success: true,
      message: '菜单删除成功'
    });
  } catch (error) {
    console.error('删除菜单失败:', error);
    res.status(500).json({
      success: false,
      message: '删除菜单失败',
      error: error.message
    });
  }
};

/**
 * 获取角色的菜单权限
 * @param {Object} req - 请求对象
 * @param {Object} res - 响应对象
 */
exports.getRoleMenus = async (req, res) => {
  try {
    const { roleId } = req.params;

    const role = await Role.findByPk(roleId);
    if (!role) {
      return res.status(404).json({
        success: false,
        message: '角色不存在'
      });
    }

    // 获取角色的菜单权限
    const menus = await role.getMenuPermissions({
      order: [['sort_order', 'ASC'], ['id', 'ASC']]
    });

    res.status(200).json({
      success: true,
      data: menus,
      message: '获取角色菜单权限成功'
    });
  } catch (error) {
    console.error('获取角色菜单权限失败:', error);
    res.status(500).json({
      success: false,
      message: '获取角色菜单权限失败',
      error: error.message
    });
  }
};

/**
 * 设置角色的菜单权限
 * @param {Object} req - 请求对象
 * @param {Object} res - 响应对象
 */
exports.setRoleMenus = async (req, res) => {
  try {
    const { roleId } = req.params;
    const { menuIds } = req.body;

    const role = await Role.findByPk(roleId);
    if (!role) {
      return res.status(404).json({
        success: false,
        message: '角色不存在'
      });
    }

    // 设置菜单权限
    await role.setMenuPermissions(menuIds || []);

    res.status(200).json({
      success: true,
      message: '设置角色菜单权限成功'
    });
  } catch (error) {
    console.error('设置角色菜单权限失败:', error);
    res.status(500).json({
      success: false,
      message: '设置角色菜单权限失败',
      error: error.message
    });
  }
};