use crate::app_interface::StaticData;
use crate::handling::cached_value::CachedValue;
use crate::handling::Cacheable;
use crate::{cached_value, ExternRef, ExternalReferenceType};
use alloc::rc::Rc;

struct DynamicLibraryInner {
    ptr: ExternRef<DynamicLibrary>,
    static_data: CachedValue<StaticData>,
}

#[derive(Clone)]
pub struct DynamicLibrary {
    inner: Rc<DynamicLibraryInner>,
}

crate::handling::cacheable::cacheable!(DynamicLibrary);

impl DynamicLibrary {
    #[cfg(not(feature = "mock_data"))]
    pub(crate) fn new(ptr: ExternRef<Self>) -> Self {
        Self::from_ref(ptr, &|ptr| Self {
            inner: Rc::new(DynamicLibraryInner {
                ptr,
                static_data: cached_value!({
                    dynamic_library_get_static_data(ptr).get_value().unwrap()
                }),
            }),
        })
    }

    #[cfg(feature = "mock_data")]
    pub fn new(data: StaticData) -> Self {
        Self {
            inner: Rc::new(DynamicLibraryInner {
                ptr: ExternRef::mock(),
                static_data: data.into(),
            }),
        }
    }

    pub fn data_library(&self) -> StaticData {
        self.inner.static_data.value()
    }
}

#[cfg(not(feature = "mock_data"))]
impl ExternalReferenceType for DynamicLibrary {
    fn from_extern_value(reference: ExternRef<Self>) -> Self {
        DynamicLibrary::new(reference)
    }
}

#[cfg(not(feature = "mock_data"))]
extern "wasm" {
    fn dynamic_library_get_static_data(ptr: ExternRef<DynamicLibrary>) -> ExternRef<StaticData>;
}