// 通用库存操作模块 (items, tals, equips)
// 现在作为统一接口，调用各个独立模块
const itemsModule = require('./items');
const talsModule = require('./tals');
const equipsModule = require('./equips');

// 支持的数据类型
const SUPPORTED_TYPES = ['items', 'tals', 'equips'];

/**
 * 验证数据类型
 * @param {string} dataType 数据类型
 * @returns {boolean} 是否有效
 */
function validateDataType(dataType) {
  return SUPPORTED_TYPES.includes(dataType);
}

/**
 * 根据数据类型获取对应的模块
 * @param {string} dataType 数据类型
 * @returns {Object} 对应的模块
 */
function getModuleByType(dataType) {
  switch(dataType) {
    case 'items':
      return itemsModule;
    case 'tals':
      return talsModule;
    case 'equips':
      return equipsModule;
    default:
      return null;
  }
}

/**
 * 获取库存数据
 * @param {Object} db 数据库实例
 * @param {string} openid 用户openid
 * @param {string} dataType 数据类型 ('items', 'tals', 'equips')
 * @returns {Object} 操作结果
 */
async function getInventory(db, openid, dataType) {
  if (!validateDataType(dataType)) {
    return {
      code: -3,
      msg: `无效的数据类型: ${dataType}`
    };
  }
  
  const module = getModuleByType(dataType);
  switch(dataType) {
    case 'items':
      return await module.getItems(db, openid);
    case 'tals':
      return await module.getTals(db, openid);
    case 'equips':
      return await module.getEquips(db, openid);
    default:
      return {
        code: -3,
        msg: `无效的数据类型: ${dataType}`
      };
  }
}

/**
 * 获取单个物品数据
 * @param {Object} db 数据库实例
 * @param {string} openid 用户openid
 * @param {string} dataType 数据类型
 * @param {number} itemId 物品ID
 * @returns {Object} 操作结果
 */
async function getInventoryItem(db, openid, dataType, itemId) {
  if (!validateDataType(dataType)) {
    return {
      code: -3,
      msg: `无效的数据类型: ${dataType}`
    };
  }
  
  const module = getModuleByType(dataType);
  switch(dataType) {
    case 'items':
      return await module.getItem(db, openid, itemId);
    case 'tals':
      return await module.getTal(db, openid, itemId);
    case 'equips':
      return await module.getEquip(db, openid, itemId);
    default:
      return {
        code: -3,
        msg: `无效的数据类型: ${dataType}`
      };
  }
}

/**
 * 添加物品
 * @param {Object} db 数据库实例
 * @param {string} openid 用户openid
 * @param {string} dataType 数据类型
 * @param {number} itemId 物品ID
 * @param {number} count 添加数量
 * @returns {Object} 操作结果
 */
async function addInventoryItem(db, openid, dataType, itemId, count) {
  if (!validateDataType(dataType)) {
    return {
      code: -3,
      msg: `无效的数据类型: ${dataType}`
    };
  }
  
  const module = getModuleByType(dataType);
  switch(dataType) {
    case 'items':
      return await module.addItem(db, openid, itemId, count);
    case 'tals':
      return await module.addTal(db, openid, itemId, count);
    case 'equips':
      return await module.addEquip(db, openid, itemId, count);
    default:
      return {
        code: -3,
        msg: `无效的数据类型: ${dataType}`
      };
  }
}

/**
 * 消耗物品
 * @param {Object} db 数据库实例
 * @param {string} openid 用户openid
 * @param {string} dataType 数据类型
 * @param {number} itemId 物品ID
 * @param {number} count 消耗数量
 * @returns {Object} 操作结果
 */
