use std::fmt::Debug;

pub use eval_res::EvalRes;

use crate::asm::data::literal::Value;
use crate::asm::data::Mask;
use crate::asm::error::Error;
use crate::asm::instr::Op;
use crate::asm::parse::arg_parser::ArgParser;
use crate::runtime::fault::Fault;
use crate::runtime::run_thread::state::RunState;
use crate::runtime::run_thread::ThreadInfo;

mod eval_res;

/// Result type returned from the op parser. This is the Ok variant of a Result.
pub enum ParseOpRes {
    /// Parsing successful.
    Parsed(Op),
    /// Instruction not recognized, but there was no error.
    Unknown(ArgParser),
}

pub trait OpTrait: Debug + Send + Sync + 'static {
    fn execute(&self, ti: &ThreadInfo, state: &mut RunState) -> Result<EvalRes, Fault>;
}

pub trait CrsnExtension: Debug + Send + Sync + 'static {
    /// Get name of the module
    fn name(&self) -> &'static str;

    /// Parse an op.
    /// If the keyword matches and the function decides to parse the instruction, it must consume
    /// the argument list and either return Ok or Err.
    ///
    /// If the instruction keyword is not recognized, return Unknown with the unchanged argument list.
    fn parse_op(&self, keyword: &str, arg_tokens: ArgParser) -> Result<ParseOpRes, Error>;

    /// Drop an object referenced by a handle
    fn drop_obj(&self,
                #[allow(unused)] ti: &ThreadInfo,
                #[allow(unused)] state: &mut RunState,
                #[allow(unused)] handle: Value) -> Result<Option<()>, Fault>
    {
        // Default impl - we do not support dropping this object
        Ok(None)
    }

    /// Run-time method called to read an object (using the object handle syntax)
    fn read_obj(&self,
                #[allow(unused)] ti: &ThreadInfo,
                #[allow(unused)] state: &mut RunState,
                #[allow(unused)] handle: Value,
                #[allow(unused)] mask: Mask,
    ) -> Result<Option<Value>, Fault> {
        // Default impl - we do not support reading this object
        Ok(None)
    }

    /// Run-time method called to write an object (using the object handle syntax)
    fn write_obj(&self,
                 #[allow(unused)] ti: &ThreadInfo,
                 #[allow(unused)] state: &mut RunState,
                 #[allow(unused)] handle: Value,
                 #[allow(unused)] mask: Mask,
    ) -> Result<Option<()>, Fault> {
        // Default impl - we do not support writing this object
        Ok(None)
    }
}