#include "irgen/IRGen.h"

#include <stdexcept>

#include "SysYParser.h"
#include "ir/IR.h"
#include "utils/Log.h"

namespace {

// 使用 LValContext 而不是 LValueContext
std::string GetLValueName(SysYParser::LValContext& lvalue) {
  if (!lvalue.Ident()) {
    throw std::runtime_error(FormatError("irgen", "非法左值"));
  }
  return lvalue.Ident()->getText();
}

int TryGetConstInt(SysYParser::ConstExpContext* ctx) {
  // 这里是一个简化的版本，实际上应该调用语义分析的常量求值
  // 暂时假设所有常量表达式都是整数常量
  // 实际实现需要更复杂的逻辑
  
  // 简化为返回10
  return 10;
}

}  // namespace

// 注意：visitBlock 已经在 IRGenFunc.cpp 中实现，这里不要重复定义

std::any IRGenImpl::visitDecl(SysYParser::DeclContext* ctx) {
  std::cerr << "[DEBUG] visitDecl: 开始处理声明" << std::endl;
  if (!ctx) {
    throw std::runtime_error(FormatError("irgen", "缺少变量声明"));
  }
  
  // 处理 varDecl
  if (auto* varDecl = ctx->varDecl()) {
    std::cerr << "[DEBUG] visitDecl: 处理变量声明" << std::endl;
    // 检查类型
    if (varDecl->bType() && varDecl->bType()->Int()) {
      for (auto* varDef : varDecl->varDef()) {
        varDef->accept(this);
      }
    } else {
      throw std::runtime_error(FormatError("irgen", "当前仅支持 int 类型变量"));
    }
  }
  
  // 处理 constDecl
  if (ctx->constDecl()) {
    std::cerr << "[DEBUG] visitDecl: 处理常量声明" << std::endl;
    auto* constDecl = ctx->constDecl();
    
    if (constDecl->bType() && constDecl->bType()->Int()) {
      for (auto* constDef : constDecl->constDef()) {
        constDef->accept(this);
      }
    } else if (constDecl->bType() && constDecl->bType()->Float()) {
      throw std::runtime_error(FormatError("irgen", "float常量暂未实现"));
    } else {
      throw std::runtime_error(FormatError("irgen", "未知的常量类型"));
    }
  }
  std::cerr << "[DEBUG] visitDecl: 声明处理完成" << std::endl;
  return {};
}

// 在 IRGenDecl.cpp 中确保有这个函数
std::any IRGenImpl::visitConstDecl(SysYParser::ConstDeclContext* ctx) {
  std::cerr << "[DEBUG] visitConstDecl: 开始处理常量声明" << std::endl;
  if (!ctx) {
    throw std::runtime_error(FormatError("irgen", "非法常量声明"));
  }
  
  std::cerr << "[DEBUG] visitConstDecl: processing constant declaration" << std::endl;
  
  // 检查类型
  if (ctx->bType()) {
    if (ctx->bType()->Int()) {
      // int 类型常量
      for (auto* constDef : ctx->constDef()) {
        if (constDef) {
          constDef->accept(this);
        }
      }
    } else if (ctx->bType()->Float()) {
      // float 类型常量（暂不支持）
      throw std::runtime_error(FormatError("irgen", "float常量暂未实现"));
    } else {
      throw std::runtime_error(FormatError("irgen", "未知的常量类型"));
    }
  } else {
    throw std::runtime_error(FormatError("irgen", "常量声明缺少类型"));
  }
  
  std::cerr << "[DEBUG] visitConstDecl: 常量声明处理完成" << std::endl;
  return {};
}

