// IR 指令体系：
// - 二元运算/比较、load/store、call、br/condbr、ret、phi、alloca 等
// - 指令操作数与结果类型管理，支持打印与优化
#include "ir/IR.h"

#include <stdexcept>

#include "utils/Log.h"

namespace ir {
User::User(std::shared_ptr<Type> ty, std::string name)
    : Value(std::move(ty), std::move(name)) {}

size_t User::GetNumOperands() const { return operands_.size(); }

Value* User::GetOperand(size_t index) const {
  if (index >= operands_.size()) {
    throw std::out_of_range("User operand index out of range");
  }
  return operands_[index];
}

void User::SetOperand(size_t index, Value* value) {
  if (index >= operands_.size()) {
    throw std::out_of_range("User operand index out of range");
  }
  if (!value) {
    throw std::runtime_error(FormatError("ir", "User operand 不能为空"));
  }
  auto* old = operands_[index];
  if (old == value) {
    return;
  }
  if (old) {
    old->RemoveUse(this, index);
  }
  operands_[index] = value;
  value->AddUse(this, index);
}

void User::AddOperand(Value* value) {
  if (!value) {
    throw std::runtime_error(FormatError("ir", "User operand 不能为空"));
  }
  size_t operand_index = operands_.size();
  operands_.push_back(value);
  value->AddUse(this, operand_index);
}

Instruction::Instruction(Opcode op, std::shared_ptr<Type> ty, std::string name)
    : User(std::move(ty), std::move(name)), opcode_(op) {}

Opcode Instruction::GetOpcode() const { return opcode_; }

bool Instruction::IsTerminator() const {
  return opcode_ == Opcode::Ret || opcode_ == Opcode::Br ||
         opcode_ == Opcode::CondBr;
}

BasicBlock* Instruction::GetParent() const { return parent_; }

void Instruction::SetParent(BasicBlock* parent) { parent_ = parent; }

BinaryInst::BinaryInst(Opcode op, std::shared_ptr<Type> ty, Value* lhs,
                       Value* rhs, std::string name)
    : Instruction(op, std::move(ty), std::move(name)) {
  // 检查操作码是否为有效的二元操作符
  switch (op) {
    case Opcode::Add:
    case Opcode::Sub:
    case Opcode::Mul:
    case Opcode::Div:
    case Opcode::Mod:
    case Opcode::And:
    case Opcode::Or:
      // 有效的二元操作符
      break;
    case Opcode::Not:
      // Not是一元操作符，不应该在BinaryInst中
      throw std::runtime_error(FormatError("ir", "Not是一元操作符，应使用其他指令"));
    default:
      throw std::runtime_error(FormatError("ir", "BinaryInst 不支持的操作码"));
    }
    // 当前 BinaryInst 仅支持 Add/Sub/Mul，且操作数和结果必须都是 i32。
    if (op != Opcode::Add && op != Opcode::Sub && op != Opcode::Mul) {
  }
  
  if (!type_ || !lhs->GetType() || !rhs->GetType()) {
    throw std::runtime_error(FormatError("ir", "BinaryInst 缺少类型信息"));
  }
  
  // 对于比较操作，结果类型是i1，但我们的类型系统可能还没有i1
  // 暂时简化：所有操作都返回i32，比较操作返回0或1
  // 检查操作数类型是否匹配
  if (lhs->GetType()->GetKind() != rhs->GetType()->GetKind()) {
    throw std::runtime_error(FormatError("ir", "BinaryInst 操作数类型不匹配"));
  }
  
  // 检查操作数类型是否支持
  if (!lhs->GetType()->IsInt32() && !lhs->GetType()->IsFloat()) {
    throw std::runtime_error(
        FormatError("ir", "BinaryInst 只支持 int32 和 float 类型"));
  }
  
  // 对于算术运算，结果类型应与操作数类型相同
  
  bool is_logical = (op == Opcode::And || op == Opcode::Or);
  
  if (is_logical) {
    // 比较和逻辑运算的结果应该是整数类型
    if (!type_->IsInt32()) {
      throw std::runtime_error(
          FormatError("ir", "比较和逻辑运算的结果类型必须是 int32"));
    }
  } else {
    // 算术运算的结果类型应与操作数类型相同
    if (type_->GetKind() != lhs->GetType()->GetKind()) {
      throw std::runtime_error(
          FormatError("ir", "BinaryInst 结果类型与操作数类型不匹配"));
    }
  }
  
  AddOperand(lhs);
  AddOperand(rhs);
}

Value* BinaryInst::GetLhs() const { return GetOperand(0); }

Value* BinaryInst::GetRhs() const { return GetOperand(1); }

ReturnInst::ReturnInst(std::shared_ptr<Type> void_ty, Value* val)
    : Instruction(Opcode::Ret, std::move(void_ty), "") {
  if (!val) {
    throw std::runtime_error(FormatError("ir", "ReturnInst 缺少返回值"));
  }
  if (!type_ || !type_->IsVoid()) {
    throw std::runtime_error(FormatError("ir", "ReturnInst 返回类型必须为 void"));
  }
  AddOperand(val);
}

Value* ReturnInst::GetValue() const { return GetOperand(0); }

AllocaInst::AllocaInst(std::shared_ptr<Type> ptr_ty, std::string name)
    : Instruction(Opcode::Alloca, std::move(ptr_ty), std::move(name)) {
  if (!type_ || !type_->IsPtrInt32()) {
    throw std::runtime_error(FormatError("ir", "AllocaInst 当前只支持 i32*"));
  }
}

LoadInst::LoadInst(std::shared_ptr<Type> val_ty, Value* ptr, std::string name)
    : Instruction(Opcode::Load, std::move(val_ty), std::move(name)) {
  if (!ptr) {
    throw std::runtime_error(FormatError("ir", "LoadInst 缺少 ptr"));
  }
  if (!type_ || !type_->IsInt32()) {
    throw std::runtime_error(FormatError("ir", "LoadInst 当前只支持加载 i32"));
  }
  if (!ptr->GetType() || !ptr->GetType()->IsPtrInt32()) {
    throw std::runtime_error(
        FormatError("ir", "LoadInst 当前只支持从 i32* 加载"));
  }
  AddOperand(ptr);
}

Value* LoadInst::GetPtr() const { return GetOperand(0); }

StoreInst::StoreInst(std::shared_ptr<Type> void_ty, Value* val, Value* ptr)
    : Instruction(Opcode::Store, std::move(void_ty), "") {
  if (!val) {
    throw std::runtime_error(FormatError("ir", "StoreInst 缺少 value"));
  }
  if (!ptr) {
    throw std::runtime_error(FormatError("ir", "StoreInst 缺少 ptr"));
  }
  if (!type_ || !type_->IsVoid()) {
    throw std::runtime_error(FormatError("ir", "StoreInst 返回类型必须为 void"));
  }
  if (!val->GetType() || !val->GetType()->IsInt32()) {
    throw std::runtime_error(FormatError("ir", "StoreInst 当前只支持存储 i32"));
  }
  if (!ptr->GetType() || !ptr->GetType()->IsPtrInt32()) {
    throw std::runtime_error(
        FormatError("ir", "StoreInst 当前只支持写入 i32*"));
  }
  AddOperand(val);
  AddOperand(ptr);
}

Value* StoreInst::GetValue() const { return GetOperand(0); }

Value* StoreInst::GetPtr() const { return GetOperand(1); }


Function* CallInst::GetCallee() const { return callee_; }

const std::vector<Value*>& CallInst::GetArgs() const { return args_; }

GEPInst::GEPInst(std::shared_ptr<Type> ptr_ty, 
                 Value* base, 
                 const std::vector<Value*>& indices,
                 const std::string& name)
    : Instruction(Opcode::GEP, ptr_ty, name) {
  // 添加base作为第一个操作数
  AddOperand(base);
  
  // 添加所有索引作为后续操作数
  for (auto* index : indices) {
    AddOperand(index);
  }
}

Value* GEPInst::GetBase() const {
  // 第一个操作数是base
  return GetOperand(0);
}

const std::vector<Value*>& GEPInst::GetIndices() const {
  // 需要返回索引列表，但Instruction只存储操作数
  // 这是一个设计问题：要么修改架构，要么提供辅助方法
  
  // 简化实现：返回空vector（或创建临时vector）
  static std::vector<Value*> indices;
  indices.clear();
  
  // 索引从操作数1开始
  for (size_t i = 1; i < GetNumOperands(); ++i) {
    indices.push_back(GetOperand(i));
  }
  
  return indices;
}

CallInst::CallInst(std::shared_ptr<Type> ret_ty, Function* callee,
                   const std::vector<Value*>& args, const std::string& name)
    : Instruction(Opcode::Call, std::move(ret_ty), name),  // name 是 const&，这里会复制
      callee_(callee), args_(args) {
  if (!callee_) {
    throw std::runtime_error(FormatError("ir", "CallInst 缺少被调用函数"));
  }
  for (auto* arg : args_) {
    if (!arg) {
      throw std::runtime_error(FormatError("ir", "CallInst 参数不能为 null"));
    }
    AddOperand(arg);
  }
}


}  // namespace ir

