// 当前只支撑 i32、i32*、void 以及最小的内存/算术指令，演示用。
//
// 当前已经实现：
// 1. 基础类型系统：void / i32 / i32*
// 2. Value 体系：Value / ConstantValue / ConstantInt / Function / BasicBlock / User / GlobalValue / Instruction
// 3. 最小指令集：Add / Alloca / Load / Store / Ret
// 4. BasicBlock / Function / Module 三层组织结构
// 5. IRBuilder：便捷创建常量和最小指令
// 6. def-use 关系的轻量实现：
//    - Instruction 保存 operand 列表
//    - Value 保存 uses
//    - 支持 ReplaceAllUsesWith 的简化实现
//
// 当前尚未实现或只做了最小占位：
// 1. 完整类型系统：数组、函数类型、label 类型等
// 2. 更完整的指令系统：br / condbr / call / phi / gep 等
// 3. 更成熟的 Use 管理（例如 LLVM 风格的双向链式结构）
// 4. 更完整的 IR verifier 和优化基础设施
//
// 当前需要特别说明的两个简化点：
// 1. BasicBlock 虽然已经纳入 Value 体系，但其类型目前仍用 void 作为占位，
//    后续如果补 label type，可以再改成更合理的块标签类型。
// 2. ConstantValue 体系目前只实现了 ConstantInt，后续可以继续补 ConstantFloat、
//    ConstantArray等更完整的常量种类。
//
// 建议的扩展顺序：
// 1. 先补更多指令和类型
// 2. 再补控制流相关 IR
// 3. 最后再考虑把 Value/User/Use 进一步抽象成更完整的框架

#pragma once

#include <iosfwd>
#include <memory>
#include <stdexcept>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>

namespace ir {

class Type;
class ArrayType;
class FunctionType;
class Value;
class User;
class ConstantValue;
class ConstantInt;
class ConstantFloat;
class ConstantArray;
class ConstantZero;
class ConstantAggregateZero;
class GlobalValue;
class Instruction;
class BasicBlock;
class Function;

// Use 表示一个 Value 的一次使用记录。
// 当前实现设计：
// - value：被使用的值
// - user：使用该值的 User
// - operand_index：该值在 user 操作数列表中的位置

class Use {
 public:
  Use() = default;
  Use(Value* value, User* user, size_t operand_index)
      : value_(value), user_(user), operand_index_(operand_index) {}

  Value* GetValue() const { return value_; }
  User* GetUser() const { return user_; }
  size_t GetOperandIndex() const { return operand_index_; }

  void SetValue(Value* value) { value_ = value; }
  void SetUser(User* user) { user_ = user; }
  void SetOperandIndex(size_t operand_index) { operand_index_ = operand_index; }

 private:
  Value* value_ = nullptr;
  User* user_ = nullptr;
  size_t operand_index_ = 0;
};

// IR 上下文：集中管理类型、常量等共享资源，便于复用与扩展。
// ir/IR.h - 修改 Context 类定义

class Context {
 public:
  Context() = default;
  ~Context();
  
  // 去重创建 i32 常量
  ConstantInt* GetConstInt(int v);
  
  // 去重创建浮点常量
  ConstantFloat* GetConstFloat(float v);
  
  // 创建数组常量（不去重，因为数组常量通常比较复杂且组合多样）
  ConstantArray* GetConstArray(std::shared_ptr<ArrayType> ty, 
                                std::vector<ConstantValue*> elements);
  
  // 获取零常量（按类型缓存）
  ConstantZero* GetZeroConstant(std::shared_ptr<Type> ty);
  
  // 获取聚合类型的零常量
  ConstantAggregateZero* GetAggregateZero(std::shared_ptr<Type> ty);

  std::string NextTemp();

 private:
  std::unordered_map<int, std::unique_ptr<ConstantInt>> const_ints_;
  
  // 浮点常量：使用整数表示浮点数位模式作为键（避免浮点精度问题）
  std::unordered_map<uint32_t, std::unique_ptr<ConstantFloat>> const_floats_;
  