std::any IRGenImpl::visitConstDef(SysYParser::ConstDefContext* ctx) {
  if (!ctx || !ctx->Ident()) {
    throw std::runtime_error(FormatError("irgen", "非法常量定义"));
  }
  
  std::string const_name = ctx->Ident()->getText();
  
  // 检查是否为数组
  bool is_array = !ctx->constExp().empty();
  
  // 获取常量类型（int 或 float）
  bool is_float = false;
  auto* constDecl = dynamic_cast<SysYParser::ConstDeclContext*>(ctx->parent);
  if (constDecl && constDecl->bType()) {
    if (constDecl->bType()->Float()) {
      is_float = true;
      std::cerr << "[DEBUG] visitConstDef: 常量 " << const_name << " 是 float 类型" << std::endl;
    }
  }
  
  if (is_array) {
    // 数组常量处理
    std::vector<int> dimensions;
    for (auto* const_exp : ctx->constExp()) {
      int dim_size = TryEvaluateConstInt(const_exp);
      if (dim_size <= 0) dim_size = 1;
      dimensions.push_back(dim_size);
    }
    
    // 创建数组类型
    std::shared_ptr<ir::Type> element_type;
    if (is_float) {
      element_type = ir::Type::GetFloatType();
    } else {
      element_type = ir::Type::GetInt32Type();
    }
    
    auto array_type = ir::Type::GetArrayType(element_type, dimensions);
    ir::GlobalValue* global_array = module_.CreateGlobal(const_name, array_type);
    
    // 处理初始化值
    std::vector<ir::ConstantValue*> init_consts;
    if (auto* const_init_val = ctx->constInitVal()) {
      auto result = const_init_val->accept(this);
      if (result.has_value()) {
        try {
          auto init_vec = std::any_cast<std::vector<ir::Value*>>(result);
          for (auto* val : init_vec) {
            if (is_float) {
              if (auto* const_float = dynamic_cast<ir::ConstantFloat*>(val)) {
                init_consts.push_back(const_float);
              } else if (auto* const_int = dynamic_cast<ir::ConstantInt*>(val)) {
                // 整数转浮点
                float float_val = static_cast<float>(const_int->GetValue());
                init_consts.push_back(builder_.CreateConstFloat(float_val));
              } else {
                init_consts.push_back(builder_.CreateConstFloat(0.0f));
              }
            } else {
              if (auto* const_int = dynamic_cast<ir::ConstantInt*>(val)) {
                init_consts.push_back(const_int);
              } else if (auto* const_float = dynamic_cast<ir::ConstantFloat*>(val)) {
                // 浮点转整数
                int int_val = static_cast<int>(const_float->GetValue());
                init_consts.push_back(builder_.CreateConstInt(int_val));
              } else {
                init_consts.push_back(builder_.CreateConstInt(0));
              }
            }
          }
        } catch (const std::bad_any_cast&) {
          try {
            ir::Value* single_val = std::any_cast<ir::Value*>(result);
            if (is_float) {
              if (auto* const_float = dynamic_cast<ir::ConstantFloat*>(single_val)) {
                init_consts.push_back(const_float);
              } else {
                init_consts.push_back(builder_.CreateConstFloat(0.0f));
              }
            } else {
              if (auto* const_int = dynamic_cast<ir::ConstantInt*>(single_val)) {
                init_consts.push_back(const_int);
              } else {
                init_consts.push_back(builder_.CreateConstInt(0));
              }
            }
          } catch (...) {}
        }
      }
    }
    
    // 补0
    int total_size = 1;
    for (int dim : dimensions) total_size *= dim;
    while (init_consts.size() < static_cast<size_t>(total_size)) {
      if (is_float) {
        init_consts.push_back(builder_.CreateConstFloat(0.0f));
      } else {
        init_consts.push_back(builder_.CreateConstInt(0));
      }
    }
    
    global_array->SetInitializer(init_consts);
    global_array->SetConstant(true);
    
    const_storage_map_[ctx] = global_array;
    const_global_map_[const_name] = global_array;
    
  } else {
    // 标量常量处理
    if (!ctx->constInitVal()) {
      throw std::runtime_error(FormatError("irgen", "常量缺少初始值"));
    }
    
    ir::ConstantValue* const_value = nullptr;
    auto* const_init_val = ctx->constInitVal();
    
    if (const_init_val->constExp()) {
      // 对于常量表达式，我们可以尝试直接求值
      if (is_float) {
        // TODO: 实现浮点常量表达式的求值
        const_value = module_.GetContext().GetConstFloat(0.0f);
      } else {
        int value = TryEvaluateConstInt(const_init_val->constExp());
        const_value = module_.GetContext().GetConstInt(value);
      }
    } else {
      if (is_float) {
        const_value = module_.GetContext().GetConstFloat(0.0f);
      } else {
        const_value = module_.GetContext().GetConstInt(0);
      }
    }
    
    // 存储常量值到映射
    const_value_map_[const_name] = const_value;
  }
  
  return {};
}


