// 英雄数据操作模块
const { getOrCreaterUser } = require('./auth');

const user_db_name = "cocos_users";

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

/**
 * 获取单个英雄数据
 * @param {Object} db 数据库实例
 * @param {string} openid 用户openid
 * @param {number} heroId 英雄ID
 * @returns {Object} 操作结果
 */
async function getHero(db, openid, heroId) {
  try {
    let user = await getOrCreaterUser(db, openid);
    if (!user) {
      return {
        code: -4,
        msg: "未找到用户"
      };
    }
    
    const hero = user.heros[heroId];
    if (!hero) {
      return {
        code: -6,
        msg: "未找到英雄"
      };
    }
    
    return {
      code: 200,
      data: hero,
      msg: "获取英雄成功"
    };
  } catch (error) {
    console.error("获取英雄错误:", error);
    return {
      code: -5,
      msg: `获取英雄错误: ${error.message}`
    };
  }
}

/**
 * 添加新英雄
 * @param {Object} db 数据库实例
 * @param {string} openid 用户openid
 * @param {number} heroId 英雄ID
 * @param {Object} heroData 英雄数据（可选）
 * @returns {Object} 操作结果
 */
async function addHero(db, openid, heroId, heroData = null) {
  try {
    const _ = db.command;
    let user = await getOrCreaterUser(db, openid);
    if (!user) {
      return {
        code: -4,
        msg: "未找到用户"
      };
    }
    
    // 检查英雄是否已存在
    if (user.heros[heroId]) {
      return {
        code: -7,
        msg: "英雄已存在"
      };
    }
    
    // 使用提供的数据或默认数据
    const newHero = heroData || {
      uuid: heroId,
      lv: 1,
      exp: 0,
      star: 1,
      power: 100
    };
    
    // 确保uuid字段正确
    newHero.uuid = heroId;
    
    let updateRes = await db.collection(user_db_name).doc(user._id).update({
      data: {
        [`heros.${heroId}`]: _.set(newHero),
        last_save_time: _.set(Date.now())
      }
    });

    if (updateRes?.stats?.updated >= 1) {
      return {
        code: 200,
        data: newHero,
        msg: `英雄 ${heroId} 添加成功`
      };
    } else {
      return {
        code: -1,
        msg: `添加英雄失败`
      };
    }
  } catch (error) {
    console.error("添加英雄错误:", error);
    return {
      code: -5,
      msg: `添加英雄错误: ${error.message}`
    };
  }
}

/**
 * 更新英雄属性
 * @param {Object} db 数据库实例
 * @param {string} openid 用户openid
 * @param {number} heroId 英雄ID
 * @param {Object} updateData 要更新的属性
 * @returns {Object} 操作结果
 */
async function updateHero(db, openid, heroId, updateData) {
  try {
    const _ = db.command;
    let user = await getOrCreaterUser(db, openid);
    if (!user) {
      return {
        code: -4,
        msg: "未找到用户"
      };
    }
    
    // 检查英雄是否存在
    if (!user.heros[heroId]) {
      return {
        code: -6,
        msg: "未找到英雄"
      };
    }
    
    // 验证更新数据
    if (!updateData || typeof updateData !== 'object') {
      return {
        code: -3,
        msg: "无效的更新数据格式"
      };
    }
    
    const currentHero = user.heros[heroId];
    const newHero = { ...currentHero, ...updateData };
    
    // 确保uuid字段不被修改
    newHero.uuid = heroId;
    
    let updateRes = await db.collection(user_db_name).doc(user._id).update({
      data: {
        [`heros.${heroId}`]: _.set(newHero),
        last_save_time: _.set(Date.now())
      }
    });

    if (updateRes?.stats?.updated >= 1) {
      return {
        code: 200,
        data: {
          old_data: currentHero,
          new_data: newHero
        },
        msg: `英雄 ${heroId} 更新成功`
      };
    } else {
      return {
        code: -1,
        msg: `更新英雄失败`
      };
    }
  } catch (error) {
    console.error("更新英雄错误:", error);
    return {
      code: -5,
      msg: `更新英雄错误: ${error.message}`
    };
  }
}

/**
 * 设置英雄属性
 * @param {Object} db 数据库实例
 * @param {string} openid 用户openid
 * @param {number} heroId 英雄ID
 * @param {string} property 属性名
 * @param {any} value 属性值
 * @returns {Object} 操作结果
 */
