wfassoc/wfassoc-cdylib/src/lib.rs

mod wrapper;

use sarasacw_omrf::object_pool::ObjectPool;
use sarasacw_omrf::{cffi_wrapper, cstr_ffi, in_param_ty, last_error, object_pool, out_param_ty};
use std::sync::LazyLock;
use thiserror::Error as TeError;
use wfassoc::highlevel::{Program, Schema};

// region: Error

/// Error occurs in this crate.
#[derive(Debug, TeError)]
enum UserError {
    /// Error when operating Schema.
    #[error("wfassoc error: {0}")]
    Schema(#[from] wfassoc::highlevel::SchemaError),
    /// Error when parsing Schema into Program.
    #[error("wfassoc error: {0}")]
    ParseProgram(#[from] wfassoc::highlevel::ParseProgramError),
    /// Error when operating Program.
    #[error("wfassoc error: {0}")]
    Program(#[from] wfassoc::highlevel::ProgramError),

    /// Error when manipulating with C-style string.
    #[error("C-Style string FFI error: {0}")]
    CStrFfi(#[from] cstr_ffi::Error),
    /// Error when manipulating with object pool.
    #[error("object pool error: {0}")]
    ObjectPool(#[from] object_pool::Error),

    /// Error occurs when checking enum value
    #[error("the enumeration value provided to FFI function is out of its range")]
    EnumOutOfRange,
}

impl From<UserError> for WFError {
    fn from(_: UserError) -> Self {
        WFERROR_ERR
    }
}

/// Result type used in this crate.
type Result<T> = std::result::Result<T, UserError>;

// endregion

// region: Macros

macro_rules! resolve_enum {
    ($t:ty, $v:expr) => {
        <$t>::try_from($v).map_err(|_| UserError::EnumOutOfRange)
    };
}

// endregion

// region: Object Pools

struct State {
    schema_pool: ObjectPool<Schema>,
    program_pool: ObjectPool<Program>,
    ext_status_pool: ObjectPool<wfassoc::highlevel::ProgramExtStatus>,
    self_ext_status_pool: ObjectPool<wfassoc::highlevel::ProgramSelfExtStatus>,
    icon_rc_pool: ObjectPool<wfassoc::win32::concept::IconRc>,
}

impl State {
    fn new() -> Self {
        Self {
            schema_pool: ObjectPool::new(),
            program_pool: ObjectPool::new(),
            ext_status_pool: ObjectPool::new(),
            self_ext_status_pool: ObjectPool::new(),
            icon_rc_pool: ObjectPool::new(),
        }
    }
}

static CONTEXT: LazyLock<State> = LazyLock::new(|| State::new());

// endregion

// region: Exposed Types

pub use last_error::CERROR_OK as WFERROR_OK;
pub use last_error::CError as WFError;
pub const WFERROR_ERR: WFError = 1;

pub use cstr_ffi::CStrPtr as WFStrPtr;
pub use object_pool::{INVALID_TOKEN as WF_INVALID_TOKEN, Token as WFToken};
pub use wrapper::{HICON as WFHICON, Scope as WFScope, View as WFView};
pub use wrapper::{INVALID_HICON as WF_INVALID_HICON, INVALID_INDEX as WF_INVALID_INDEX};

// endregion

// region: Exposed Functions

// region: Facilities

#[unsafe(no_mangle)]
pub extern "C" fn WFGetLastError() -> WFStrPtr {
    last_error::get_error_message()
}

// endregion

// region: Global Functions

#[unsafe(no_mangle)]
pub extern "C" fn WFHasPrivilege(out_has: out_param_ty!(bool)) -> WFError {
    cffi_wrapper!(|| -> (out_has: bool) {
        Ok(wfassoc::win32::utilities::has_privilege())
    })
}

// endregion

// region: Schema

#[unsafe(no_mangle)]
pub extern "C" fn WFSchemaCreate(out_schema: out_param_ty!(WFToken)) -> WFError {
    cffi_wrapper!(|| -> (out_schema: WFToken) {
        let pool = &CONTEXT.schema_pool;
        Ok(pool.allocate(Schema::new()))
    })
}

#[unsafe(no_mangle)]
pub extern "C" fn WFSchemaDestroy(in_schema: in_param_ty!(WFToken)) -> WFError {
    cffi_wrapper!(|in_schema: WFToken| {
        let pool = &CONTEXT.schema_pool;
        Ok(pool.free(in_schema)?)
    })
}

#[unsafe(no_mangle)]
pub extern "C" fn WFSchemaSetIdentifier(
    in_schema: in_param_ty!(WFToken),
    in_value: in_param_ty!(WFStrPtr),
) -> WFError {
    cffi_wrapper!(|in_schema: WFToken, in_value: WFStrPtr| {
        let pool = &CONTEXT.schema_pool;
        let mut schema = pool.get_mut(in_schema)?;
        schema.set_identifier(cstr_ffi::parse_ffi_string(in_value)?);
        Ok(())
    })
}

#[unsafe(no_mangle)]
pub extern "C" fn WFSchemaSetPath(
    in_schema: in_param_ty!(WFToken),
    in_value: in_param_ty!(WFStrPtr),
) -> WFError {
    cffi_wrapper!(|in_schema: WFToken, in_value: WFStrPtr| {
        let pool = &CONTEXT.schema_pool;
        let mut schema = pool.get_mut(in_schema)?;
        schema.set_path(cstr_ffi::parse_ffi_string(in_value)?);
        Ok(())
    })
}

#[unsafe(no_mangle)]
pub extern "C" fn WFSchemaSetClsid(
    in_schema: in_param_ty!(WFToken),
    in_value: in_param_ty!(WFStrPtr),
) -> WFError {
    cffi_wrapper!(|in_schema: WFToken, in_value: WFStrPtr| {
        let pool = &CONTEXT.schema_pool;
        let mut schema = pool.get_mut(in_schema)?;
        schema.set_clsid(cstr_ffi::parse_ffi_string(in_value)?);
        Ok(())
    })
}

#[unsafe(no_mangle)]
pub extern "C" fn WFSchemaSetName(
    in_schema: in_param_ty!(WFToken),
    in_value: in_param_ty!(WFStrPtr),
) -> WFError {
    cffi_wrapper!(|in_schema: WFToken, in_value: WFStrPtr| {
        let name = if in_value.is_null() {
            None
        } else {
            Some(cstr_ffi::parse_ffi_string(in_value)?)
        };
        
        let pool = &CONTEXT.schema_pool;
        let mut schema = pool.get_mut(in_schema)?;
        schema.set_name(name);
        Ok(())
    })
}

#[unsafe(no_mangle)]
pub extern "C" fn WFSchemaSetIcon(
    in_schema: in_param_ty!(WFToken),
    in_value: in_param_ty!(WFStrPtr),
) -> WFError {
    cffi_wrapper!(|in_schema: WFToken, in_value: WFStrPtr| {
        let icon = if in_value.is_null() {
            None
        } else {
            Some(cstr_ffi::parse_ffi_string(in_value)?)
        };

        let pool = &CONTEXT.schema_pool;
        let mut schema = pool.get_mut(in_schema)?;
        schema.set_icon(icon);
        Ok(())
    })
}

#[unsafe(no_mangle)]
pub extern "C" fn WFSchemaSetBehavior(
    in_schema: in_param_ty!(WFToken),
    in_value: in_param_ty!(WFStrPtr),
) -> WFError {
    cffi_wrapper!(|in_schema: WFToken, in_value: WFStrPtr| {
        let behavior = if in_value.is_null() {
            None
        } else {
            Some(cstr_ffi::parse_ffi_string(in_value)?)
        };

        let pool = &CONTEXT.schema_pool;
        let mut schema = pool.get_mut(in_schema)?;
        schema.set_behavior(behavior);
        Ok(())
    })
}

#[unsafe(no_mangle)]
pub extern "C" fn WFSchemaAddStr(
    in_schema: in_param_ty!(WFToken),
    in_name: in_param_ty!(WFStrPtr),
    in_value: in_param_ty!(WFStrPtr),
) -> WFError {
    cffi_wrapper!(
        |in_schema: WFToken, in_name: WFStrPtr, in_value: WFStrPtr| {
            let pool = &CONTEXT.schema_pool;
            let mut schema = pool.get_mut(in_schema)?;
            schema.add_str(
                cstr_ffi::parse_ffi_string(in_name)?,
                cstr_ffi::parse_ffi_string(in_value)?,
            )?;
            Ok(())
        }
    )
}

#[unsafe(no_mangle)]
pub extern "C" fn WFSchemaAddIcon(
    in_schema: in_param_ty!(WFToken),
    in_name: in_param_ty!(WFStrPtr),
    in_value: in_param_ty!(WFStrPtr),
) -> WFError {
    cffi_wrapper!(
        |in_schema: WFToken, in_name: WFStrPtr, in_value: WFStrPtr| {
            let pool = &CONTEXT.schema_pool;
            let mut schema = pool.get_mut(in_schema)?;
            schema.add_icon(
                cstr_ffi::parse_ffi_string(in_name)?,
                cstr_ffi::parse_ffi_string(in_value)?,
            )?;
            Ok(())
        }
    )
}

#[unsafe(no_mangle)]
pub extern "C" fn WFSchemaAddBehavior(
    in_schema: in_param_ty!(WFToken),
    in_name: in_param_ty!(WFStrPtr),
    in_value: in_param_ty!(WFStrPtr),
) -> WFError {
    cffi_wrapper!(
        |in_schema: WFToken, in_name: WFStrPtr, in_value: WFStrPtr| {
            let pool = &CONTEXT.schema_pool;
            let mut schema = pool.get_mut(in_schema)?;
            schema.add_behavior(
                cstr_ffi::parse_ffi_string(in_name)?,
                cstr_ffi::parse_ffi_string(in_value)?,
            )?;
            Ok(())
        }
    )
}

#[unsafe(no_mangle)]
pub extern "C" fn WFSchemaAddExt(
    in_schema: in_param_ty!(WFToken),
    in_ext: in_param_ty!(WFStrPtr),
    in_ext_name: in_param_ty!(WFStrPtr),
    in_ext_icon: in_param_ty!(WFStrPtr),
    in_ext_behavior: in_param_ty!(WFStrPtr),
) -> WFError {
    cffi_wrapper!(|in_schema: WFToken,
                   in_ext: WFStrPtr,
                   in_ext_name: WFStrPtr,
                   in_ext_icon: WFStrPtr,
                   in_ext_behavior: WFStrPtr| {
        let pool = &CONTEXT.schema_pool;
        let mut schema = pool.get_mut(in_schema)?;
        schema.add_ext(
            cstr_ffi::parse_ffi_string(in_ext)?,
            cstr_ffi::parse_ffi_string(in_ext_name)?,
            cstr_ffi::parse_ffi_string(in_ext_icon)?,
            cstr_ffi::parse_ffi_string(in_ext_behavior)?,
        )?;
        Ok(())
    })
}

// endregion

// region: Program

#[unsafe(no_mangle)]
pub extern "C" fn WFProgramCreate(
    in_schema: in_param_ty!(WFToken),
    out_program: out_param_ty!(WFToken),
) -> WFError {
    cffi_wrapper!(|in_schema: WFToken| -> (out_program: WFToken) {
        let pool = &CONTEXT.schema_pool;
        let schema = pool.pop(in_schema)?;

        let pool = &CONTEXT.program_pool;
        let program = Program::new(schema)?;
        Ok(pool.allocate(program))
    })
}

#[unsafe(no_mangle)]
pub extern "C" fn WFProgramDestroy(in_program: in_param_ty!(WFToken)) -> WFError {
    cffi_wrapper!(|in_program: WFToken| {
        let pool = &CONTEXT.program_pool;
        Ok(pool.free(in_program)?)
    })
}

#[unsafe(no_mangle)]
pub extern "C" fn WFProgramResolveName(
    in_program: in_param_ty!(WFToken),
    out_name: out_param_ty!(WFStrPtr),
) -> WFError {
    cffi_wrapper!(|in_program: WFToken| -> (out_name: WFStrPtr) {
        let pool = &CONTEXT.program_pool;
        let program = pool.get(in_program)?;

        let name = program.resolve_name()?;
        Ok(cstr_ffi::push_ffi_string(&name)?)
    })
}

#[unsafe(no_mangle)]
pub extern "C" fn WFProgramResolveIcon(
    in_program: in_param_ty!(WFToken),
    out_icon_rc: out_param_ty!(WFToken),
) -> WFError {
    cffi_wrapper!(|in_program: WFToken| -> (out_icon_rc: WFToken) {
        let pool = &CONTEXT.program_pool;
        let program = pool.get(in_program)?;

        let icon = program.resolve_icon()?;
        let pool = &CONTEXT.icon_rc_pool;
        Ok(pool.allocate(icon))
    })
}

#[unsafe(no_mangle)]
pub extern "C" fn WFProgramExtsLen(
    in_program: in_param_ty!(WFToken),
    out_len: out_param_ty!(usize),
) -> WFError {
    cffi_wrapper!(|in_program: WFToken| -> (out_len: usize) {
        let pool = &CONTEXT.program_pool;
        let program = pool.get(in_program)?;
        Ok(program.exts_len())
    })
}

#[unsafe(no_mangle)]
pub extern "C" fn WFProgramFindExt(
    in_program: in_param_ty!(WFToken),
    in_body: in_param_ty!(WFStrPtr),
    out_index: out_param_ty!(usize),
) -> WFError {
    cffi_wrapper!(|in_program: WFToken, in_body: WFStrPtr| -> (out_index: usize) {
        let pool = &CONTEXT.program_pool;
        let program = pool.get(in_program)?;

        let body = cstr_ffi::parse_ffi_string(in_body)?;
        let index = match program.find_ext(body) {
            Some(index) => index,
            None => WF_INVALID_INDEX,
        };
        Ok(index)
    })
}

#[unsafe(no_mangle)]
pub extern "C" fn WFProgramResolveExt(
    in_program: in_param_ty!(WFToken),
    in_index: in_param_ty!(usize),
    out_self_ext_status: out_param_ty!(WFToken),
) -> WFError {
    cffi_wrapper!(|in_program: WFToken, in_index: usize| -> (out_self_ext_status: WFToken) {
        let pool = &CONTEXT.program_pool;
        let program = pool.get(in_program)?;

        let self_ext_status = program.resolve_ext(in_index)?;
        let pool = &CONTEXT.self_ext_status_pool;
        let token = pool.allocate(self_ext_status);
        Ok(token)
    })
}

#[unsafe(no_mangle)]
pub extern "C" fn WFProgramRegister(
    in_program: in_param_ty!(WFToken),
    in_scope: in_param_ty!(u32),
) -> WFError {
    cffi_wrapper!(|in_program: WFToken, in_scope: u32| {
        let scope = resolve_enum!(WFScope, in_scope)?;

        let pool = &CONTEXT.program_pool;
        let mut program = pool.get_mut(in_program)?;
        program.register(scope.into())?;
        Ok(())
    })
}

#[unsafe(no_mangle)]
pub extern "C" fn WFProgramUnregister(
    in_program: in_param_ty!(WFToken),
    in_scope: in_param_ty!(u32),
) -> WFError {
    cffi_wrapper!(|in_program: WFToken, in_scope: u32| {
        let scope = resolve_enum!(WFScope, in_scope)?;
        
        let pool = &CONTEXT.program_pool;
        let mut program = pool.get_mut(in_program)?;
        program.unregister(scope.into())?;
        Ok(())
    })
}

#[unsafe(no_mangle)]
pub extern "C" fn WFProgramIsRegistered(
    in_program: in_param_ty!(WFToken),
    in_scope: in_param_ty!(u32),
    out_is_registered: out_param_ty!(bool),
) -> WFError {
    cffi_wrapper!(|in_program: WFToken, in_scope: u32| -> (out_is_registered: bool) {
        let scope = resolve_enum!(WFScope, in_scope)?;

        let pool = &CONTEXT.program_pool;
        let program = pool.get(in_program)?;
        Ok(program.is_registered(scope.into())?)
    })
}

#[unsafe(no_mangle)]
pub extern "C" fn WFProgramLinkExt(
    in_program: in_param_ty!(WFToken),
    in_scope: in_param_ty!(u32),
    in_index: in_param_ty!(usize),
) -> WFError {
    cffi_wrapper!(|in_program: WFToken, in_scope: u32, in_index: usize| {
        let scope = resolve_enum!(WFScope, in_scope)?;

        let pool = &CONTEXT.program_pool;
        let mut program = pool.get_mut(in_program)?;
        program.link_ext(scope.into(), in_index)?;
        Ok(())
    })
}

#[unsafe(no_mangle)]
pub extern "C" fn WFProgramUnlinkExt(
    in_program: in_param_ty!(WFToken),
    in_scope: in_param_ty!(u32),
    in_index: in_param_ty!(usize),
) -> WFError {
    cffi_wrapper!(|in_program: WFToken, in_scope: u32, in_index: usize| {
        let scope = resolve_enum!(WFScope, in_scope)?;

        let pool = &CONTEXT.program_pool;
        let mut program = pool.get_mut(in_program)?;
        program.unlink_ext(scope.into(), in_index)?;
        Ok(())
    })
}

#[unsafe(no_mangle)]
pub extern "C" fn WFProgramQueryExt(
    in_program: in_param_ty!(WFToken),
    in_view: in_param_ty!(u32),
    in_index: in_param_ty!(usize),
    out_ext_status: out_param_ty!(WFToken),
) -> WFError {
    cffi_wrapper!(|in_program: WFToken, in_view: u32, in_index: usize| -> (out_ext_status: WFToken) {
        let view = resolve_enum!(WFView, in_view)?;

        let pool = &CONTEXT.program_pool;
        let program = pool.get(in_program)?;
        let ext_status = program.query_ext(view.into(), in_index)?;
        let token = match ext_status {
            Some(ext_status) => {
                let pool = &CONTEXT.ext_status_pool;
                pool.allocate(ext_status)
            },
            None => WF_INVALID_TOKEN,
        };
        Ok(token)
    })
}

// endregion

// region: Extension Status

#[unsafe(no_mangle)]
pub extern "C" fn WFExtStatusDestroy(in_ext_status: in_param_ty!(WFToken)) -> WFError {
    cffi_wrapper!(|in_ext_status: WFToken| {
        let pool = &CONTEXT.ext_status_pool;
        Ok(pool.free(in_ext_status)?)
    })
}

#[unsafe(no_mangle)]
pub extern "C" fn WFExtStatusGetName(
    in_ext_status: in_param_ty!(WFToken),
    out_name: out_param_ty!(WFStrPtr),
) -> WFError {
    cffi_wrapper!(|in_ext_status: WFToken| -> (out_name: WFStrPtr) {
        let pool = &CONTEXT.ext_status_pool;
        let ext_status = pool.get(in_ext_status)?;

        Ok(cstr_ffi::push_ffi_string(ext_status.get_name())?)
    })
}

#[unsafe(no_mangle)]
pub extern "C" fn WFExtStatusGetIcon(
    in_ext_status: in_param_ty!(WFToken),
    out_icon: out_param_ty!(WFHICON),
) -> WFError {
    cffi_wrapper!(|in_ext_status: WFToken| -> (out_icon: WFHICON) {
        let pool = &CONTEXT.ext_status_pool;
        let ext_status = pool.get(in_ext_status)?;

        let icon = ext_status.get_icon();
        Ok(icon.get_icon())
    })
}

// endregion

// region: Self Extension Status

#[unsafe(no_mangle)]
pub extern "C" fn WFSelfExtStatusDestroy(in_self_ext_status: in_param_ty!(WFToken)) -> WFError {
    cffi_wrapper!(|in_self_ext_status: WFToken| {
        let pool = &CONTEXT.self_ext_status_pool;
        Ok(pool.free(in_self_ext_status)?)
    })
}

#[unsafe(no_mangle)]
pub extern "C" fn WFSelfExtStatusGetName(
    in_self_ext_status: in_param_ty!(WFToken),
    out_name: out_param_ty!(WFStrPtr),
) -> WFError {
    cffi_wrapper!(|in_self_ext_status: WFToken| -> (out_name: WFStrPtr) {
        let pool = &CONTEXT.self_ext_status_pool;
        let self_ext_status = pool.get(in_self_ext_status)?;

        Ok(cstr_ffi::push_ffi_string(self_ext_status.get_name())?)
    })
}

#[unsafe(no_mangle)]
pub extern "C" fn WFSelfExtStatusGetIcon(
    in_self_ext_status: in_param_ty!(WFToken),
    out_icon: out_param_ty!(WFHICON),
) -> WFError {
    cffi_wrapper!(|in_self_ext_status: WFToken| -> (out_icon: WFHICON) {
        let pool = &CONTEXT.self_ext_status_pool;
        let self_ext_status = pool.get(in_self_ext_status)?;

        let icon = self_ext_status.get_icon();
        Ok(icon.get_icon())
    })
}

#[unsafe(no_mangle)]
pub extern "C" fn WFSelfExtStatusGetExt(
    in_self_ext_status: in_param_ty!(WFToken),
    out_inner: out_param_ty!(WFStrPtr),
) -> WFError {
    cffi_wrapper!(|in_self_ext_status: WFToken| -> (out_inner: WFStrPtr) {
        let pool = &CONTEXT.self_ext_status_pool;
        let self_ext_status = pool.get(in_self_ext_status)?;

        Ok(cstr_ffi::push_ffi_string(self_ext_status.get_ext())?)
    })
}

#[unsafe(no_mangle)]
pub extern "C" fn WFSelfExtStatusGetDottedExt(
    in_self_ext_status: in_param_ty!(WFToken),
    out_inner: out_param_ty!(WFStrPtr),
) -> WFError {
    cffi_wrapper!(|in_self_ext_status: WFToken| -> (out_inner: WFStrPtr) {
        let pool = &CONTEXT.self_ext_status_pool;
        let self_ext_status = pool.get(in_self_ext_status)?;

        Ok(cstr_ffi::push_ffi_string(self_ext_status.get_dotted_ext().as_str())?)
    })
}

// endregion

// region: Icon Resource

#[unsafe(no_mangle)]
pub extern "C" fn WFIconRcDestroy(in_icon_rc: in_param_ty!(WFToken)) -> WFError {
    cffi_wrapper!(|in_icon_rc: WFToken| {
        let pool = &CONTEXT.icon_rc_pool;
        Ok(pool.free(in_icon_rc)?)
    })
}

#[unsafe(no_mangle)]
pub extern "C" fn WFIconRcGetIcon(
    in_icon_rc: in_param_ty!(WFToken),
    out_icon: out_param_ty!(WFHICON),
) -> WFError {
    cffi_wrapper!(|in_icon_rc: WFToken| -> (out_icon: WFHICON) {
        let pool = &CONTEXT.icon_rc_pool;
        let icon_rc = pool.get(in_icon_rc)?;

        Ok(icon_rc.get_icon())
    })
}

// endregion