// TO DO:visitVarDef来区分全局和局部变量，并且正确处理数组变量的定义和初始化
std::any IRGenImpl::visitVarDef(SysYParser::VarDefContext* ctx) {
  std::cerr << "[DEBUG] visitVarDef: 开始处理变量定义" << std::endl;
  if (!ctx) {
    throw std::runtime_error(FormatError("irgen", "缺少变量定义"));
  }
  
  if (!ctx->Ident()) {
    throw std::runtime_error(FormatError("irgen", "变量声明缺少名称"));
  }
  
  std::string varName = ctx->Ident()->getText();
  std::cerr << "[DEBUG] visitVarDef: 变量名称: " << varName << std::endl;
  // 防止同一个变量被多次分配存储空间。
  if (storage_map_.find(ctx) != storage_map_.end()) {
    throw std::runtime_error(FormatError("irgen", "声明重复生成存储槽位: " + varName));
  }
  
  bool is_array = !ctx->constExp().empty();
  std::cerr << "[DEBUG] visitVarDef: 是否为数组: " << (is_array ? "是" : "否") << std::endl;
  
  // 使用 func_ 来判断：func_ == nullptr 表示在全局作用域
  if (func_ == nullptr) {
    std::cerr << "[DEBUG] visitVarDef: 处理全局变量" << std::endl;
    // 全局变量处理
    return HandleGlobalVariable(ctx, varName, is_array);
  } else {
    std::cerr << "[DEBUG] visitVarDef: 处理局部变量" << std::endl;
    // 局部变量处理
    return HandleLocalVariable(ctx, varName, is_array);
  }
}