async function setHeroProperty(db, openid, heroId, property, value) {
  try {
    const _ = db.command;
    let user = await getOrCreaterUser(db, openid);
    if (!user) {
      return {
        code: -4,
        msg: "未找到用户"
      };
    }
    
    // 检查英雄是否存在
    if (!user.heros[heroId]) {
      return {
        code: -6,
        msg: "未找到英雄"
      };
    }
    
    // 防止修改uuid
    if (property === 'uuid') {
      return {
        code: -3,
        msg: "不可修改英雄UUID"
      };
    }
    
    const oldValue = user.heros[heroId][property];
    
    let updateRes = await db.collection(user_db_name).doc(user._id).update({
      data: {
        [`heros.${heroId}.${property}`]: _.set(value),
        last_save_time: _.set(Date.now())
      }
    });

    if (updateRes?.stats?.updated >= 1) {
      return {
        code: 200,
        data: {
          hero_id: heroId,
          property: property,
          old_value: oldValue,
          new_value: value
        },
        msg: `英雄 ${heroId} 属性 ${property} 更新成功`
      };
    } else {
      return {
        code: -1,
        msg: `设置英雄属性失败`
      };
    }
  } catch (error) {
    console.error("设置英雄属性错误:", error);
    return {
      code: -5,
      msg: `设置英雄属性错误: ${error.message}`
    };
  }
}

/**
 * 英雄升级
 * @param {Object} db 数据库实例
 * @param {string} openid 用户openid
 * @param {number} heroId 英雄ID
 * @param {number} levels 升级级数（默认1级）
 * @returns {Object} 操作结果
 */
async function levelUpHero(db, openid, heroId, exp,gold,levels = 1) {
  try {
    let user = await getOrCreaterUser(db, openid);
    if (!user) {
      return {
        code: -4,
        msg: "未找到用户"
      };
    }
    
    // 检查英雄是否存在
    if (!user.heros[heroId]) {
      return {
        code: -6,
        msg: "未找到英雄"
      };
    }
    
    if (typeof levels !== 'number' || levels < 1) {
      return {
        code: -3,
        msg: "等级必须为正数"
      };
    }
    let result=await spendDataField(db, openid, {'exp':exp,'gold':gold});
    if(result.code!==200){
      return {
        code: -1,
        msg: `升级失败，${result.msg}`
      };
    }
    const currentLevel = user.heros[heroId].lv || 1;
    const newLevel = currentLevel + levels;
    return await setHeroProperty(db, openid, heroId, 'lv', newLevel);
  } catch (error) {
    console.error("英雄升级错误:", error);
    return {
      code: -5,
      msg: `英雄升级错误: ${error.message}`
    };
  }
}

/**
 * 删除英雄
 * @param {Object} db 数据库实例
 * @param {string} openid 用户openid
 * @param {number} heroId 英雄ID
 * @returns {Object} 操作结果
 */
async function deleteHero(db, openid, heroId) {
  try {
    const _ = db.command;
    let user = await getOrCreaterUser(db, openid);
    if (!user) {
      return {
        code: -4,
        msg: "未找到用户"
      };
    }
    
    // 检查英雄是否存在
    if (!user.heros[heroId]) {
      return {
        code: -6,
        msg: "未找到英雄"
      };
    }
    
    // 检查英雄是否在出战阵容中
    for (let pos = 0; pos < 5; pos++) {
      if (user.fight_heros[pos] === heroId) {
        return {
          code: -8,
          msg: `英雄位于出战位置 ${pos}，请先从出战阵容移除`
        };
      }
    }
    
    const deletedHero = user.heros[heroId];
    
    let updateRes = await db.collection(user_db_name).doc(user._id).update({
      data: {
        [`heros.${heroId}`]: _.remove(),
        last_save_time: _.set(Date.now())
      }
    });

    if (updateRes?.stats?.updated >= 1) {
      return {
        code: 200,
        data: deletedHero,
        msg: `英雄 ${heroId} 删除成功`
      };
    } else {
      return {
        code: -1,
        msg: `删除英雄失败`
      };
    }
  } catch (error) {
    console.error("删除英雄错误:", error);
    return {
      code: -5,
      msg: `删除英雄错误: ${error.message}`
    };
  }
}

/**
 * 获取已拥有的英雄ID列表
 * @param {Object} db 数据库实例
 * @param {string} openid 用户openid
 * @returns {Object} 操作结果
 */
async function getOwnedHeroIds(db, openid) {
  try {
    let user = await getOrCreaterUser(db, openid);
    if (!user) {
      return {
        code: -4,
        msg: "未找到用户"
      };
    }
    
    const heroIds = Object.keys(user.heros).map(Number);
    
    return {
      code: 200,
      data: {
        hero_ids: heroIds,
        total_count: heroIds.length
      },
      msg: "获取已拥有英雄ID成功"
    };
  } catch (error) {
    console.error("获取已拥有英雄ID错误:", error);
    return {
      code: -5,
      msg: `获取已拥有英雄ID错误: ${error.message}`
    };
  }
}

module.exports = {
  getHeros,
  getHero,
  addHero,
  updateHero,
  setHeroProperty,
  levelUpHero,
  deleteHero,
  getOwnedHeroIds
};