use std::convert::{TryFrom, From};
use num_enum::TryFromPrimitive;

#[derive(Debug, PartialEq, Eq)]
pub enum Op {
    Misc(u8),
    Atom(AtomMinor),
    Compound(CompoundMinor),
    Reserved(u8),
}

#[derive(Debug, PartialEq, Eq)]
pub struct InvalidOp;

impl TryFrom<u8> for Op {
    type Error = InvalidOp;
    fn try_from(v: u8) -> Result<Self, Self::Error> {
        match v >> 2 {
            0 => Ok(Self::Misc(v & 3)),
            1 => Ok(Self::Atom(AtomMinor::try_from(v & 3).unwrap())),
            2 => Ok(Self::Compound(CompoundMinor::try_from(v & 3).unwrap())),
            3 => Ok(Self::Reserved(v & 3)),
            _ => Err(InvalidOp),
        }
    }
}

impl From<Op> for u8 {
    fn from(v: Op) -> Self {
        match v {
            Op::Misc(minor) => minor & 3,
            Op::Atom(minor) => (1 << 2) | ((minor as u8) & 3),
            Op::Compound(minor) => (2 << 2) | ((minor as u8) & 3),
            Op::Reserved(minor) => (3 << 2) | (minor & 3),
        }
    }
}

#[derive(Debug, TryFromPrimitive, PartialEq, Eq)]
#[repr(u8)]
pub enum AtomMinor {
    SignedInteger = 0,
    String = 1,
    ByteString = 2,
    Symbol = 3,
}

#[derive(Debug, TryFromPrimitive, PartialEq, Eq)]
#[repr(u8)]
pub enum CompoundMinor {
    Record = 0,
    Sequence = 1,
    Set = 2,
    Dictionary = 3,
}