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

const user_db_name = "cocos_users";

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

/**
 * 设置出战英雄
 * @param {Object} db 数据库实例
 * @param {string} openid 用户openid
 * @param {number} position 出战位置 (0-4)
 * @param {number} heroId 英雄ID，0表示移除
 * @returns {Object} 操作结果
 */
async function setFightHero(db, openid, position, heroId) {
  try {
    const _ = db.command;
    let user = await getOrCreaterUser(db, openid);
    if (!user) {
      return {
        code: -4,
        msg: "未找到用户"
      };
    }
    
    // 验证位置参数
    if (position < 0 || position > 4) {
      return {
        code: -3,
        msg: "无效的位置，必须是0-4"
      };
    }
    
    // 验证英雄ID
    if (typeof heroId !== 'number' || heroId < 0) {
      return {
        code: -3,
        msg: "无效的英雄ID"
      };
    }
    
    // 如果不是移除操作，检查英雄是否存在
    if (heroId > 0 && !user.heros[heroId]) {
      return {
        code: -6,
        msg: "未拥有该英雄"
      };
    }
    
    const oldHeroId = user.fight_heros[position];
    
    let updateRes = await db.collection(user_db_name).doc(user._id).update({
      data: {
        [`fight_heros.${position}`]: _.set(heroId),
        last_save_time: _.set(Date.now())
      }
    });

    if (updateRes?.stats?.updated >= 1) {
      return {
        code: 200,
        data: {
          position: position,
          old_hero_id: oldHeroId,
          new_hero_id: heroId
        },
        msg: `出战英雄位置 ${position} 更新成功`
      };
    } else {
      return {
        code: -1,
        msg: `设置出战英雄失败`
      };
    }
  } catch (error) {
    console.error("设置出战英雄错误:", error);
    return {
      code: -5,
      msg: `设置出战英雄错误: ${error.message}`
    };
  }
}

/**
 * 批量设置出战英雄
 * @param {Object} db 数据库实例
 * @param {string} openid 用户openid
 * @param {Object} fightHeros 出战英雄配置对象
 * @returns {Object} 操作结果
 */
async function updateFightHeros(db, openid, fightHeros) {
  try {
    const _ = db.command;
    let user = await getOrCreaterUser(db, openid);
    if (!user) {
      return {
        code: -4,
        msg: "未找到用户"
      };
    }
    
    // 验证数据格式
    if (!fightHeros || typeof fightHeros !== 'object') {
      return {
        code: -3,
        msg: "无效的出战英雄数据格式"
      };
    }
    
    // 验证每个位置和英雄ID
    for (const pos in fightHeros) {
      const position = parseInt(pos);
      const heroId = fightHeros[pos];
      
      if (isNaN(position) || position < 0 || position > 4) {
        return {
          code: -3,
          msg: `无效的位置: ${pos}`
        };
      }
      
      if (typeof heroId !== 'number' || heroId < 0) {
        return {
          code: -3,
          msg: `位置 ${pos} 的英雄ID无效: ${heroId}`
        };
      }
      
      // 如果不是移除操作，检查英雄是否存在
      if (heroId > 0 && !user.heros[heroId]) {
        return {
          code: -6,
          msg: `位置 ${pos} 未拥有英雄 ${heroId}`
        };
      }
    }
    
    const newFightHeros = { ...user.fight_heros, ...fightHeros };
    
    let updateRes = await db.collection(user_db_name).doc(user._id).update({
      data: {
        fight_heros: _.set(newFightHeros),
        last_save_time: _.set(Date.now())
      }
    });

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

/**
 * 获取当前出战英雄列表（不包含空位）
 * @param {Object} db 数据库实例
 * @param {string} openid 用户openid
 * @returns {Object} 操作结果
 */
async function getActiveFightHeros(db, openid) {
  try {
    let user = await getOrCreaterUser(db, openid);
    if (!user) {
      return {
        code: -4,
        msg: "未找到用户"
      };
    }
    
    const activeHeros = [];
    for (let i = 0; i < 5; i++) {
      const heroId = user.fight_heros[i];
      if (heroId && heroId > 0) {
        activeHeros.push({
          position: i,
          hero_id: heroId,
          hero_data: user.heros[heroId] || null
        });
      }
    }
    
    return {
      code: 200,
      data: {
        active_heros: activeHeros,
        total_count: activeHeros.length
      },
      msg: "获取活跃出战英雄成功"
    };
  } catch (error) {
    console.error("获取活跃出战英雄错误:", error);
    return {
      code: -5,
      msg: `获取活跃出战英雄错误: ${error.message}`
    };
  }
}

/**
 * 交换两个出战位置的英雄
 * @param {Object} db 数据库实例
 * @param {string} openid 用户openid
 * @param {number} position1 位置1 (0-4)
 * @param {number} position2 位置2 (0-4)
 * @returns {Object} 操作结果
 */
async function swapFightHeros(db, openid, position1, position2) {
  try {
    const _ = db.command;
    let user = await getOrCreaterUser(db, openid);
    if (!user) {
      return {
        code: -4,
        msg: "未找到用户"
      };
    }
    
    // 验证位置参数
    if (position1 < 0 || position1 > 4 || position2 < 0 || position2 > 4) {
      return {
        code: -3,
        msg: "无效的位置，必须是0-4"
      };
    }
    
    if (position1 === position2) {
      return {
        code: -3,
        msg: "不能交换相同位置"
      };
    }
    
    const hero1 = user.fight_heros[position1];
    const hero2 = user.fight_heros[position2];
    
    let updateRes = await db.collection(user_db_name).doc(user._id).update({
      data: {
        [`fight_heros.${position1}`]: _.set(hero2),
        [`fight_heros.${position2}`]: _.set(hero1),
        last_save_time: _.set(Date.now())
      }
    });

    if (updateRes?.stats?.updated >= 1) {
      return {
        code: 200,
        data: {
          position1: position1,
          position2: position2,
          hero1_moved_to: hero1,
          hero2_moved_to: hero2
        },
        msg: `出战英雄交换成功`
      };
    } else {
      return {
        code: -1,
        msg: `交换出战英雄失败`
      };
    }
  } catch (error) {
    console.error("交换出战英雄错误:", error);
    return {
      code: -5,
      msg: `交换出战英雄错误: ${error.message}`
    };
  }
}

/**
 * 重置出战英雄配置
 * @param {Object} db 数据库实例
 * @param {string} openid 用户openid
 * @returns {Object} 操作结果
 */
async function resetFightHeros(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: {
        fight_heros: _.set(defaultData.fight_heros),
        last_save_time: _.set(Date.now()),
        reset_time: _.set(Date.now())
      }
    });

    if (resetRes?.stats?.updated >= 1) {
      return {
        code: 200,
        data: defaultData.fight_heros,
        msg: "出战英雄重置成功"
      };
    } else {
      return {
        code: -1,
        msg: `重置失败, ${JSON.stringify(resetRes)}`
      };
    }
  } catch (error) {
    console.error("重置出战英雄错误:", error);
    return {
      code: -5,
      msg: `重置出战英雄错误: ${error.message}`
    };
  }
}

module.exports = {
  getFightHeros,
  setFightHero,
  updateFightHeros,
  getActiveFightHeros,
  swapFightHeros,
  resetFightHeros
};