  // 零常量缓存（按类型指针）
  std::unordered_map<Type*, std::unique_ptr<ConstantZero>> zero_constants_;
  std::unordered_map<Type*, std::unique_ptr<ConstantAggregateZero>> aggregate_zeros_;
  
  // 数组常量简单存储，不去重（因为数组常量通常组合多样，去重成本高）
  std::vector<std::unique_ptr<ConstantArray>> const_arrays_;
  
  int temp_index_ = -1;
};

class Type {
 public:
  enum class Kind { Void, Int32, Float, PtrInt32, PtrFloat, Label, Array, Function, 
                  Int1, PtrInt1};

  virtual ~Type() = default;

  // 使用静态共享对象获取类型。
  // 同一类型可直接比较返回值是否相等，例如：
  // Type::GetInt32Type() == Type::GetInt32Type()
  static const std::shared_ptr<Type>& GetVoidType();
  static const std::shared_ptr<Type>& GetInt32Type();
  static const std::shared_ptr<Type>& GetFloatType(); 
  static const std::shared_ptr<Type>& GetPtrInt32Type();
  static const std::shared_ptr<Type>& GetPtrFloatType();
  static const std::shared_ptr<Type>& GetLabelType();
  static std::shared_ptr<ArrayType> GetArrayType(std::shared_ptr<Type> elem, std::vector<int> dims);
  static std::shared_ptr<FunctionType> GetFunctionType(std::shared_ptr<Type> ret, std::vector<std::shared_ptr<Type>> params);
  static const std::shared_ptr<Type>& GetInt1Type();
  static const std::shared_ptr<Type>& GetPtrInt1Type();

  
  // 类型判断
  Kind GetKind() const { return kind_; }
  bool IsVoid() const { return kind_ == Kind::Void; }
  bool IsInt32() const { return kind_ == Kind::Int32; }
  bool IsFloat() const { return kind_ == Kind::Float; } 
  bool IsPtrInt32() const { return kind_ == Kind::PtrInt32; }
  bool IsPtrFloat() const { return kind_ == Kind::PtrFloat; }
  bool IsLabel() const { return kind_ == Kind::Label; }
  bool IsArray() const { return kind_ == Kind::Array; }
  bool IsFunction() const { return kind_ == Kind::Function; }
  bool IsInt1() const { return kind_ == Kind::Int1; }
  bool IsPtrInt1() const { return kind_ == Kind::PtrInt1; }

  // 类型属性
  virtual size_t Size() const;          // 字节大小
  virtual size_t Alignment() const;     // 对齐要求
  virtual bool IsComplete() const;      // 是否为完整类型（非 void，数组维度已知等）

protected:
  explicit Type(Kind k);          // 构造函数 protected，只能由工厂和派生类调用

 private:
  Kind kind_;
};

// 数组类型
class ArrayType : public Type {
public:
  // 获取元素类型和维度
  const std::shared_ptr<Type>& GetElementType() const { return elem_type_; }
  const std::vector<int>& GetDimensions() const { return dims_; }
  size_t GetElementCount() const;            // 总元素个数

  size_t Size() const override;
  size_t Alignment() const override;
  bool IsComplete() const override;

protected:
  ArrayType(std::shared_ptr<Type> elem, std::vector<int> dims);
  friend class Type;  // 允许 Type::GetArrayType 构造

private:
  std::shared_ptr<Type> elem_type_;
    std::vector<int> dims_;
};

// 函数类型
class FunctionType : public Type {
public:
    const std::shared_ptr<Type>& GetReturnType() const { return return_type_; }
    const std::vector<std::shared_ptr<Type>>& GetParamTypes() const { return param_types_; }
    