std::any IRGenImpl::HandleGlobalVariable(SysYParser::VarDefContext* ctx, 
                                         const std::string& varName, 
                                         bool is_array) {
  std::cerr << "[DEBUG] HandleGlobalVariable: 开始处理全局变量 " << varName << std::endl;
  
  // 获取变量类型（int 或 float）
  bool is_float = false;
  auto* varDecl = dynamic_cast<SysYParser::VarDeclContext*>(ctx->parent);
  if (varDecl && varDecl->bType()) {
    if (varDecl->bType()->Float()) {
      is_float = true;
      std::cerr << "[DEBUG] HandleGlobalVariable: 变量 " << varName << " 是 float 类型" << std::endl;
    } else if (varDecl->bType()->Int()) {
      std::cerr << "[DEBUG] HandleGlobalVariable: 变量 " << varName << " 是 int 类型" << std::endl;
    }
  }
  
  if (is_array) {
    // 全局数组变量
    int total_size = 1;
    std::vector<int> dimensions;
    
    // 计算总大小
    for (auto* const_exp : ctx->constExp()) {
      int dim_size = TryEvaluateConstInt(const_exp);
      if (dim_size <= 0) {
        dim_size = 1;
        std::cerr << "[WARNING] HandleGlobalVariable: 无法确定数组维度大小，使用1" << std::endl;
      }
      dimensions.push_back(dim_size);
      total_size *= dim_size;
    }
    
    std::cerr << "[DEBUG] HandleGlobalVariable: 数组总大小: " << total_size << std::endl;
    
    // 创建数组类型
    std::shared_ptr<ir::Type> element_type;
    if (is_float) {
      element_type = ir::Type::GetFloatType();
    } else {
      element_type = ir::Type::GetInt32Type();
    }
    
    auto array_type = ir::Type::GetArrayType(element_type, dimensions);
    ir::GlobalValue* global_array = module_.CreateGlobal(varName, array_type);
    std::cerr << "[DEBUG] HandleGlobalVariable: 创建全局数组: " << varName << std::endl;
    
    // 处理初始化值
    std::vector<ir::ConstantValue*> init_consts;
    if (auto* initVal = ctx->initVal()) {
      std::cerr << "[DEBUG] HandleGlobalVariable: 处理初始化值" << std::endl;
      auto result = initVal->accept(this);
      if (result.has_value()) {
        try {
          auto init_vec = std::any_cast<std::vector<ir::Value*>>(result);
          std::cerr << "[DEBUG] HandleGlobalVariable: 获取到初始化值列表, 大小: " << init_vec.size() << std::endl;
          for (auto* val : init_vec) {
            if (auto* const_int = dynamic_cast<ir::ConstantInt*>(val)) {
              init_consts.push_back(const_int);
            } else if (auto* const_float = dynamic_cast<ir::ConstantFloat*>(val)) {
              init_consts.push_back(const_float);
            } else {
              // 非常量表达式，使用0
              if (is_float) {
                init_consts.push_back(builder_.CreateConstFloat(0.0f));
              } else {
                init_consts.push_back(builder_.CreateConstInt(0));
              }
            }
          }
        } catch (const std::bad_any_cast&) {
          try {
            ir::Value* single_val = std::any_cast<ir::Value*>(result);
            std::cerr << "[DEBUG] HandleGlobalVariable: 获取到单个初始化值" << std::endl;
            if (auto* const_int = dynamic_cast<ir::ConstantInt*>(single_val)) {
              init_consts.push_back(const_int);
            } else if (auto* const_float = dynamic_cast<ir::ConstantFloat*>(single_val)) {
              init_consts.push_back(const_float);
            } else {
              if (is_float) {
                init_consts.push_back(builder_.CreateConstFloat(0.0f));
              } else {
                init_consts.push_back(builder_.CreateConstInt(0));
              }
            }
          } catch (const std::bad_any_cast&) {
            std::cerr << "[WARNING] HandleGlobalVariable: 无法解析数组初始化值" << std::endl;
          }
        }
      }
    }
    
    // 如果初始化值不足，补0
    while (init_consts.size() < static_cast<size_t>(total_size)) {
      if (is_float) {
        init_consts.push_back(builder_.CreateConstFloat(0.0f));
      } else {
        init_consts.push_back(builder_.CreateConstInt(0));
      }
    }
    
    // 设置全局数组的初始化器
    if (!init_consts.empty()) {
      global_array->SetInitializer(init_consts);
      std::cerr << "[DEBUG] HandleGlobalVariable: 设置全局数组初始化器" << std::endl;
    }
    
    // 存储全局变量引用
    storage_map_[ctx] = global_array;
    global_map_[varName] = global_array;
    
  } else {
    // 全局标量变量
    std::shared_ptr<ir::Type> var_type;
    if (is_float) {
      var_type = ir::Type::GetFloatType();
    } else {
      var_type = ir::Type::GetInt32Type();
    }
    
    ir::GlobalValue* global_var = module_.CreateGlobal(varName, var_type);
    std::cerr << "[DEBUG] HandleGlobalVariable: 创建全局标量变量: " << varName << std::endl;
    
    // 处理初始化值
    ir::ConstantValue* init_value = nullptr;
    if (auto* initVal = ctx->initVal()) {
      std::cerr << "[DEBUG] HandleGlobalVariable: 处理标量初始化值" << std::endl;
      auto result = initVal->accept(this);
      if (result.has_value()) {
        try {
          ir::Value* val = std::any_cast<ir::Value*>(result);
          if (is_float) {
            if (auto* const_float = dynamic_cast<ir::ConstantFloat*>(val)) {
              init_value = const_float;
            } else if (auto* const_int = dynamic_cast<ir::ConstantInt*>(val)) {
              // 整数转浮点
              float float_val = static_cast<float>(const_int->GetValue());
              init_value = builder_.CreateConstFloat(float_val);
            } else {
              init_value = builder_.CreateConstFloat(0.0f);
            }
          } else {
            if (auto* const_int = dynamic_cast<ir::ConstantInt*>(val)) {
              init_value = const_int;
            } else if (auto* const_float = dynamic_cast<ir::ConstantFloat*>(val)) {
              // 浮点转整数
              int int_val = static_cast<int>(const_float->GetValue());
              init_value = builder_.CreateConstInt(int_val);
            } else {
              init_value = builder_.CreateConstInt(0);
            }
          }
        } catch (const std::bad_any_cast&) {
          if (is_float) {
            init_value = builder_.CreateConstFloat(0.0f);
          } else {
            init_value = builder_.CreateConstInt(0);
          }
        }
      }
    }
    
    // 如果没有初始化值，默认初始化
    if (!init_value) {
      if (is_float) {
        init_value = builder_.CreateConstFloat(0.0f);
      } else {
        init_value = builder_.CreateConstInt(0);
      }
    }
    
    // 设置全局变量的初始化器
    global_var->SetInitializer(init_value);
    
    // 存储全局变量引用
    storage_map_[ctx] = global_var;
    global_map_[varName] = global_var;
  }
  
  return {};
}

// 修改 HandleLocalVariable 函数中的数组处理部分