async function consumeInventoryItem(db, openid, dataType, itemId, count) {
  if (!validateDataType(dataType)) {
    return {
      code: -3,
      msg: `无效的数据类型: ${dataType}`
    };
  }
  
  const module = getModuleByType(dataType);
  switch(dataType) {
    case 'items':
      return await module.consumeItem(db, openid, itemId, count);
    case 'tals':
      return await module.consumeTal(db, openid, itemId, count);
    case 'equips':
      return await module.consumeEquip(db, openid, itemId, count);
    default:
      return {
        code: -3,
        msg: `无效的数据类型: ${dataType}`
      };
  }
}

/**
 * 设置物品数量
 * @param {Object} db 数据库实例
 * @param {string} openid 用户openid
 * @param {string} dataType 数据类型
 * @param {number} itemId 物品ID
 * @param {number} count 新的数量
 * @returns {Object} 操作结果
 */
async function setInventoryItem(db, openid, dataType, itemId, count) {
  if (!validateDataType(dataType)) {
    return {
      code: -3,
      msg: `无效的数据类型: ${dataType}`
    };
  }
  
  const module = getModuleByType(dataType);
  switch(dataType) {
    case 'items':
      return await module.setItem(db, openid, itemId, count);
    case 'tals':
      return await module.setTal(db, openid, itemId, count);
    case 'equips':
      return await module.setEquip(db, openid, itemId, count);
    default:
      return {
        code: -3,
        msg: `无效的数据类型: ${dataType}`
      };
  }
}

/**
 * 批量更新库存
 * @param {Object} db 数据库实例
 * @param {string} openid 用户openid
 * @param {string} dataType 数据类型
 * @param {Object} updateData 更新数据对象
 * @param {boolean} merge 是否合并更新（默认true）
 * @returns {Object} 操作结果
 */
async function updateInventory(db, openid, dataType, updateData, merge = true) {
  if (!validateDataType(dataType)) {
    return {
      code: -3,
      msg: `无效的数据类型: ${dataType}`
    };
  }
  
  const module = getModuleByType(dataType);
  switch(dataType) {
    case 'items':
      return await module.updateItems(db, openid, updateData, merge);
    case 'tals':
      return await module.updateTals(db, openid, updateData, merge);
    case 'equips':
      return await module.updateEquips(db, openid, updateData, merge);
    default:
      return {
        code: -3,
        msg: `无效的数据类型: ${dataType}`
      };
  }
}

/**
 * 重置库存数据
 * @param {Object} db 数据库实例
 * @param {string} openid 用户openid
 * @param {string} dataType 数据类型
 * @returns {Object} 操作结果
 */
async function resetInventory(db, openid, dataType) {
  if (!validateDataType(dataType)) {
    return {
      code: -3,
      msg: `无效的数据类型: ${dataType}`
    };
  }
  
  const module = getModuleByType(dataType);
  switch(dataType) {
    case 'items':
      return await module.resetItems(db, openid);
    case 'tals':
      return await module.resetTals(db, openid);
    case 'equips':
      return await module.resetEquips(db, openid);
    default:
      return {
        code: -3,
        msg: `无效的数据类型: ${dataType}`
      };
  }
}

/**
 * 获取拥有的物品列表（数量大于0的）
 * @param {Object} db 数据库实例
 * @param {string} openid 用户openid
 * @param {string} dataType 数据类型
 * @returns {Object} 操作结果
 */
async function getOwnedItems(db, openid, dataType) {
  if (!validateDataType(dataType)) {
    return {
      code: -3,
      msg: `无效的数据类型: ${dataType}`
    };
  }
  
  const module = getModuleByType(dataType);
  switch(dataType) {
    case 'items':
      return await module.getOwnedItems(db, openid);
    case 'tals':
      return await module.getOwnedTals(db, openid);
    case 'equips':
      return await module.getOwnedEquips(db, openid);
    default:
      return {
        code: -3,
        msg: `无效的数据类型: ${dataType}`
      };
  }
}

module.exports = {
  getInventory,
  getInventoryItem,
  addInventoryItem,
  consumeInventoryItem,
  setInventoryItem,
  updateInventory,
  resetInventory,
  getOwnedItems,
  SUPPORTED_TYPES
};