    size_t Size() const override;              // 函数类型没有大小，通常返回 0
    size_t Alignment() const override;        // 无对齐要求
    bool IsComplete() const override;         // 函数类型视为完整

protected:
    FunctionType(std::shared_ptr<Type> ret, std::vector<std::shared_ptr<Type>> params);
    friend class Type;

private:
    std::shared_ptr<Type> return_type_;
    std::vector<std::shared_ptr<Type>> param_types_;
};

class Value {
 public:
  Value(std::shared_ptr<Type> ty, std::string name);
  virtual ~Value() = default;
  const std::shared_ptr<Type>& GetType() const;
  const std::string& GetName() const;
  void SetName(std::string n);
  bool IsVoid() const;
  bool IsInt32() const;
  bool IsPtrInt32() const;
  bool IsConstant() const;
  bool IsInstruction() const;
  bool IsUser() const;
  bool IsFunction() const;
  void AddUse(User* user, size_t operand_index);
  void RemoveUse(User* user, size_t operand_index);
  const std::vector<Use>& GetUses() const;
  void ReplaceAllUsesWith(Value* new_value);

 protected:
  std::shared_ptr<Type> type_;
  std::string name_;
  std::vector<Use> uses_;
};

// ConstantValue 是常量体系的基类。
// 当前只实现了 ConstantInt，后续可继续扩展更多常量种类。
class ConstantValue : public Value {
 public:
  ConstantValue(std::shared_ptr<Type> ty, std::string name = "");
};

class ConstantInt : public ConstantValue {
 public:
  ConstantInt(std::shared_ptr<Type> ty, int v);
  int GetValue() const { return value_; }

 private:
  int value_{};
};

// 在 ConstantInt 类之后添加以下类

// ConstantFloat - 浮点常量
class ConstantFloat : public ConstantValue {
 public:
  ConstantFloat(std::shared_ptr<Type> ty, float v);
  float GetValue() const { return value_; }

 private:
  float value_{};
};

// ConstantArray - 数组常量
class ConstantArray : public ConstantValue {
 public:
  // 构造函数：接收数组类型和常量元素列表
  ConstantArray(std::shared_ptr<ArrayType> ty, std::vector<ConstantValue*> elements);
  
  // 获取元素数量
  size_t GetNumElements() const { return elements_.size(); }
  
  // 获取指定索引的元素
  ConstantValue* GetElement(size_t index) const { return elements_[index]; }
  
  // 获取所有元素
  const std::vector<ConstantValue*>& GetElements() const { return elements_; }
  
  // 验证常量数组的类型是否正确
  bool IsValid() const;

 private:
  std::vector<ConstantValue*> elements_;
};

// ConstantZero - 零常量（用于零初始化）
class ConstantZero : public ConstantValue {
 public:
  explicit ConstantZero(std::shared_ptr<Type> ty);
  
  // 工厂方法：创建特定类型的零常量
  static std::unique_ptr<ConstantZero> GetZero(std::shared_ptr<Type> ty);
};

// ConstantAggregateZero - 聚合类型的零常量（数组、结构体等）
class ConstantAggregateZero : public ConstantValue {
 public:
  explicit ConstantAggregateZero(std::shared_ptr<Type> ty);
  
  // 获取聚合类型
  std::shared_ptr<Type> GetAggregateType() const { return GetType(); }
  
  // 工厂方法：创建聚合类型的零常量
  static std::unique_ptr<ConstantAggregateZero> GetZero(std::shared_ptr<Type> ty);
};
//function 参数占位类，目前仅保存类型和名字，后续可扩展更多属性（例如是否为数组参数、数组维度等）。
class Argument : public Value {
 public:
  Argument(std::shared_ptr<Type> ty, std::string name);
};

// 后续还需要扩展更多指令类型。add call instruction 只是最小占位，后续可以继续补 sub/mul/div/rem、br/condbr、phi、gep 等指令。
enum class Opcode { 
  Add, Sub, Mul,
  Alloca, Load, Store, Ret, Call, 
  Br, CondBr, Icmp, ZExt, Trunc,
  Div, Mod, 
  And, Or, Not,
  GEP,
  FAdd, FSub, FMul, FDiv,
  FCmp,
  SIToFP,    // 整数转浮点
  FPToSI,    // 浮点转整数
  FPExt,     // 浮点扩展
  FPTrunc,   // 浮点截断
 };
// ZExt 和 Trunc 是零扩展和截断指令,SysY 的 int (i32) vs LLVM IR 的比较结果 (i1)。

// User 是所有“会使用其他 Value 作为输入”的 IR 对象的抽象基类。
// 当前实现中只有 Instruction 继承自 User。
class User : public Value {
 public:
  User(std::shared_ptr<Type> ty, std::string name);
  size_t GetNumOperands() const;
  Value* GetOperand(size_t index) const;
  void SetOperand(size_t index, Value* value);
  // 添加模板方法，支持派生类自动转换
  template<typename T>
  void SetOperand(size_t index, T* value) {
    SetOperand(index, static_cast<Value*>(value));
  }
  
