use crate::ir::ir_add::IrAdd;
use crate::ir::ir_call::IrCall;
use crate::ir::ir_expression::IrExpression;
use crate::ir::ir_variable::IrVrVariableDescriptor;
use crate::ir::register_allocation::{OffsetCounter, VrUser};
use std::collections::{HashMap, HashSet};
use std::fmt::{Display, Formatter};

pub enum IrOperation {
    Load(IrExpression),
    Add(IrAdd),
    Call(IrCall),
}

impl Display for IrOperation {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        match self {
            IrOperation::Load(ir_expression) => {
                write!(f, "{}", ir_expression)
            }
            IrOperation::Add(ir_add) => {
                write!(f, "{}", ir_add)
            }
            IrOperation::Call(ir_call) => {
                write!(f, "{}", ir_call)
            }
        }
    }
}

impl VrUser for IrOperation {
    fn vr_definitions(&self) -> HashSet<IrVrVariableDescriptor> {
        match self {
            IrOperation::Load(ir_expression) => ir_expression.vr_definitions(),
            IrOperation::Add(ir_add) => ir_add.vr_definitions(),
            IrOperation::Call(ir_call) => ir_call.vr_definitions(),
        }
    }

    fn vr_uses(&self) -> HashSet<IrVrVariableDescriptor> {
        match self {
            IrOperation::Load(ir_expression) => ir_expression.vr_uses(),
            IrOperation::Add(ir_add) => ir_add.vr_uses(),
            IrOperation::Call(ir_call) => ir_call.vr_uses(),
        }
    }

    fn propagate_spills(&mut self, spills: &HashSet<IrVrVariableDescriptor>) {
        match self {
            IrOperation::Load(ir_expression) => {
                ir_expression.propagate_spills(spills);
            }
            IrOperation::Add(ir_add) => {
                ir_add.propagate_spills(spills);
            }
            IrOperation::Call(ir_call) => {
                ir_call.propagate_spills(spills);
            }
        }
    }

    fn propagate_register_assignments(
        &mut self,
        assignments: &HashMap<IrVrVariableDescriptor, usize>,
    ) {
        match self {
            IrOperation::Load(ir_expression) => {
                ir_expression.propagate_register_assignments(assignments);
            }
            IrOperation::Add(ir_add) => {
                ir_add.propagate_register_assignments(assignments);
            }
            IrOperation::Call(ir_call) => {
                ir_call.propagate_register_assignments(assignments);
            }
        }
    }

    fn propagate_stack_offsets(&mut self, _counter: &mut OffsetCounter) {
        // no-op
    }
}