use crate::{
    backing::ImportBacking,
    error::CompileResult,
    error::RuntimeResult,
    module::ModuleInner,
    types::{FuncIndex, LocalFuncIndex, Value},
    vm,
};
#[cfg(feature = "cache")]
use crate::{
    cache::{Cache, Error as CacheError},
    module::ModuleInfo,
    sys::Memory,
};
use std::ptr::NonNull;

pub mod sys {
    pub use crate::sys::*;
}
pub use crate::sig_registry::SigRegistry;

#[cfg_attr(feature = "cache", derive(Serialize, Deserialize))]
#[derive(Debug, Copy, Clone, PartialEq, Eq)]
pub enum Backend {
    Cranelift,
}

/// This type cannot be constructed from
/// outside the runtime crate.
pub struct Token {
    _private: (),
}

impl Token {
    pub(crate) fn generate() -> Self {
        Self { _private: () }
    }
}

pub trait Compiler {
    /// Compiles a `Module` from WebAssembly binary format.
    /// The `CompileToken` parameter ensures that this can only
    /// be called from inside the runtime.
    fn compile(&self, wasm: &[u8], _: Token) -> CompileResult<ModuleInner>;

    #[cfg(feature = "cache")]
    unsafe fn from_cache(&self, cache: Cache, _: Token) -> Result<ModuleInner, CacheError>;

    #[cfg(feature = "cache")]
    fn compile_to_backend_cache_data(
        &self,
        wasm: &[u8],
        _: Token,
    ) -> CompileResult<(Box<ModuleInfo>, Vec<u8>, Memory)>;
}

/// The functionality exposed by this trait is expected to be used
/// for calling functions exported by a webassembly module from
/// host code only.
pub trait ProtectedCaller: Send + Sync {
    /// This calls the exported function designated by `local_func_index`.
    /// Important to note, this supports calling imported functions that are
    /// then exported.
    ///
    /// It's invalid to attempt to call a local function that isn't exported and
    /// the implementation is expected to check for that. The implementation
    /// is also expected to check for correct parameter types and correct
    /// parameter number.
    ///
    /// The `returns` parameter is filled with dummy values when passed in and upon function
    /// return, will be filled with the return values of the wasm function, as long as the
    /// call completed successfully.
    ///
    /// The existance of the Token parameter ensures that this can only be called from
    /// within the runtime crate.
    fn call(
        &self,
        module: &ModuleInner,
        func_index: FuncIndex,
        params: &[Value],
        import_backing: &ImportBacking,
        vmctx: *mut vm::Ctx,
        _: Token,
    ) -> RuntimeResult<Vec<Value>>;
}

pub trait FuncResolver: Send + Sync {
    /// This returns a pointer to the function designated by the `local_func_index`
    /// parameter.
    fn get(
        &self,
        module: &ModuleInner,
        local_func_index: LocalFuncIndex,
    ) -> Option<NonNull<vm::Func>>;
}