  template<typename T>
  void AddOperand(T* value) {
    AddOperand(static_cast<Value*>(value));
  }
 protected:
  // 统一的 operand 入口。
  void AddOperand(Value* value);

 private:
  std::vector<Value*> operands_;
};

// GlobalValue 是全局值/全局变量体系的空壳占位类。
// 当前只补齐类层次，具体初始化器、打印和链接语义后续再补。
// ir/IR.h - 修正 GlobalValue 定义
// ir/IR.h - 修正 GlobalValue 定义
class GlobalValue : public User {
private:
  std::vector<ConstantValue*> initializer_;  // 初始化值列表
  bool is_constant_ = false;            // 是否为常量（如const变量）
  bool is_extern_ = false;              // 是否为外部声明
  
public:
  GlobalValue(std::shared_ptr<Type> ty, std::string name);
  
  // 初始化器相关 - 使用 ConstantValue*
  void SetInitializer(ConstantValue* init);
  void SetInitializer(const std::vector<ConstantValue*>& init);
  const std::vector<ConstantValue*>& GetInitializer() const { return initializer_; }
  bool HasInitializer() const { return !initializer_.empty(); }
  
  // 常量属性
  void SetConstant(bool is_const) { is_constant_ = is_const; }
  bool IsConstant() const { return is_constant_; }
  
  // 外部声明
  void SetExtern(bool is_extern) { is_extern_ = is_extern; }
  bool IsExtern() const { return is_extern_; }
  
  // 类型判断 - 使用 Type 的方法
  bool IsArray() const { return GetType()->IsArray(); }
  bool IsScalar() const { return GetType()->IsInt32() || GetType()->IsFloat(); }
  
  // 获取数组大小（如果是数组类型）
  int GetArraySize() const {
    if (auto* array_ty = dynamic_cast<ArrayType*>(GetType().get())) {
      return array_ty->GetElementCount();
    }
    return 0;
  }
};

class Instruction : public User {
 public:
  Instruction(Opcode op, std::shared_ptr<Type> ty, std::string name = "");
  Opcode GetOpcode() const;
  bool IsTerminator() const;
  BasicBlock* GetParent() const;
  void SetParent(BasicBlock* parent);

 private:
  Opcode opcode_;
  BasicBlock* parent_ = nullptr;
};

class BinaryInst : public Instruction {
 public:
  BinaryInst(Opcode op, std::shared_ptr<Type> ty, Value* lhs, Value* rhs,
             std::string name);
  Value* GetLhs() const;
 Value* GetRhs() const;
};

class ReturnInst : public Instruction {
 public:
  ReturnInst(std::shared_ptr<Type> void_ty, Value* val);
  Value* GetValue() const;
};

class AllocaInst : public Instruction {
 public:
  AllocaInst(std::shared_ptr<Type> ptr_ty, std::string name);
};

class LoadInst : public Instruction {
 public:
  LoadInst(std::shared_ptr<Type> val_ty, Value* ptr, std::string name);
  Value* GetPtr() const;
};

class StoreInst : public Instruction {
 public:
  StoreInst(std::shared_ptr<Type> void_ty, Value* val, Value* ptr);
  Value* GetValue() const;
  Value* GetPtr() const;
};

// 在 IR.h 中修改 BranchInst 类定义

class BranchInst : public Instruction {
 public:
  // 无条件跳转构造函数
  BranchInst(std::shared_ptr<Type> void_ty, BasicBlock* target)
      : Instruction(Opcode::Br, void_ty, ""), 
        is_conditional_(false), 
        cond_(nullptr),
        target_(target),
        true_target_(nullptr),
        false_target_(nullptr) {}
  
