use core::ops::Mul;
use std::str::FromStr;

/// Multiple Operation
#[derive(Debug)]
pub struct MulOp {
    lhs: String,
    rhs: String,
}

impl MulOp {
    pub fn new(lhs: String, rhs: String) -> MulOp {
        MulOp { lhs, rhs }
    }

    pub fn multiple<T>(&self) -> Result<<T as Mul>::Output, <T as FromStr>::Err>
    where
        T: FromStr + Mul,
    {
        let lhs: T = self.lhs.parse()?;
        let rhs: T = self.rhs.parse()?;
        Ok(lhs * rhs)
    }
}

/// Do Operation
#[derive(Debug)]
pub struct DoOp {}

impl DoOp {
    pub fn new() -> DoOp {
        DoOp {}
    }
}

/// Don't Operation
#[derive(Debug)]
pub struct DontOp {}

impl DontOp {
    pub fn new() -> DontOp {
        DontOp {}
    }
}

/// Enum of all Operations
#[derive(Debug)]
pub enum Ops {
    Mul(MulOp),
    Do(DoOp),
    Dont(DontOp),
}