// 云函数路由入口文件
const cloud = require('wx-server-sdk');

// 导入各个模块
const authModule = require('./modules/auth');
const gameDataModule = require('./modules/gameData');
const fightHerosModule = require('./modules/fightHeros');
const herosModule = require('./modules/heros');
const inventoryModule = require('./modules/inventory');
const responseModule = require('./modules/response');

cloud.init({ env: cloud.DYNAMIC_CURRENT_ENV }); // 使用当前云环境

// 云函数入口函数
exports.main = async (event, context) => {
  const startTime = Date.now();
  
  try {
    // 验证命令参数
    const validation = responseModule.validateRequiredParams(event, ['cmd']);
    if (validation) {
      return validation;
    }
    
    const { cmd, ...params } = event;
  const wxContext = cloud.getWXContext();
  const db = cloud.database({
    env: cloud.DYNAMIC_CURRENT_ENV,
    throwOnNotFound: false
  });
    
    console.log(`[${cmd}] Request from ${wxContext.OPENID}:`, params);
    
    // 路由分发
    let result;
    switch (cmd) {
      // ==================== 认证相关 ====================
      case 'login':
        result = await authModule.login(db, wxContext);
        break;
        
      case 'user_info':
        result = await authModule.getUserInfo(db, wxContext.OPENID);
        break;
        
      case 'version':
        result = await authModule.checkVersion(db, wxContext.OPENID);
        break;
        
      case 'upgrade':
        result = await authModule.upgradeUserData(db, wxContext.OPENID);
        break;
        
      // ==================== 基础游戏数据 ====================
      case 'data_get':
        result = await gameDataModule.getData(db, wxContext.OPENID);
        break;
        
      case 'data_update':
        const merge = params.merge !== false; // 默认合并
        result = await gameDataModule.updateData(db, wxContext.OPENID, params.data, merge);
        break;
        
      case 'data_add':
        const fieldValidation = responseModule.validateRequiredParams(params, ['field', 'amount']);
        if (fieldValidation) return fieldValidation;
        result = await gameDataModule.addDataField(db, wxContext.OPENID, params.field, params.amount);
        break;
        
      case 'data_spend':
        const spendValidation = responseModule.validateRequiredParams(params, ['field', 'amount']);
        if (spendValidation) return spendValidation;
        result = await gameDataModule.spendDataField(db, wxContext.OPENID, params.field, params.amount);
        break;
        
      case 'data_set':
        const setValidation = responseModule.validateRequiredParams(params, ['field', 'value']);
        if (setValidation) return setValidation;
        result = await gameDataModule.setDataField(db, wxContext.OPENID, params.field, params.value);
        break;
        
      case 'data_reset':
        result = await gameDataModule.resetData(db, wxContext.OPENID);
        break;
        
      // ==================== 出战英雄 ====================
      case 'fight_heros_get':
        result = await fightHerosModule.getFightHeros(db, wxContext.OPENID);
        break;
        
      case 'fight_hero_set':
        const heroSetValidation = responseModule.validateRequiredParams(params, ['position', 'hero_id']);
        if (heroSetValidation) return heroSetValidation;
        result = await fightHerosModule.setFightHero(db, wxContext.OPENID, params.position, params.hero_id);
        break;
        
      case 'fight_heros_update':
        const herosUpdateValidation = responseModule.validateRequiredParams(params, ['fight_heros']);
        if (herosUpdateValidation) return herosUpdateValidation;
        result = await fightHerosModule.updateFightHeros(db, wxContext.OPENID, params.fight_heros);
        break;
        
      case 'fight_heros_active':
        result = await fightHerosModule.getActiveFightHeros(db, wxContext.OPENID);
        break;
        
      case 'fight_heros_swap':
        const swapValidation = responseModule.validateRequiredParams(params, ['position1', 'position2']);
        if (swapValidation) return swapValidation;
        result = await fightHerosModule.swapFightHeros(db, wxContext.OPENID, params.position1, params.position2);
        break;
        
      case 'fight_heros_reset':
        result = await fightHerosModule.resetFightHeros(db, wxContext.OPENID);
        break;
        
      // ==================== 英雄管理 ====================
      case 'heros_get':
        result = await herosModule.getHeros(db, wxContext.OPENID);
        break;
        
      case 'hero_get':
        const heroGetValidation = responseModule.validateRequiredParams(params, ['hero_id']);
        if (heroGetValidation) return heroGetValidation;
        result = await herosModule.getHero(db, wxContext.OPENID, params.hero_id);
        break;
        
      case 'hero_add':
        const heroAddValidation = responseModule.validateRequiredParams(params, ['hero_id']);
        if (heroAddValidation) return heroAddValidation;
        result = await herosModule.addHero(db, wxContext.OPENID, params.hero_id, params.hero_data);
        break;
        
      case 'hero_update':
        const heroUpdateValidation = responseModule.validateRequiredParams(params, ['hero_id', 'update_data']);
        if (heroUpdateValidation) return heroUpdateValidation;
        result = await herosModule.updateHero(db, wxContext.OPENID, params.hero_id, params.update_data);
        break;
        
      case 'hero_property_set':
        const propValidation = responseModule.validateRequiredParams(params, ['hero_id', 'property', 'value']);
        if (propValidation) return propValidation;
        result = await herosModule.setHeroProperty(db, wxContext.OPENID, params.hero_id, params.property, params.value);
        break;
        
      case 'hero_levelup':
        const levelValidation = responseModule.validateRequiredParams(params, ['hero_id']);
        if (levelValidation) return levelValidation;
        result = await herosModule.levelUpHero(db, wxContext.OPENID, params.hero_id, params.levels);
        break;
        
      case 'hero_delete':
        const deleteValidation = responseModule.validateRequiredParams(params, ['hero_id']);
        if (deleteValidation) return deleteValidation;
        result = await herosModule.deleteHero(db, wxContext.OPENID, params.hero_id);
        break;
        
      case 'heros_owned':
        result = await herosModule.getOwnedHeroIds(db, wxContext.OPENID);
        break;
        
      // ==================== 库存管理 (items, tals, equips) ====================
      case 'inventory_get':
        const invGetValidation = responseModule.validateRequiredParams(params, ['type']);
        if (invGetValidation) return invGetValidation;
        result = await inventoryModule.getInventory(db, wxContext.OPENID, params.type);
        break;
        
      case 'inventory_item_get':
        const itemGetValidation = responseModule.validateRequiredParams(params, ['type', 'item_id']);
        if (itemGetValidation) return itemGetValidation;
        result = await inventoryModule.getInventoryItem(db, wxContext.OPENID, params.type, params.item_id);
        break;
        
      case 'inventory_item_add':
        const itemAddValidation = responseModule.validateRequiredParams(params, ['type', 'item_id', 'count']);
        if (itemAddValidation) return itemAddValidation;
        result = await inventoryModule.addInventoryItem(db, wxContext.OPENID, params.type, params.item_id, params.count);
        break;
        
      case 'inventory_item_consume':
        const itemConsumeValidation = responseModule.validateRequiredParams(params, ['type', 'item_id', 'count']);
        if (itemConsumeValidation) return itemConsumeValidation;
        result = await inventoryModule.consumeInventoryItem(db, wxContext.OPENID, params.type, params.item_id, params.count);
        break;
        
      case 'inventory_item_set':
        const itemSetValidation = responseModule.validateRequiredParams(params, ['type', 'item_id', 'count']);
        if (itemSetValidation) return itemSetValidation;
        result = await inventoryModule.setInventoryItem(db, wxContext.OPENID, params.type, params.item_id, params.count);
        break;
        
      case 'inventory_update':
        const invUpdateValidation = responseModule.validateRequiredParams(params, ['type', 'data']);
        if (invUpdateValidation) return invUpdateValidation;
        const invMerge = params.merge !== false;
        result = await inventoryModule.updateInventory(db, wxContext.OPENID, params.type, params.data, invMerge);
        break;
        
      case 'inventory_reset':
        const invResetValidation = responseModule.validateRequiredParams(params, ['type']);
        if (invResetValidation) return invResetValidation;
        result = await inventoryModule.resetInventory(db, wxContext.OPENID, params.type);
        break;
        
      case 'inventory_owned':
        const invOwnedValidation = responseModule.validateRequiredParams(params, ['type']);
        if (invOwnedValidation) return invOwnedValidation;
        result = await inventoryModule.getOwnedItems(db, wxContext.OPENID, params.type);
        break;
        
      // ==================== 兼容旧接口 ====================
      case 'load':
        result = await authModule.login(db, wxContext);
        break;
        
      case 'save':
        // 兼容旧的保存接口
        if (params.data) {
          const tasks = [];
          if (params.data.data) tasks.push(gameDataModule.updateData(db, wxContext.OPENID, params.data.data));
          if (params.data.fight_heros) tasks.push(fightHerosModule.updateFightHeros(db, wxContext.OPENID, params.data.fight_heros));
          if (params.data.heros) {
            // 批量更新英雄
            for (const heroId in params.data.heros) {
              tasks.push(herosModule.updateHero(db, wxContext.OPENID, parseInt(heroId), params.data.heros[heroId]));
            }
          }
          if (params.data.items) tasks.push(inventoryModule.updateInventory(db, wxContext.OPENID, 'items', params.data.items));
          if (params.data.tals) tasks.push(inventoryModule.updateInventory(db, wxContext.OPENID, 'tals', params.data.tals));
          if (params.data.equips) tasks.push(inventoryModule.updateInventory(db, wxContext.OPENID, 'equips', params.data.equips));
          
          const results = await Promise.all(tasks);
          const hasError = results.some(r => r.code !== 200);
          
          if (hasError) {
            result = responseModule.error(-1, "Partial save failed", { results });
          } else {
            result = responseModule.success({ results }, "All data saved successfully");
          }
    } else {
          result = responseModule.badRequest("No data to save");
        }
        break;
        
      default:
        const availableCommands = [
          'login', 'user_info', 'version', 'upgrade',
          'data_get', 'data_update', 'data_add', 'data_spend', 'data_set', 'data_reset',
          'fight_heros_get', 'fight_hero_set', 'fight_heros_update', 'fight_heros_active', 'fight_heros_swap', 'fight_heros_reset',
          'heros_get', 'hero_get', 'hero_add', 'hero_update', 'hero_property_set', 'hero_levelup', 'hero_delete', 'heros_owned',
          'inventory_get', 'inventory_item_get', 'inventory_item_add', 'inventory_item_consume', 'inventory_item_set', 'inventory_update', 'inventory_reset', 'inventory_owned',
          'load', 'save'
        ];
        result = responseModule.unknownCommand(cmd, availableCommands);
        break;
    }
    
    // 添加执行时间
    const executionTime = Date.now() - startTime;
    if (result && typeof result === 'object') {
      result.execution_time = executionTime;
    }
    
    console.log(`[${cmd}] Response (${executionTime}ms):`, result.code, result.msg);
    return result;
    
  } catch (error) {
    console.error("Cloud function error:", error);
    return responseModule.systemError("Cloud function execution failed", error);
  }
};