  // 条件跳转构造函数
  BranchInst(std::shared_ptr<Type> void_ty, Value* cond, 
             BasicBlock* true_target, BasicBlock* false_target)
      : Instruction(Opcode::CondBr, void_ty, ""),
        is_conditional_(true),
        cond_(cond),
        target_(nullptr),
        true_target_(true_target),
        false_target_(false_target) {
    // 添加操作数以便维护 def-use 关系
    AddOperand(cond);
    // 注意：BasicBlock 也是 Value，也需要添加到操作数中
    // 但 BasicBlock 继承自 Value，所以可以添加
    AddOperand(true_target);
    AddOperand(false_target);
  }
  
  // 判断是否为条件跳转
  bool IsConditional() const { return is_conditional_; }
  
  // 获取无条件跳转的目标（仅适用于无条件跳转）
  BasicBlock* GetTarget() const { 
    if (is_conditional_) {
      throw std::runtime_error("GetTarget called on conditional branch");
    }
    return target_; 
  }
  
  // 获取条件值（仅适用于条件跳转）
  Value* GetCondition() const { 
    if (!is_conditional_) {
      throw std::runtime_error("GetCondition called on unconditional branch");
    }
    return cond_; 
  }
  
  // 获取真分支目标（仅适用于条件跳转）
  BasicBlock* GetTrueTarget() const { 
    if (!is_conditional_) {
      throw std::runtime_error("GetTrueTarget called on unconditional branch");
    }
    return true_target_; 
  }
  
  // 获取假分支目标（仅适用于条件跳转）
  BasicBlock* GetFalseTarget() const { 
    if (!is_conditional_) {
      throw std::runtime_error("GetFalseTarget called on unconditional branch");
    }
    return false_target_; 
  }
  
  // 设置无条件跳转目标
  void SetTarget(BasicBlock* target) {
    if (is_conditional_) {
      throw std::runtime_error("SetTarget called on conditional branch");
    }
    target_ = target;
  }
  
  // 设置条件跳转的分支目标
  void SetTrueTarget(BasicBlock* target) {
    if (!is_conditional_) {
      throw std::runtime_error("SetTrueTarget called on unconditional branch");
    }
    true_target_ = target;
    // 更新操作数
    SetOperand(1, target);
  }
  
  void SetFalseTarget(BasicBlock* target) {
    if (!is_conditional_) {
      throw std::runtime_error("SetFalseTarget called on unconditional branch");
    }
    false_target_ = target;
    // 更新操作数
    SetOperand(2, target);
  }
  
  void SetCondition(Value* cond) {
    if (!is_conditional_) {
      throw std::runtime_error("SetCondition called on unconditional branch");
    }
    cond_ = cond;
    // 更新操作数
    SetOperand(0, cond);
  }
  
 private:
  bool is_conditional_;
  Value* cond_;               // 条件值（条件跳转使用）
  BasicBlock* target_;        // 无条件跳转目标
  BasicBlock* true_target_;   // 真分支目标（条件跳转使用）
  BasicBlock* false_target_;  // 假分支目标（条件跳转使用）
};

// 创建整数比较指令
  class IcmpInst : public Instruction {
   public:
    enum class Predicate {
      EQ,  // equal
      NE,  // not equal
      LT,  // less than
      LE,  // less than or equal
      GT,  // greater than
      GE   // greater than or equal
    };
    
    IcmpInst(Predicate pred, Value* lhs, Value* rhs, std::shared_ptr<Type> i1_ty, std::string name)
        : Instruction(Opcode::Icmp, i1_ty, name), pred_(pred) {
      AddOperand(lhs);
      AddOperand(rhs);
    }
    
    Predicate GetPredicate() const { return pred_; }
    Value* GetLhs() const { return GetOperand(0); }
    Value* GetRhs() const { return GetOperand(1); }
    
