const { Setting, Category } = require('../models');
const { Op } = require('sequelize');
const response = require('../utils/response');

/**
 * 获取系统设置
 */
const getSettings = async (req, res) => {
  try {
    const tenantId = req.user.tenantId;
    
    const settings = await Setting.findAll({
      where: { tenantId }
    });
    
    // 转换为键值对格式
    const settingsMap = {};
    settings.forEach(setting => {
      settingsMap[setting.key] = setting.value;
    });
    
    // 设置默认值
    const defaultSettings = {
      expireReminderDays: '30',
      enableExpiredReminder: 'true',
      ...settingsMap
    };
    
    response.success(res, '获取成功', defaultSettings);
  } catch (error) {
    console.error('获取设置失败:', error);
    response.serverError(res, '获取设置失败', error);
  }
};

/**
 * 更新系统设置
 */
const updateSettings = async (req, res) => {
  try {
    const tenantId = req.user.tenantId;
    const userId = req.user.id;
    const settings = req.body;
    
    // 批量更新或创建设置
    for (const [key, value] of Object.entries(settings)) {
      if (key === 'id' || key === 'createTime' || key === 'updateTime') continue;
      
      const [setting, created] = await Setting.findOrCreate({
        where: { key, tenantId },
        defaults: {
          key,
          value: String(value),
          tenantId,
          createBy: userId,
          updateBy: userId
        }
      });
      
      if (!created) {
        await setting.update({
          value: String(value),
          updateBy: userId
        });
      }
    }
    
    response.success(res, '设置保存成功');
  } catch (error) {
    console.error('保存设置失败:', error);
    response.serverError(res, '保存设置失败', error);
  }
};

/**
 * 获取收支类目列表
 */
const getCategories = async (req, res) => {
  try {
    const tenantId = req.user.tenantId;
    const { type } = req.query;
    
    const where = { 
      tenantId,
      isDeleted: 0,
      status: 'active'
    };
    
    if (type) {
      where.type = type;
    }
    
    const categories = await Category.findAll({
      where,
      order: [['sort', 'ASC'], ['id', 'ASC']]
    });
    
    response.success(res, '获取成功', categories);
  } catch (error) {
    console.error('获取类目失败:', error);
    response.serverError(res, '获取类目失败', error);
  }
};

/**
 * 创建类目
 */
const createCategory = async (req, res) => {
  try {
    const tenantId = req.user.tenantId;
    const userId = req.user.id;
    const { name, code, type, sort } = req.body;
    
    // 检查编码是否已存在
    const existing = await Category.findOne({
      where: { code, tenantId, isDeleted: 0 }
    });
    
    if (existing) {
      return response.badRequest(res, '类目编码已存在');
    }
    
    const category = await Category.create({
      name,
      code,
      type,
      sort: sort || 0,
      tenantId,
      createBy: userId,
      updateBy: userId
    });
    
    response.success(res, '创建成功', category);
  } catch (error) {
    console.error('创建类目失败:', error);
    response.serverError(res, '创建类目失败', error);
  }
};

/**
 * 更新类目
 */
const updateCategory = async (req, res) => {
  try {
    const tenantId = req.user.tenantId;
    const userId = req.user.id;
    const { id } = req.params;
    const { name, code, type, sort, status } = req.body;
    
    const category = await Category.findOne({
      where: { id, tenantId, isDeleted: 0 }
    });
    
    if (!category) {
      return response.notFound(res, '类目不存在');
    }
    
    // 检查编码是否与其他类目冲突
    if (code && code !== category.code) {
      const existing = await Category.findOne({
        where: { code, tenantId, isDeleted: 0, id: { [Op.ne]: id } }
      });
      
      if (existing) {
        return response.badRequest(res, '类目编码已存在');
      }
    }
    
    await category.update({
      name: name || category.name,
      code: code || category.code,
      type: type || category.type,
      sort: sort !== undefined ? sort : category.sort,
      status: status || category.status,
      updateBy: userId
    });
    
    response.success(res, '更新成功', category);
  } catch (error) {
    console.error('更新类目失败:', error);
    response.serverError(res, '更新类目失败', error);
  }
};

/**
 * 删除类目
 */
const deleteCategory = async (req, res) => {
  try {
    const tenantId = req.user.tenantId;
    const userId = req.user.id;
    const { id } = req.params;
    
    const category = await Category.findOne({
      where: { id, tenantId, isDeleted: 0 }
    });
    
    if (!category) {
      return response.notFound(res, '类目不存在');
    }
    
    // 默认类目不允许删除
    if (category.isDefault) {
      return response.badRequest(res, '默认类目不能删除');
    }
    
    await category.update({
      isDeleted: 1,
      updateBy: userId
    });
    
    response.success(res, '删除成功');
  } catch (error) {
    console.error('删除类目失败:', error);
    response.serverError(res, '删除类目失败', error);
  }
};

module.exports = {
  getSettings,
  updateSettings,
  getCategories,
  createCategory,
  updateCategory,
  deleteCategory
};