// 天赋库存操作模块 (tals)
const { getOrCreaterUser } = require('./auth');

const user_db_name = "cocos_users";
const DATA_TYPE = 'tals';

/**
 * 获取天赋库存数据
 * @param {Object} db 数据库实例
 * @param {string} openid 用户openid
 * @returns {Object} 操作结果
 */
async function getTals(db, openid) {
  try {
    let user = await getOrCreaterUser(db, openid);
    if (!user) {
      return {
        code: -4,
        msg: "未找到用户"
      };
    }
    
    return {
      code: 200,
      data: user[DATA_TYPE],
      msg: `${DATA_TYPE}获取成功`
    };
  } catch (error) {
    console.error(`获取${DATA_TYPE}错误:`, error);
    return {
      code: -5,
      msg: `获取${DATA_TYPE}错误: ${error.message}`
    };
  }
}

/**
 * 获取单个天赋数据
 * @param {Object} db 数据库实例
 * @param {string} openid 用户openid
 * @param {number} talId 天赋ID
 * @returns {Object} 操作结果
 */
async function getTal(db, openid, talId) {
  try {
    let user = await getOrCreaterUser(db, openid);
    if (!user) {
      return {
        code: -4,
        msg: "未找到用户"
      };
    }
    
    const talCount = user[DATA_TYPE][talId];
    if (talCount === undefined) {
      return {
        code: -6,
        msg: `${DATA_TYPE.slice(0, -1)} ${talId} 未找到`
      };
    }
    
    return {
      code: 200,
      data: {
        item_id: talId,
        count: talCount
      },
      msg: `${DATA_TYPE.slice(0, -1)} ${talId} 获取成功`
    };
  } catch (error) {
    console.error(`获取${DATA_TYPE}物品错误:`, error);
    return {
      code: -5,
      msg: `获取${DATA_TYPE}物品错误: ${error.message}`
    };
  }
}

/**
 * 添加天赋
 * @param {Object} db 数据库实例
 * @param {string} openid 用户openid
 * @param {number} talId 天赋ID
 * @param {number} count 添加数量
 * @returns {Object} 操作结果
 */
async function addTal(db, openid, talId, count) {
  try {
    const _ = db.command;
    let user = await getOrCreaterUser(db, openid);
    if (!user) {
      return {
        code: -4,
        msg: "未找到用户"
      };
    }
    
    if (typeof count !== 'number' || count < 0) {
      return {
        code: -3,
        msg: "数量必须是非负数"
      };
    }
    
    const currentCount = user[DATA_TYPE][talId] || 0;
    const newCount = currentCount + count;
    
    let updateRes = await db.collection(user_db_name).doc(user._id).update({
      data: {
        [`${DATA_TYPE}.${talId}`]: _.set(newCount),
        last_save_time: _.set(Date.now())
      }
    });

    if (updateRes?.stats?.updated >= 1) {
      return {
        code: 200,
        data: {
          item_id: talId,
          old_count: currentCount,
          new_count: newCount,
          added: count
        },
        msg: `${DATA_TYPE.slice(0, -1)} ${talId} 添加成功`
      };
    } else {
      return {
        code: -1,
        msg: `添加 ${DATA_TYPE.slice(0, -1)} 失败`
      };
    }
  } catch (error) {
    console.error(`添加${DATA_TYPE}物品错误:`, error);
    return {
      code: -5,
      msg: `添加${DATA_TYPE}物品错误: ${error.message}`
    };
  }
}

/**
 * 消耗天赋
 * @param {Object} db 数据库实例
 * @param {string} openid 用户openid
 * @param {number} talId 天赋ID
 * @param {number} count 消耗数量
 * @returns {Object} 操作结果
 */
async function consumeTal(db, openid, talId, count) {
  try {
    let user = await getOrCreaterUser(db, openid);
    if (!user) {
      return {
        code: -4,
        msg: "未找到用户"
      };
    }
    
    if (typeof count !== 'number' || count < 0) {
      return {
        code: -3,
        msg: "数量必须是非负数"
      };
    }
    
    const currentCount = user[DATA_TYPE][talId] || 0;
    if (currentCount < count) {
      return {
        code: -6,
        msg: `${DATA_TYPE.slice(0, -1)} ${talId}不足, 当前: ${currentCount}, 需要: ${count}`
      };
    }
    
    return await addTal(db, openid, talId, -count);
  } catch (error) {
    console.error(`消耗${DATA_TYPE}物品错误:`, error);
    return {
      code: -5,
      msg: `消耗${DATA_TYPE}物品错误: ${error.message}`
    };
  }
}

/**
 * 设置天赋数量
 * @param {Object} db 数据库实例
 * @param {string} openid 用户openid
 * @param {number} talId 天赋ID
 * @param {number} count 新的数量
 * @returns {Object} 操作结果
 */