   private:
    Predicate pred_;
  };

class FcmpInst : public Instruction {
 public:
  enum class Predicate {
    FALSE,      // Always false
    OEQ,        // Ordered and equal
    OGT,        // Ordered and greater than
    OGE,        // Ordered and greater than or equal
    OLT,        // Ordered and less than
    OLE,        // Ordered and less than or equal
    ONE,        // Ordered and not equal
    ORD,        // Ordered (no nans)
    UNO,        // Unordered (isnan(x) || isnan(y))
    UEQ,        // Unordered or equal
    UGT,        // Unordered or greater than
    UGE,        // Unordered or greater than or equal
    ULT,        // Unordered or less than
    ULE,        // Unordered or less than or equal
    UNE,        // Unordered or not equal
    TRUE        // Always true
  };
  
  FcmpInst(Predicate pred, Value* lhs, Value* rhs, 
           std::shared_ptr<Type> i1_ty, std::string name)
      : Instruction(Opcode::FCmp, i1_ty, name), pred_(pred) {
    AddOperand(lhs);
    AddOperand(rhs);
  }
  
  Predicate GetPredicate() const { return pred_; }
  Value* GetLhs() const { return GetOperand(0); }
  Value* GetRhs() const { return GetOperand(1); }
  
 private:
  Predicate pred_;
};

  // ZExtInst - 零扩展指令
class ZExtInst : public Instruction {
 public:
  ZExtInst(Value* value, std::shared_ptr<Type> target_ty, std::string name = "")
      : Instruction(Opcode::ZExt, target_ty, name) {
    AddOperand(value);
  }
  
  // 获取被扩展的值
  Value* GetValue() const { 
    return GetOperand(0); 
  }
  
  // 获取源类型
  std::shared_ptr<Type> GetSourceType() const {
    return GetValue()->GetType();
  }
  
  // 获取目标类型
  std::shared_ptr<Type> GetTargetType() const {
    return GetType();
  }
  
  // 设置被扩展的值
  void SetValue(Value* value) {
    SetOperand(0, value);
  }
};

// TruncInst - 截断指令
class TruncInst : public Instruction {
 public:
  TruncInst(Value* value, std::shared_ptr<Type> target_ty, std::string name = "")
      : Instruction(Opcode::Trunc, target_ty, name) {
    AddOperand(value);
  }
  
  // 获取被截断的值
  Value* GetValue() const { 
    return GetOperand(0); 
  }
  
  // 获取源类型
  std::shared_ptr<Type> GetSourceType() const {
    return GetValue()->GetType();
  }
  
  // 获取目标类型
  std::shared_ptr<Type> GetTargetType() const {
    return GetType();
  }
  
  // 设置被截断的值
  void SetValue(Value* value) {
    SetOperand(0, value);
  }
};

class GEPInst : public Instruction {
 public:
  GEPInst(std::shared_ptr<Type> ptr_ty, 
          Value* base, 
          const std::vector<Value*>& indices,
          const std::string& name);
  Value* GetBase() const;
  const std::vector<Value*>& GetIndices() const;
};

// Function 当前也采用了最小实现。
// 需要特别注意：由于项目里还没有单独的 FunctionType，
// Function 继承自 Value 后，其 type_ 目前只保存“返回类型”，
// 并不能完整表达“返回类型 + 形参列表”这一整套函数签名。
// 这对当前只支持 int main() 的最小 IR 足够，但后续若补普通函数、
// 形参和调用，通常需要引入专门的函数类型表示。
class Function : public Value {
 public:
  // 当前构造函数接收完整的 FunctionType。
  Function(std::string name, std::shared_ptr<FunctionType> func_type);
  BasicBlock* CreateBlock(const std::string& name);
  BasicBlock* GetEntry();
  const BasicBlock* GetEntry() const;
  const std::vector<std::unique_ptr<BasicBlock>>& GetBlocks() const;
  // 函数增加参数的接口，目前仅保存参数类型和名字，后续可扩展更多属性（例如是否为数组参数、数组维度等）。注意这里是直接在 Function 上管理参数列表，而不是通过一个单独的 FunctionType 来表达完整函数签名，这也是当前最小实现的一个简化点。
  Argument* AddArgument(std::unique_ptr<Argument> arg);
  const std::vector<std::unique_ptr<Argument>>& GetArguments() const;