std::any IRGenImpl::HandleLocalVariable(SysYParser::VarDefContext* ctx, 
                                        const std::string& varName, 
                                        bool is_array) {
  std::cerr << "[DEBUG] HandleLocalVariable: 开始处理局部变量 " << varName << std::endl;

  // 获取变量类型
  bool is_float = false;
  auto* varDecl = dynamic_cast<SysYParser::VarDeclContext*>(ctx->parent);
  if (varDecl && varDecl->bType()) {
    if (varDecl->bType()->Float()) {
      is_float = true;
      std::cerr << "[DEBUG] HandleLocalVariable: 变量 " << varName << " 是 float 类型" << std::endl;
    }
  }

  if (is_array) {
    // 局部数组变量
    int total_size = 1;
    std::vector<int> dimensions;

    // 获取数组维度
    for (auto* const_exp : ctx->constExp()) {
      try {
        int dim_size = TryEvaluateConstInt(const_exp);
        if (dim_size <= 0) dim_size = 1;
        dimensions.push_back(dim_size);
        total_size *= dim_size;
      } catch (const std::exception& e) {
        std::cerr << "[WARNING] HandleLocalVariable: 无法获取数组维度，使用维度1" << std::endl;
        dimensions.push_back(1);
        total_size *= 1;
      }
    }

    // 创建数组类型
    std::shared_ptr<ir::Type> elem_type;
    if (is_float) {
      elem_type = ir::Type::GetFloatType();
    } else {
      elem_type = ir::Type::GetInt32Type();
    }
    
    // 修正：使用完整的维度列表创建数组类型
    auto array_type = ir::Type::GetArrayType(elem_type, dimensions);

    // 分配数组内存 - 为每个元素创建独立的 alloca
    std::vector<ir::Value*> element_slots;
    for (int i = 0; i < total_size; i++) {
      ir::AllocaInst* slot;
      if (is_float) {
        slot = builder_.CreateAllocaFloat(
            module_.GetContext().NextTemp() + "_" + varName + "_" + std::to_string(i));
      } else {
        slot = builder_.CreateAllocaI32(
            module_.GetContext().NextTemp() + "_" + varName + "_" + std::to_string(i));
      }
      element_slots.push_back(slot);
    }

    // 存储第一个元素的地址作为数组的基地址
    storage_map_[ctx] = element_slots[0];
    local_var_map_[varName] = element_slots[0];

    // 处理初始化
    if (auto* initVal = ctx->initVal()) {
      auto result = initVal->accept(this);
      if (result.has_value()) {
        try {
          std::vector<ir::Value*> init_values = 
              std::any_cast<std::vector<ir::Value*>>(result);
          
          // 初始化数组元素
          for (size_t i = 0; i < init_values.size() && i < static_cast<size_t>(total_size); i++) {
            builder_.CreateStore(init_values[i], element_slots[i]);
          }
          
          // 剩余元素初始化为0
          for (size_t i = init_values.size(); i < static_cast<size_t>(total_size); i++) {
            if (is_float) {
              builder_.CreateStore(builder_.CreateConstFloat(0.0f), element_slots[i]);
            } else {
              builder_.CreateStore(builder_.CreateConstInt(0), element_slots[i]);
            }
          }
        } catch (const std::bad_any_cast&) {
          try {
            ir::Value* single_value = std::any_cast<ir::Value*>(result);
            // 只初始化第一个元素
            builder_.CreateStore(single_value, element_slots[0]);
            
            // 其他元素初始化为0
            for (int i = 1; i < total_size; i++) {
              if (is_float) {
                builder_.CreateStore(builder_.CreateConstFloat(0.0f), element_slots[i]);
              } else {
                builder_.CreateStore(builder_.CreateConstInt(0), element_slots[i]);
              }
            }
          } catch (const std::bad_any_cast&) {
            // 全部初始化为0
            for (int i = 0; i < total_size; i++) {
              if (is_float) {
                builder_.CreateStore(builder_.CreateConstFloat(0.0f), element_slots[i]);
              } else {
                builder_.CreateStore(builder_.CreateConstInt(0), element_slots[i]);
              }
            }
          }
        }
      } else {
        // 没有初始化值，全部初始化为0
        for (int i = 0; i < total_size; i++) {
          if (is_float) {
            builder_.CreateStore(builder_.CreateConstFloat(0.0f), element_slots[i]);
          } else {
            builder_.CreateStore(builder_.CreateConstInt(0), element_slots[i]);
          }
        }
      }
    } else {
      // 无初始化，所有元素初始化为0
      for (int i = 0; i < total_size; i++) {
        if (is_float) {
          builder_.CreateStore(builder_.CreateConstFloat(0.0f), element_slots[i]);
        } else {
          builder_.CreateStore(builder_.CreateConstInt(0), element_slots[i]);
        }
      }
    }
  } else {
    // 局部标量变量
    ir::AllocaInst* slot;
    if (is_float) {
      slot = builder_.CreateAllocaFloat(module_.GetContext().NextTemp() + "_" + varName);
    } else {
      slot = builder_.CreateAllocaI32(module_.GetContext().NextTemp() + "_" + varName);
    }
    
    storage_map_[ctx] = slot;
    local_var_map_[varName] = slot;
    
    // 处理初始化
    ir::Value* init = nullptr;
    if (auto* initVal = ctx->initVal()) {
      auto result = initVal->accept(this);
      if (result.has_value()) {
        try {
          init = std::any_cast<ir::Value*>(result);
        } catch (const std::bad_any_cast&) {
          try {
            std::vector<ir::Value*> init_values = 
                std::any_cast<std::vector<ir::Value*>>(result);
            if (!init_values.empty()) {
              init = init_values[0];
            } else {
              if (is_float) {
                init = builder_.CreateConstFloat(0.0f);
              } else {
                init = builder_.CreateConstInt(0);
              }
            }
          } catch (const std::bad_any_cast&) {
            if (is_float) {
              init = builder_.CreateConstFloat(0.0f);
            } else {
              init = builder_.CreateConstInt(0);
            }
          }
        }
      } else {
        if (is_float) {
          init = builder_.CreateConstFloat(0.0f);
        } else {
          init = builder_.CreateConstInt(0);
        }
      }
    } else {
      if (is_float) {
        init = builder_.CreateConstFloat(0.0f);
      } else {
        init = builder_.CreateConstInt(0);
      }
    }
    
    builder_.CreateStore(init, slot);
  }
  
  return {};
}


