use super::error::AsmError;


pub mod literal;
pub mod reg;
pub mod mask;

pub use reg::Register;
pub use mask::Mask;
use literal::Addr;

use std::convert::TryFrom;

use crate::data::literal::Value;

/// Data source disposition
#[derive(Debug, Clone, Copy, Eq, PartialEq)]
pub enum DataDisp {
    /// Constant value
    Immediate(Value),
    /// Constant memory address
    ImmediatePtr(Addr),
    /// Register
    Register(Register),
    /// Pointer into memory, stored in a numbered register
    RegisterPtr(Register),
}

/// Data source disposition
#[derive(Debug, Clone, Copy, Eq, PartialEq)]
pub enum SrcDisp {
    /// Constant value
    Immediate(Value),
    /// Constant memory address
    ImmediatePtr(Addr),
    /// Register
    Register(Register),
    /// Pointer into memory, stored in a numbered register
    RegisterPtr(Register),
}

impl TryFrom<DataDisp> for SrcDisp {
    type Error = AsmError;

    fn try_from(value: DataDisp) -> Result<Self, Self::Error> {
        match value {
            DataDisp::Immediate(x) => Ok(SrcDisp::Immediate(x)),
            DataDisp::ImmediatePtr(x) => Ok(SrcDisp::ImmediatePtr(x)),
            DataDisp::Register(x) => Ok(SrcDisp::Register(x)),
            DataDisp::RegisterPtr(x) => Ok(SrcDisp::RegisterPtr(x)),
        }
    }
}

/// Data destination disposition
#[derive(Debug, Clone, Copy, Eq, PartialEq)]
pub enum DstDisp {
    /// Constant memory address
    ImmediatePtr(Addr),
    /// Register
    Register(Register),
    /// Pointer into memory, stored in a numbered register
    RegisterPtr(Register),
}

impl TryFrom<DataDisp> for DstDisp {
    type Error = AsmError;

    fn try_from(value: DataDisp) -> Result<Self, Self::Error> {
        match value {
            DataDisp::Immediate(_x) => Err(AsmError::ValueAsOutput),
            DataDisp::ImmediatePtr(x) => Ok(DstDisp::ImmediatePtr(x)),
            DataDisp::Register(x) => Ok(DstDisp::Register(x)),
            DataDisp::RegisterPtr(x) => Ok(DstDisp::RegisterPtr(x)),
        }
    }
}

/// Data source argument (read-only)
#[derive(Debug, Clone, Copy, Eq, PartialEq)]
pub struct Rd(SrcDisp, Mask);

impl Rd {
    pub fn new(src : SrcDisp) -> Self {
        Rd(src, Mask::default())
    }
}

/// Data destination argument (read-write)
#[derive(Debug, Clone, Copy, Eq, PartialEq)]
pub struct Wr(DstDisp, Mask);

impl Wr {
    pub fn new(dst : DstDisp) -> Self {
        Wr(dst, Mask::default())
    }
}