 private:
  BasicBlock* entry_ = nullptr;
  std::vector<std::unique_ptr<BasicBlock>> blocks_;
  std::vector<std::unique_ptr<Argument>> arguments_;
};


class CallInst : public Instruction {
 public:
  CallInst(std::shared_ptr<Type> ret_ty, 
           Function* callee,
           const std::vector<Value*>& args,
           const std::string& name);
  Function* GetCallee() const;
  const std::vector<Value*>& GetArgs() const;

 private:
  Function* callee_;
  std::vector<Value*> args_;
};

// BasicBlock 已纳入 Value 体系，便于后续向更完整 IR 类图靠拢。
// 当前其类型仍使用 void 作为占位，后续可替换为专门的 label type。
class BasicBlock : public Value {
 public:
  explicit BasicBlock(std::string name);
  Function* GetParent() const;
  void SetParent(Function* parent);
  bool HasTerminator() const;
  const std::vector<std::unique_ptr<Instruction>>& GetInstructions() const;
  const std::vector<BasicBlock*>& GetPredecessors() const;
  const std::vector<BasicBlock*>& GetSuccessors() const;
  template <typename T, typename... Args>
  T* Append(Args&&... args) {
    if (HasTerminator()) {
      throw std::runtime_error("BasicBlock 已有 terminator，不能继续追加指令: " +
                               name_);
    }
    auto inst = std::make_unique<T>(std::forward<Args>(args)...);
    auto* ptr = inst.get();
    ptr->SetParent(this);
    instructions_.push_back(std::move(inst));
    return ptr;
  }

 private:
  Function* parent_ = nullptr;
  std::vector<std::unique_ptr<Instruction>> instructions_;
  std::vector<BasicBlock*> predecessors_;
  std::vector<BasicBlock*> successors_;
};


class Module {
 public:
  Module() = default;
  Context& GetContext();
  const Context& GetContext() const;
  // 创建函数时传入完整的 FunctionType。
  Function* CreateFunction(const std::string& name,
                           std::shared_ptr<FunctionType> func_type);
  GlobalValue* CreateGlobal(const std::string& name,
                            std::shared_ptr<Type> ty);
  Function* FindFunction(const std::string& name) const;
  const std::vector<std::unique_ptr<Function>>& GetFunctions() const;
  const std::vector<std::unique_ptr<GlobalValue>>& GetGlobals() const;

 private:
  Context context_;
  std::vector<std::unique_ptr<Function>> functions_;
  std::vector<std::unique_ptr<GlobalValue>> globals_;
};

// SIToFP - 整数转浮点
class SIToFPInst : public Instruction {
 public:
  SIToFPInst(Value* value, std::shared_ptr<Type> target_ty, std::string name = "")
      : Instruction(Opcode::SIToFP, target_ty, name) {
    AddOperand(value);
  }
  
  Value* GetValue() const { 
    return GetOperand(0); 
  }
};

// FPToSI - 浮点转整数
class FPToSIInst : public Instruction {
 public:
  FPToSIInst(Value* value, std::shared_ptr<Type> target_ty, std::string name = "")
      : Instruction(Opcode::FPToSI, target_ty, name) {
    AddOperand(value);
  }
  
  Value* GetValue() const { 
    return GetOperand(0); 
  }
};

class IRBuilder {
 public:
  IRBuilder(Context& ctx, BasicBlock* bb);
  void SetInsertPoint(BasicBlock* bb);
  BasicBlock* GetInsertBlock() const;

  // 构造常量、二元运算、返回指令的最小集合。
  ConstantInt* CreateConstInt(int v);
  ConstantFloat* CreateConstFloat(float v);  // 新增
  ConstantArray* CreateConstArray(std::shared_ptr<ArrayType> ty, 
                                   std::vector<ConstantValue*> elements);  // 新增
  ConstantZero* CreateZeroConstant(std::shared_ptr<Type> ty);  // 新增

