use crate::ir::ir_allocate::IrAllocate;
use crate::ir::ir_binary_operation::IrBinaryOperation;
use crate::ir::ir_call::IrCall;
use crate::ir::ir_expression::IrExpression;
use crate::ir::ir_get_field_ref::IrGetFieldRef;
use crate::ir::ir_get_field_ref_mut::IrGetFieldRefMut;
use crate::ir::ir_read_field::IrReadField;
use crate::ir::ir_variable::IrVariableId;
use crate::ir::register_allocation::VrUser;
use std::collections::HashSet;
use std::fmt::{Display, Formatter};

pub enum IrOperation {
    GetFieldRef(IrGetFieldRef),
    GetFieldRefMut(IrGetFieldRefMut),
    ReadField(IrReadField),
    Load(IrExpression),
    Binary(IrBinaryOperation),
    Call(IrCall),
    Allocate(IrAllocate),
}

impl Display for IrOperation {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        match self {
            IrOperation::GetFieldRef(ir_get_field_ref) => {
                write!(f, "{}", ir_get_field_ref)
            }
            IrOperation::GetFieldRefMut(ir_get_field_ref_mut) => {
                write!(f, "{}", ir_get_field_ref_mut)
            }
            IrOperation::ReadField(ir_read_field) => {
                write!(f, "{}", ir_read_field)
            }
            IrOperation::Load(ir_expression) => {
                write!(f, "{}", ir_expression)
            }
            IrOperation::Binary(ir_binary_operation) => {
                write!(f, "{}", ir_binary_operation)
            }
            IrOperation::Call(ir_call) => {
                write!(f, "{}", ir_call)
            }
            IrOperation::Allocate(ir_allocate) => {
                write!(f, "{}", ir_allocate)
            }
        }
    }
}

impl VrUser for IrOperation {
    fn vr_uses(&self) -> HashSet<IrVariableId> {
        match self {
            IrOperation::GetFieldRef(ir_get_field_ref) => ir_get_field_ref.vr_uses(),
            IrOperation::GetFieldRefMut(ir_get_field_ref_mut) => ir_get_field_ref_mut.vr_uses(),
            IrOperation::ReadField(ir_read_field) => ir_read_field.vr_uses(),
            IrOperation::Load(ir_expression) => ir_expression.vr_uses(),
            IrOperation::Binary(ir_binary) => ir_binary.vr_uses(),
            IrOperation::Call(ir_call) => ir_call.vr_uses(),
            IrOperation::Allocate(_) => HashSet::new(),
        }
    }
}