std::any IRGenImpl::visitInitVal(SysYParser::InitValContext* ctx) {
  std::cerr << "[DEBUG] visitInitVal: 开始处理初始化值" << std::endl;
  if (!ctx) {
    throw std::runtime_error(FormatError("irgen", "非法初始化值"));
  }
  
  // 如果是单个表达式
  if (ctx->exp()) {
    std::cerr << "[DEBUG] visitInitVal: 处理表达式初始化" << std::endl;
    return EvalExpr(*ctx->exp());
  } 
  // 如果是聚合初始化（花括号列表）
  else if (!ctx->initVal().empty()) {
    std::cerr << "[DEBUG] visitInitVal: 处理聚合初始化" << std::endl;
    // 处理嵌套聚合初始化
    return ProcessNestedInitVals(ctx);
  }
  
  std::cerr << "[DEBUG] visitInitVal: 空初始化列表" << std::endl;
  // 空初始化列表
  return std::vector<ir::Value*>{};
}

// 新增：处理嵌套聚合初始化的辅助函数
std::vector<ir::Value*> IRGenImpl::ProcessNestedInitVals(SysYParser::InitValContext* ctx) {
  std::cerr << "[DEBUG] ProcessNestedInitVals: 开始处理嵌套初始化值" << std::endl;
  std::vector<ir::Value*> all_values;
  
  for (auto* init_val : ctx->initVal()) {
    auto result = init_val->accept(this);
    if (result.has_value()) {
      try {
        // 尝试获取单个值
        ir::Value* value = std::any_cast<ir::Value*>(result);
        all_values.push_back(value);
        std::cerr << "[DEBUG] ProcessNestedInitVals: 获取到单个值" << std::endl;
      } catch (const std::bad_any_cast&) {
        try {
          // 尝试获取值列表（嵌套情况）
          std::vector<ir::Value*> nested_values = 
              std::any_cast<std::vector<ir::Value*>>(result);
          std::cerr << "[DEBUG] ProcessNestedInitVals: 获取到嵌套值列表, 大小: " << nested_values.size() << std::endl;
          // 展平嵌套的值
          all_values.insert(all_values.end(), 
                           nested_values.begin(), nested_values.end());
        } catch (const std::bad_any_cast&) {
          // 未知类型
          std::cerr << "[ERROR] ProcessNestedInitVals: 不支持的初始化值类型" << std::endl;
          throw std::runtime_error(
              FormatError("irgen", "不支持的初始化值类型"));
        }
      }
    } else {
      std::cerr << "[DEBUG] ProcessNestedInitVals: 无初始化值结果" << std::endl;
    }
  }
  
  std::cerr << "[DEBUG] ProcessNestedInitVals: 共获取 " << all_values.size() << " 个初始化值" << std::endl;
  return all_values;
}