async function setTal(db, openid, talId, count) {
  try {
    const _ = db.command;
    let user = await getOrCreaterUser(db, openid);
    if (!user) {
      return {
        code: -4,
        msg: "未找到用户"
      };
    }
    
    if (typeof count !== 'number' || count < 0) {
      return {
        code: -3,
        msg: "数量必须是非负数"
      };
    }
    
    const oldCount = user[DATA_TYPE][talId] || 0;
    
    let updateRes = await db.collection(user_db_name).doc(user._id).update({
      data: {
        [`${DATA_TYPE}.${talId}`]: _.set(count),
        last_save_time: _.set(Date.now())
      }
    });

    if (updateRes?.stats?.updated >= 1) {
      return {
        code: 200,
        data: {
          item_id: talId,
          old_count: oldCount,
          new_count: count
        },
        msg: `${DATA_TYPE.slice(0, -1)} ${talId} 设置成功`
      };
    } else {
      return {
        code: -1,
        msg: `设置 ${DATA_TYPE.slice(0, -1)} 失败`
      };
    }
  } catch (error) {
    console.error(`设置${DATA_TYPE}物品错误:`, error);
    return {
      code: -5,
      msg: `设置${DATA_TYPE}物品错误: ${error.message}`
    };
  }
}

/**
 * 批量更新天赋库存
 * @param {Object} db 数据库实例
 * @param {string} openid 用户openid
 * @param {Object} updateData 更新数据对象
 * @param {boolean} merge 是否合并更新（默认true）
 * @returns {Object} 操作结果
 */
async function updateTals(db, openid, updateData, merge = true) {
  try {
    const _ = db.command;
    let user = await getOrCreaterUser(db, openid);
    if (!user) {
      return {
        code: -4,
        msg: "未找到用户"
      };
    }
    
    // 验证更新数据
    if (!updateData || typeof updateData !== 'object') {
      return {
        code: -3,
        msg: "无效的更新数据格式"
      };
    }
    
    // 验证所有值都是非负数
    for (const talId in updateData) {
      const count = updateData[talId];
      if (typeof count !== 'number' || count < 0) {
        return {
          code: -3,
          msg: `天赋 ${talId} 的数量无效: ${count}`
        };
      }
    }
    
    let newData;
    if (merge) {
      // 合并更新
      newData = { ...user[DATA_TYPE], ...updateData };
    } else {
      // 完全替换
      newData = updateData;
    }
    
    let updateRes = await db.collection(user_db_name).doc(user._id).update({
      data: {
        [DATA_TYPE]: _.set(newData),
        last_save_time: _.set(Date.now())
      }
    });

    if (updateRes?.stats?.updated >= 1) {
      return {
        code: 200,
        data: newData,
        msg: `${DATA_TYPE} 更新成功`
      };
    } else {
      return {
        code: -1,
        msg: `更新 ${DATA_TYPE} 失败`
      };
    }
  } catch (error) {
    console.error(`更新${DATA_TYPE}错误:`, error);
    return {
      code: -5,
      msg: `更新${DATA_TYPE}错误: ${error.message}`
    };
  }
}

/**
 * 重置天赋库存数据
 * @param {Object} db 数据库实例
 * @param {string} openid 用户openid
 * @returns {Object} 操作结果
 */
async function resetTals(db, openid) {
  try {
    const _ = db.command;
    const { getNewUserInitData } = require('../user_init_data');
    let user = await getOrCreaterUser(db, openid);
    if (!user) {
      return {
        code: -4,
        msg: "未找到用户"
      };
    }
    
    const defaultData = getNewUserInitData();
    
    let resetRes = await db.collection(user_db_name).doc(user._id).update({
      data: {
        [DATA_TYPE]: _.set(defaultData[DATA_TYPE]),
        last_save_time: _.set(Date.now()),
        reset_time: _.set(Date.now())
      }
    });

    if (resetRes?.stats?.updated >= 1) {
      return {
        code: 200,
        data: defaultData[DATA_TYPE],
        msg: `${DATA_TYPE} 重置成功`
      };
    } else {
      return {
        code: -1,
        msg: `重置 ${DATA_TYPE} 失败`
      };
    }
  } catch (error) {
    console.error(`重置${DATA_TYPE}错误:`, error);
    return {
      code: -5,
      msg: `重置${DATA_TYPE}错误: ${error.message}`
    };
  }
}

/**
 * 获取拥有的天赋列表（数量大于0的）
 * @param {Object} db 数据库实例
 * @param {string} openid 用户openid
 * @returns {Object} 操作结果
 */
async function getOwnedTals(db, openid) {
  try {
    let user = await getOrCreaterUser(db, openid);
    if (!user) {
      return {
        code: -4,
        msg: "未找到用户"
      };
    }
    
    const ownedTals = [];
    for (const talId in user[DATA_TYPE]) {
      const count = user[DATA_TYPE][talId];
      if (count > 0) {
        ownedTals.push({
          item_id: parseInt(talId),
          count: count
        });
      }
    }
    
    return {
      code: 200,
      data: {
        owned_items: ownedTals,
        total_types: ownedTals.length
      },
      msg: `拥有的${DATA_TYPE}获取成功`
    };
  } catch (error) {
    console.error(`获取拥有的${DATA_TYPE}错误:`, error);
    return {
      code: -5,
      msg: `获取拥有的${DATA_TYPE}错误: ${error.message}`
    };
  }
}

module.exports = {
  getTals,
  getTal,
  addTal,
  consumeTal,
  setTal,
  updateTals,
  resetTals,
  getOwnedTals
};