  BinaryInst* CreateBinary(Opcode op, Value* lhs, Value* rhs,
                           const std::string& name);
  BinaryInst* CreateAdd(Value* lhs, Value* rhs, const std::string& name);
  AllocaInst* CreateAllocaI32(const std::string& name);
  AllocaInst* CreateAllocaFloat(const std::string& name);
  LoadInst* CreateLoad(Value* ptr, const std::string& name);
  StoreInst* CreateStore(Value* val, Value* ptr);
  ReturnInst* CreateRet(Value* v);
  CallInst* CreateCall(Function* callee, const std::vector<Value*>& args,
                       const std::string& name);

  // 创建无条件跳转
  BranchInst* CreateBr(BasicBlock* target);
  
  // 创建条件跳转
  BranchInst* CreateCondBr(Value* cond, BasicBlock* true_target, 
                           BasicBlock* false_target);
  
  // 创建整数比较指令
  IcmpInst* CreateICmpEQ(Value* lhs, Value* rhs, const std::string& name);
  IcmpInst* CreateICmpNE(Value* lhs, Value* rhs, const std::string& name);
  IcmpInst* CreateICmpLT(Value* lhs, Value* rhs, const std::string& name);
  IcmpInst* CreateICmpLE(Value* lhs, Value* rhs, const std::string& name);
  IcmpInst* CreateICmpGT(Value* lhs, Value* rhs, const std::string& name);
  IcmpInst* CreateICmpGE(Value* lhs, Value* rhs, const std::string& name);
  
  // 创建类型转换指令
  ZExtInst* CreateZExt(Value* value, std::shared_ptr<Type> target_ty, 
                       const std::string& name = "");
  TruncInst* CreateTrunc(Value* value, std::shared_ptr<Type> target_ty,
                         const std::string& name = "");
  
  // 便捷方法
  ZExtInst* CreateZExtI1ToI32(Value* value, const std::string& name = "zext");
  TruncInst* CreateTruncI32ToI1(Value* value, const std::string& name = "trunc");

  

  BinaryInst* CreateDiv(Value* lhs, Value* rhs, const std::string& name);
  BinaryInst* CreateMod(Value* lhs, Value* rhs, const std::string& name);
  BinaryInst* CreateMul(Value* lhs, Value* rhs, const std::string& name);
  BinaryInst* CreateSub(Value* lhs, Value* rhs, const std::string& name);

  // 比较运算接口
  BinaryInst* CreateAnd(Value* lhs, Value* rhs, const std::string& name);
  BinaryInst* CreateOr(Value* lhs, Value* rhs, const std::string& name);
  IcmpInst* CreateNot(Value* val, const std::string& name);

  GEPInst* CreateGEP(Value* base, const std::vector<Value*>& indices, const std::string& name);
 
  // 浮点运算
  BinaryInst* CreateFAdd(Value* lhs, Value* rhs, const std::string& name);
  BinaryInst* CreateFSub(Value* lhs, Value* rhs, const std::string& name);
  BinaryInst* CreateFMul(Value* lhs, Value* rhs, const std::string& name);
  BinaryInst* CreateFDiv(Value* lhs, Value* rhs, const std::string& name);
  
  // 浮点比较
  FcmpInst* CreateFCmpOEQ(Value* lhs, Value* rhs, const std::string& name);
  FcmpInst* CreateFCmpONE(Value* lhs, Value* rhs, const std::string& name);
  FcmpInst* CreateFCmpOLT(Value* lhs, Value* rhs, const std::string& name);
  FcmpInst* CreateFCmpOLE(Value* lhs, Value* rhs, const std::string& name);
  FcmpInst* CreateFCmpOGT(Value* lhs, Value* rhs, const std::string& name);
  FcmpInst* CreateFCmpOGE(Value* lhs, Value* rhs, const std::string& name);
  
  // 类型转换
  SIToFPInst* CreateSIToFP(Value* value, std::shared_ptr<Type> target_ty, 
                           const std::string& name = "");
  FPToSIInst* CreateFPToSI(Value* value, std::shared_ptr<Type> target_ty,
                           const std::string& name = "");
 private:
  Context& ctx_;
  BasicBlock* insert_block_;
};

class IRPrinter {
 public:
  void Print(const Module& module, std::ostream& os);

 private:
  void PrintConstant(const ConstantValue* constant, std::ostream& os);
};

}  // namespace ir