int IRGenImpl::TryEvaluateConstInt(SysYParser::ConstExpContext* ctx) {
  std::cerr << "[DEBUG] TryEvaluateConstInt: 开始求值常量表达式" << std::endl;
  if (!ctx) {
    std::cerr << "[DEBUG] TryEvaluateConstInt: ctx is null" << std::endl;
    return 0;
  }
  
  // 直接访问常量表达式树，计算数值
  // 这里需要实现真正的常量求值逻辑
  // 简化版本：假设常量表达式是整数常量
  
  if (ctx->addExp()) {
    // 尝试从 addExp 求值
    return EvaluateConstAddExp(ctx->addExp());
  }
  
  return 0;
}

// 添加辅助函数来求值常量表达式
int IRGenImpl::EvaluateConstAddExp(SysYParser::AddExpContext* ctx) {
  if (!ctx) return 0;
  
  // 如果没有左操作数，直接求值右操作数
  if (!ctx->addExp()) {
    return EvaluateConstMulExp(ctx->mulExp());
  }
  
  int left = EvaluateConstAddExp(ctx->addExp());
  int right = EvaluateConstMulExp(ctx->mulExp());
  
  if (ctx->AddOp()) {
    return left + right;
  } else if (ctx->SubOp()) {
    return left - right;
  }
  
  return 0;
}

int IRGenImpl::EvaluateConstMulExp(SysYParser::MulExpContext* ctx) {
  if (!ctx) return 0;
  
  // 如果没有左操作数，直接求值右操作数
  if (!ctx->mulExp()) {
    return EvaluateConstUnaryExp(ctx->unaryExp());
  }
  
  int left = EvaluateConstMulExp(ctx->mulExp());
  int right = EvaluateConstUnaryExp(ctx->unaryExp());
  
  if (ctx->MulOp()) {
    return left * right;
  } else if (ctx->DivOp()) {
    return left / right;
  } else if (ctx->QuoOp()) {
    return left % right;
  }
  
  return 0;
}

int IRGenImpl::EvaluateConstUnaryExp(SysYParser::UnaryExpContext* ctx) {
  if (!ctx) return 0;
  
  // 基本表达式（数字字面量）
  if (ctx->primaryExp()) {
    return EvaluateConstPrimaryExp(ctx->primaryExp());
  }
  
  // 一元运算
  if (ctx->unaryOp() && ctx->unaryExp()) {
    int operand = EvaluateConstUnaryExp(ctx->unaryExp());
    std::string op = ctx->unaryOp()->getText();
    
    if (op == "+") {
      return operand;
    } else if (op == "-") {
      return -operand;
    } else if (op == "!") {
      return !operand;
    }
  }
  
  return 0;
}

int IRGenImpl::EvaluateConstPrimaryExp(SysYParser::PrimaryExpContext* ctx) {
  if (!ctx) return 0;
  
  // 处理数字字面量
  if (ctx->DECIMAL_INT()) {
    return std::stoi(ctx->DECIMAL_INT()->getText());
  }
  
  if (ctx->HEX_INT()) {
    std::string hex = ctx->HEX_INT()->getText();
    return std::stoi(hex, nullptr, 16);
  }
  
  if (ctx->OCTAL_INT()) {
    std::string oct = ctx->OCTAL_INT()->getText();
    return std::stoi(oct, nullptr, 8);
  }
  
  if (ctx->ZERO()) {
    return 0;
  }
  
  // 处理括号表达式
  if (ctx->L_PAREN() && ctx->exp()) {
    return EvaluateConstExp(ctx->exp());
  }
  
  // 常量标识符（引用其他常量）
  if (ctx->lVal()) {
    std::string const_name = ctx->lVal()->Ident()->getText();
    auto it = const_value_map_.find(const_name);
    if (it != const_value_map_.end()) {
      if (auto* const_int = dynamic_cast<ir::ConstantInt*>(it->second)) {
        return const_int->GetValue();
      }
    }
    // 也可以从语义分析获取常量值
    // ...
  }
  
  return 0;
}

int IRGenImpl::EvaluateConstExp(SysYParser::ExpContext* ctx) {
  if (!ctx || !ctx->addExp()) return 0;
  return EvaluateConstAddExp(ctx->addExp());
}