maudio 0.1.5

//! Resource manager
//!
//! The resource manager is Miniaudio’s asynchronous asset loader/decoder front-end.
//! It is designed to be used from **multiple threads**: internally it uses a
//! multi-producer / multi-consumer job queue plus background worker threads.
//!
//! In `maudio`, the resource manager is exposed in two forms:
//!
//! - [`ResourceManager`]: an owned, reference-counted handle (`Arc`) that is
//!   cheap to clone and can be shared across threads.
//! - [`ResourceManagerRef`]: a non-owning reference tied to a lifetime,
//!   primarily returned by other objects (e.g. the engine).
//!
//! ### PCM format choice
//!
//! Miniaudio’s resource manager can operate in different “native” PCM formats.
//! However, for various reasons, `maudio` requires selecting a concrete PCM format up-front
//! (most users should pick `f32`). The selected format becomes part of the type
//! (`ResourceManager<f32>`, `ResourceManager<i16>`, etc.) and all APIs can then
//! remain strongly typed.
//!
//! ## What is the resource manager (in Miniaudio)?
//!
//! Miniaudio’s resource manager (`ma_resource_manager`) is a high-level facility for
//! **loading audio assets** (files or in memory sounds) and exposing them as a standard
//! `ma_data_source`.
//!
//! Conceptually, it sits between “where the bytes come from” and “who plays/consumes
//! PCM frames”:
//!
//! - **I/O**: loads from files
//! - **Decoding**: can decode compressed formats into PCM, and can do this
//!   **asynchronously** using background worker threads.
//! - **Streaming vs. fully loaded**: can either stream from the source, or load the
//!   whole asset into memory (optionally decoded/uncompressed) depending on flags.
//! - **Uniform interface**: the thing you get back is “just a data source”, which means it
//!   plugs into the rest of Miniaudio anywhere a `ma_data_source` is accepted.
//!
//! In `maudio`, the resource manager primarily exists so you can:
//! - share one loader/decoder across many sounds,
//! - keep decoding/loading work off the audio callback thread,
//! - and unify “load from file / load from memory” behind the same typed API.
//!
//! ### Sharing a resource manager between multiple engines
//!
//! A resource manager is **not tied to a single engine**. In Miniaudio, an engine
//! can be configured to use an externally created `ma_resource_manager`, but it
//! does not own it.
//!
//! The same design applies in `maudio`:
//!
//! - You can create one [`ResourceManager<F>`].
//! - Attach it to multiple [`Engine`](crate::engine::Engine) instances.
//! - All engines will share the same loader, decoder threads, and asset cache.
//!
//! This is particularly useful when:
//!
//! - You have multiple output devices (e.g. different audio backends or test engines).
//! - You want a single shared asset cache across subsystems.
//! - You want to centralize asynchronous loading/decoding.
//!
//! ### Typical usage
//!
//! Create a resource manager, then attach it to an engine:
//!
//! ```rust,no_run
//! # use maudio::engine::engine_builder::EngineBuilder;
//! # use maudio::engine::resource::rm_builder::ResourceManagerBuilder;
//! # fn main() -> maudio::MaResult<()> {
//! let rm = ResourceManagerBuilder::new().build_f32()?;
//! let engine = EngineBuilder::new()
//!     .resource_manager(&rm)
//!     .build()?;
//! # Ok(())
//! # }
//! ```
//!
//! If you already have an engine, you can access its resource manager via
//! `engine.resource_manager()` which returns a borrowed [`ResourceManagerRef`].
//!
use std::{
    marker::PhantomData,
    mem::MaybeUninit,
    path::{Path, PathBuf},
    sync::Arc,
};

use maudio_sys::ffi as sys;

use crate::{
    audio::{
        formats::{Format, SampleBuffer},
        sample_rate::SampleRate,
    },
    data_source::{AsSourcePtr, SharedSource},
    engine::resource::{
        rm_buffer::{ResourceManagerBuffer, ResourceManagerBufferBuilder},
        rm_builder::ResourceManagerBuilder,
        rm_source::{ResourceManagerSource, ResourceManagerSourceBuilder},
        rm_source_flags::RmSourceFlags,
        rm_stream::{ResourceManagerStream, ResourceManagerStreamBuilder},
    },
    pcm_frames::{PcmFormat, PcmFormatInternal, S24Packed, S24},
    test_assets::wav_i16_le,
    AsRawRef, Binding, MaResult, MaudioError,
};

pub mod rm_buffer;
pub mod rm_builder;
pub mod rm_flags;
pub mod rm_notif;
pub mod rm_source;
pub mod rm_source_flags;
pub mod rm_stream;

/// An owned resource manager handle.
///
/// Besides configuring background loading/decoding, the resource manager also acts as a
/// **registry** for named resources. Registering a resource lets you later create
/// resource-backed data sources (buffer/stream/source) using Miniaudio’s internal cache
/// and job system.
///
/// ## Two Ways to Create Resource-Backed Audio
///
/// `maudio` supports two distinct workflows for creating resource-backed audio.
/// The difference is primarily about **who owns the backing data** and
/// whether you want **explicit lifetime control**.
///
/// ---------------------------------------------------------------------------
///
/// ## 1) Register First - Explicit Ownership Model
///
/// Use `register_*()` when:
/// - You already have audio data in memory (encoded or decoded),
/// - You want explicit control over the lifetime of a resource,
/// - You want to share a single registered asset across multiple sounds,
/// - You want to ensure caching behavior is clearly scoped.
///
/// Registering returns a [`ResourceGuard`]. While the guard is alive,
/// the resource remains registered inside the resource manager.
///
/// ### What gets registered?
///
/// - `register_file()`  
///   Registers a file path under the resource manager. The file itself is not
///   immediately loaded unless required, but the name is reserved and tracked.
///
/// - `register_decoded_*()`  
///   Registers already-decoded PCM frames.  
///   The memory remains owned by the caller. The resource manager will not copy
///   or free it. The caller must ensure it stays valid for the duration of use.
///
/// - `register_encoded()`  
///   Registers encoded/compressed bytes (e.g. mp3/ogg/flac).  
///   The memory remains caller-owned.
///
/// From the returned guard you can build:
/// - [`ResourceManagerBuffer`]  (fully buffered, typically decoded into memory)
/// - [`ResourceManagerStream`]  (streamed decode / read-ahead)
/// - [`ResourceManagerSource`]  (generic data source)
///
/// Dropping the guard unregisters the resource (after all active users are gone).
///
/// This workflow is recommended when:
/// - You manage your own assets,
/// - You want predictable lifetime semantics,
/// - You want to preload or alias resources explicitly.
///
/// ---------------------------------------------------------------------------
///
/// ## 2) Build Directly - Resource Manager Managed
///
/// You can also construct buffers/streams/sources directly from a file path
/// without calling `register_*()` first.
///
/// In this case:
/// - The resource manager opens and reads the file itself.
/// - For non-streaming buffers, the data may be cached internally and shared
///   across multiple builds of the same path.
/// - The resource manager owns and frees the loaded data.
///
/// This workflow is convenient for:
/// - One-off playback,
/// - Quick loading without explicit lifetime management.
///
/// Limitations:
/// - Cannot be used for audio already loaded in memory.
/// - Lifetime is implicit and resources are kept alive internally by reference counting.
///
/// ### Thread safety
///
/// `ResourceManager<F>` is cheap to clone and intended to be shared across threads.
///
/// Miniaudio documents `ma_resource_manager` as safe to use from multiple threads:
/// it uses a multi-producer/multi-consumer job queue and background job threads.
///
/// ### Format parameter
///
/// `F` is the resource manager’s native PCM format. This is chosen when building
/// the resource manager. Most applications, especially when used with an engine, should use `f32`.
///
/// ### Multiple engine support
///
/// A single `ResourceManager<F>` can be attached to multiple engines.
/// The underlying Miniaudio resource manager is independent of the engine,
/// and sharing it allows multiple engines to reuse the same job threads
/// and asset cache.
///
/// Use [`ResourceManagerBuilder`] to initialize.
#[derive(Clone, Debug)]
pub struct ResourceManager<F: PcmFormat> {
    inner: Arc<InnerResourceManager<F>>,
}

#[allow(dead_code)]
#[derive(Debug)]
pub(crate) struct InnerResourceManager<F: PcmFormat> {
    inner: *mut sys::ma_resource_manager,
    channels: Option<u32>,
    _format: PhantomData<F>,
}

// ma_resource_manager is intended to be used from multiple threads
// it uses a multi-producer/multi-consumer job queue and background job threads
// NOTE: Everything else added to the Rust struct needs to be Send and Sync!!!
unsafe impl<F: PcmFormat> Send for ResourceManager<F> {}
unsafe impl<F: PcmFormat> Sync for ResourceManager<F> {}

impl<F: PcmFormat> Binding for ResourceManager<F> {
    type Raw = *mut sys::ma_resource_manager;

    /// !!! unimplemented !!!
    fn from_ptr(_raw: Self::Raw) -> Self {
        unimplemented!()
    }

    fn to_raw(&self) -> Self::Raw {
        self.inner.inner
    }
}

/// A borrowed resource manager.
///
/// This is a lightweight non-owning view into an existing resource manager.
/// It is primarily returned by other objects (for example `Engine::resource_manager()`).
///
/// You typically do not construct this directly. If you need an owned handle that
/// can be cloned and moved between threads, use [`ResourceManager<F>`] instead.
///
/// The lifetime `'a` ties this reference to the owner that produced it.
///
/// ### Format parameter
///
/// `F` matches the native PCM format of the underlying resource manager.
/// In practice, this is determined by how the original resource manager was created.
pub struct ResourceManagerRef<'a, F: PcmFormat> {
    inner: *mut sys::ma_resource_manager,
    _format: PhantomData<F>,
    _marker: PhantomData<&'a ()>,
}

impl<F: PcmFormat> Binding for ResourceManagerRef<'_, F> {
    type Raw = *mut sys::ma_resource_manager;

    /// !!! unimplemented !!!
    fn from_ptr(raw: Self::Raw) -> Self {
        Self {
            inner: raw,
            _format: PhantomData,
            _marker: PhantomData,
        }
    }

    fn to_raw(&self) -> Self::Raw {
        self.inner
    }
}

pub(crate) mod private_rm {
    use super::*;
    use maudio_sys::ffi as sys;

    pub trait RmPtrProvider<T: ?Sized> {
        fn as_rm_ptr(t: &T) -> *mut sys::ma_resource_manager;
    }

    pub struct RmProvider;
    pub struct RmRefProvider;

    impl<F: PcmFormat> RmPtrProvider<ResourceManager<F>> for RmProvider {
        fn as_rm_ptr(t: &ResourceManager<F>) -> *mut sys::ma_resource_manager {
            t.to_raw()
        }
    }

    impl<F: PcmFormat> RmPtrProvider<ResourceManagerRef<'_, F>> for RmRefProvider {
        fn as_rm_ptr(t: &ResourceManagerRef<'_, F>) -> *mut sys::ma_resource_manager {
            t.to_raw()
        }
    }

    pub fn rm_ptr<T: AsRmPtr + ?Sized>(t: &T) -> *mut sys::ma_resource_manager {
        <T as AsRmPtr>::__PtrProvider::as_rm_ptr(t)
    }
}

#[doc(hidden)]
pub trait AsRmPtr {
    type __PtrProvider: private_rm::RmPtrProvider<Self>;
    type Format: PcmFormat;
}

impl<F: PcmFormat> AsRmPtr for ResourceManager<F> {
    type __PtrProvider = private_rm::RmProvider;
    type Format = F;
}

impl<F: PcmFormat> AsRmPtr for ResourceManagerRef<'_, F> {
    type __PtrProvider = private_rm::RmRefProvider;
    type Format = F;
}

/// Keeps a resource manager registration alive.
///
/// A `ResourceGuard` is returned by `ResourceManager::register_*()` calls.
/// While the guard exists, the registered resource remains available to the resource manager,
/// and you can create one or more data [`ResourceManagerBuffer`], [`ResourceManagerStream`], or
/// [`ResourceManagerSource`] values from it via `build_buffer/build_stream/build_source`.
///
/// This is the primary workflow for memory-backed resources, including audio
/// data that already exists in memory before being handed to the resource
/// manager.
///
/// The guard may also hold ownership of the underlying bytes (for conversions done by maudio).
///
/// # Typical workflow
///
/// 1. Register data with `register_*()`.
/// 2. Keep the returned `ResourceGuard` alive.
/// 3. Build buffers, streams, or sources from the guard.
///
/// Dropping the guard unregisters the resource once it is no longer in active use.
#[allow(dead_code)]
pub struct ResourceGuard<'a, R: AsRmPtr + ?Sized> {
    rm: &'a R,
    data_name: RegisteredDataType,
    data_store: Option<Arc<[u8]>>,
    _data_marker: PhantomData<&'a [u8]>,
}

// Builders for registered resources
impl<'a, R: AsRmPtr> ResourceGuard<'a, R> {
    /// Builds a [`ResourceManagerBuffer`] from a previously registered file path or
    /// resource.
    ///
    /// This builder is intended for direct resource-manager loading from a path,
    /// or for creating a buffer from a resource that was already registered with
    /// `ResourceManager::register_*()`.
    ///
    /// It does not itself register raw in-memory audio data. For memory-backed
    /// resources, register them first and then use [`ResourceGuard::build_buffer`].
    /// ## Flags:
    ///
    /// - [`RmSourceFlags::LOOPING`] to enable looping
    /// - [`RmSourceFlags::WAIT_INIT`]
    ///   Only meaningful with [`RmSourceFlags::ASYNC`]. When set, blocks until the
    ///   initial async initialization/prefill step completes before returning.
    /// - [`RmSourceFlags::ASYNC`]
    ///   Initialize and prefill the stream asynchronously using the resource manager’s worker threads.
    /// - [`RmSourceFlags::STREAM`] flag is ignored by maudio
    pub fn build_buffer(
        &'a self,
        flags: RmSourceFlags,
    ) -> MaResult<PendingResource<ResourceManagerBuffer<'a, R>>> {
        let mut builder = ResourceManagerBufferBuilder::new(self.rm);
        let mut flags_check = flags;
        if flags_check.intersects(RmSourceFlags::STREAM) {
            flags_check.remove(RmSourceFlags::STREAM);
        }
        builder.flags(flags_check);
        match &self.data_name {
            RegisteredDataType::RegisteredPath { path } => builder.file_path(path),
            RegisteredDataType::RegisteredData { name } => builder.file_path(Path::new(name)),
        };
        let resource = builder.build_internal()?;
        if flags_check.intersects(RmSourceFlags::ASYNC) {
            return Ok(PendingResource::Pending {
                inner: Some(resource),
            });
        }
        Ok(PendingResource::Ready { inner: resource })
    }

    /// Builds a [`ResourceManagerStream`] for streaming a file-backed resource.
    ///
    /// This builder creates a stream from a file path, or from a resource that was
    /// previously registered from a file-backed input.
    ///
    /// Streaming is intended for resources that can be read on demand by the
    /// resource manager. It does not register new data with the resource manager.
    ///
    /// In-memory registrations are not suitable for streaming. If a resource was
    /// registered from in-memory data (decoded or encoded), [`ResourceGuard::build_stream`]
    /// is not supported and will return an error.
    ///
    /// ## Flags:
    ///
    /// - [`RmSourceFlags::LOOPING`] to enable looping
    /// - [`RmSourceFlags::WAIT_INIT`]
    ///   Only meaningful with [`RmSourceFlags::ASYNC`]. When set, blocks until the
    ///   initial async initialization/prefill step completes before returning.
    /// - [`RmSourceFlags::ASYNC`]
    ///   Initialize and prefill the stream asynchronously using the resource manager’s worker threads.
    /// - [`RmSourceFlags::STREAM`] flag is ignored by maudio
    pub fn build_stream(
        &'a self,
        flags: RmSourceFlags,
    ) -> MaResult<PendingResource<ResourceManagerStream<'a, R>>> {
        let mut builder = ResourceManagerStreamBuilder::new(self.rm);
        let mut flags_check = flags;
        if !flags_check.intersects(RmSourceFlags::STREAM) {
            flags_check.insert(RmSourceFlags::STREAM);
        }
        builder.flags(flags_check);
        match &self.data_name {
            RegisteredDataType::RegisteredPath { path } => builder.file_path(path),
            RegisteredDataType::RegisteredData { name } => builder.file_path(Path::new(name)),
        };
        let resource = builder.build_internal()?;
        if flags_check.intersects(RmSourceFlags::ASYNC) {
            return Ok(PendingResource::Pending {
                inner: Some(resource),
            });
        }
        Ok(PendingResource::Ready { inner: resource })
    }

    /// Builds a [`ResourceManagerSource`] from a previously registered file path or
    /// resource.
    ///
    /// This builder is intended for direct resource-manager loading from a path,
    /// or for creating a source from a resource that was already registered with
    /// `ResourceManager::register_*()`.
    ///
    /// It does not itself register raw in-memory audio data. For memory-backed
    /// resources, register them first and then use [`ResourceGuard::build_source`].
    /// ## Flags:
    /// Under the hood, this type is either `ResourceManagerBuffer` or `ResourceManagerStream`.
    ///
    /// `ResourceManagerSource` is an abstraction and underlying type can be chosen using the `STREAM` flag.
    ///
    /// - [`RmSourceFlags::LOOPING`] to enable looping
    /// - [`RmSourceFlags::WAIT_INIT`]
    ///   Only meaningful with [`RmSourceFlags::ASYNC`]. When set, blocks until the
    ///   initial async initialization/prefill step completes before returning.
    /// - [`RmSourceFlags::ASYNC`]
    ///   Initialize and prefill the stream asynchronously using the resource manager’s worker threads.
    /// - [`RmSourceFlags::STREAM`]
    ///   If this flag is passed, this source will be initialized as a `ResourceManagerStream`.
    ///   Without this flag, it be initialized as a `ResourceManagerBuffer`
    pub fn build_source(
        &'a self,
        flags: RmSourceFlags,
    ) -> MaResult<PendingResource<ResourceManagerSource<'a, R>>> {
        let mut builder = ResourceManagerSourceBuilder::new(self.rm);

        builder.flags(flags);
        match &self.data_name {
            RegisteredDataType::RegisteredPath { path } => builder.file_path(path),
            RegisteredDataType::RegisteredData { name } => builder.file_path(Path::new(name)),
        };
        let resource = builder.build_internal()?;
        if flags.intersects(RmSourceFlags::ASYNC) {
            return Ok(PendingResource::Pending {
                inner: Some(resource),
            });
        }
        Ok(PendingResource::Ready { inner: resource })
    }
}

// Private methods
impl<'a, R: AsRmPtr + ?Sized> ResourceGuard<'a, R> {
    pub(crate) fn from_path(rm: &'a R, path: &Path) -> Self {
        Self {
            rm,
            data_name: RegisteredDataType::RegisteredPath {
                path: path.to_path_buf(),
            },
            data_store: None,
            _data_marker: PhantomData,
        }
    }

    pub(crate) fn from_data(rm: &'a R, name: &str, data: Option<Arc<[u8]>>) -> Self {
        Self {
            rm,
            data_name: RegisteredDataType::RegisteredData {
                name: name.to_string(),
            },
            data_store: data,
            _data_marker: PhantomData,
        }
    }
}

impl<R: AsRmPtr + ?Sized> Drop for ResourceGuard<'_, R> {
    fn drop(&mut self) {
        match &self.data_name {
            RegisteredDataType::RegisteredData { name } => {
                let _ = resource_ffi::ma_resource_manager_unregister_data_internal(self.rm, name);
            }
            RegisteredDataType::RegisteredPath { path } => {
                let _ = resource_ffi::ma_resource_manager_unregister_file_internal(self.rm, path);
            }
        }
    }
}

enum RegisteredDataType {
    RegisteredPath { path: PathBuf },
    RegisteredData { name: String },
}

/// Result of building a resource-manager data source.
///
/// When asynchronous loading is enabled, the resource may not be ready
/// immediately. In that case, this type represents the current state
/// of the resource.
///
/// # States
///
/// - [`PendingResource::Ready`]   - The resource is fully initialized and ready for use.
/// - [`PendingResource::Pending`] - The resource is still being loaded or initialized (`MA_BUSY`).
/// - [`PendingResource::Failed`]  - The operation failed with an error.
///
/// # Async workflow
///
/// When async flags are used, builders return [`PendingResource::Pending`].
/// The resource can then be handled in one of two ways:
///
/// ## 1. Polling (this type)
///
/// Call [`PendingResource::poll_ready`] periodically until the resource
/// becomes ready.
///
/// ```ignore
/// # let mut pending = todo!();
/// while !pending.poll_ready()? {
///     // do other work
/// }
///
/// let resource = pending.into_ready().unwrap();
/// ```
///
/// ## 2. Fence-based notification
///
/// Instead of polling, you can attach a [`NotificationPipeline`](crate::engine::resource::rm_notif::NotificationPipeline) with a [`Fence`](crate::util::fence::Fence)
/// to be notified when the resource finishes loading.
///
/// This avoids repeated polling and allows integration with your own
/// synchronization or event systems.
///
/// ```ignore
/// # let rm = todo!();
/// # let path = todo!();
/// let fence = Fence::new();
///
/// let notif = NotificationPipelineBuilder::new().done_with_fence(&fence).build();
///
/// let pending = ResourceManagerBufferBuilder::new(&rm)
///     .notification(notif.clone())
///     .build()?;
///
/// // Block until the resource is fully ready
/// fence.wait()?;
///
/// // Now safe to extract the resource
/// let resource = pending.into_ready().unwrap();
/// ```
///
/// # Notes
///
/// - [`PendingResource`] is the Rust-side state wrapper for the resource.
/// - [`NotificationPipeline`](crate::engine::resource::rm_notif::NotificationPipeline) is an optional signaling mechanism.
/// - These can be used independently or together.
/// - In most cases, users should use a fence on the `done` stage to detect
///   when the resource is fully ready.
pub enum PendingResource<B: AsAsyncSource> {
    /// MA_SUCCESS
    Ready { inner: B },
    /// MA_BUSY
    Pending { inner: Option<B> },
    /// Other Error
    Failed(MaudioError),
}

// TODO: Derive PartialEq for PendingResource?

impl<B: AsAsyncSource> std::fmt::Debug for PendingResource<B> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::Ready { .. } => f.write_str("PendingResource::Ready(..)"),
            Self::Pending { .. } => f.write_str("PendingResource::Pending(..)"),
            Self::Failed(e) => f.debug_tuple("PendingResource::Failed").field(e).finish(),
        }
    }
}

impl<B: AsAsyncSource> PendingResource<B> {
    /// Polls the resource.
    ///
    /// Returns:
    /// - **Ok(true)** => resource is ready (or was already ready and no polling was done).
    /// - **Ok(false)** => resource pending (BUSY)
    /// - **Err(e)** => Failed (and cached)
    ///
    /// **Do not spin loop. Use [`NotificationPipeline`](crate::engine::resource::rm_notif::NotificationPipeline) instead.**
    pub fn poll_ready(&mut self) -> MaResult<bool> {
        match self {
            PendingResource::Ready { inner: _ } => Ok(true),
            PendingResource::Pending { inner } => {
                if let Some(buf) = inner {
                    match private_async_src::result_check(buf) {
                        Ok(_) => {
                            let inner = inner.take();
                            *self = PendingResource::Ready {
                                inner: inner.unwrap(),
                            }; // unwrap is guaranteed to not panic
                            Ok(true)
                        }
                        Err(e) if e.is_busy() => Ok(false),
                        Err(e) => {
                            *self = PendingResource::Failed(e);
                            Err(e)
                        }
                    }
                } else {
                    unreachable!()
                }
            }
            PendingResource::Failed(e) => Err(*e),
        }
    }

    /// Checks if the resource is available. **Does not poll**.
    pub fn is_ready(&self) -> bool {
        matches!(self, PendingResource::Ready { inner: _ })
    }

    /// Returns a reference to the resource, if ready. **Does not poll**.
    pub fn as_ready(&self) -> Option<&B> {
        match self {
            PendingResource::Ready { inner } => Some(inner),
            _ => None,
        }
    }

    /// Returns a mutable reference to the resource, if ready. **Does not poll**.
    pub fn as_read_mut(&mut self) -> Option<&mut B> {
        match self {
            PendingResource::Ready { inner } => Some(inner),
            _ => None,
        }
    }

    /// Consumes the guard and returns the resource, if ready, otherwise returns self. **Does not poll**.
    pub fn into_ready(self) -> Result<B, Self> {
        match self {
            PendingResource::Ready { inner } => Ok(inner),
            other => Err(other),
        }
    }
}

mod private_async_src {
    use super::*;

    pub trait AsyncCheckProvider<T: ?Sized> {
        fn as_result_check(t: &T) -> MaResult<()>;
    }

    pub struct SourceCheckProvider;
    pub struct BufferCheckProvider;
    pub struct StreamCheckProvider;

    impl<'a, R: AsRmPtr> AsyncCheckProvider<ResourceManagerSource<'a, R>> for SourceCheckProvider {
        fn as_result_check(t: &ResourceManagerSource<'a, R>) -> MaResult<()> {
            resource_ffi::ma_resource_manager_data_source_result(t)
        }
    }

    impl<'a, R: AsRmPtr> AsyncCheckProvider<ResourceManagerBuffer<'a, R>> for BufferCheckProvider {
        fn as_result_check(t: &ResourceManagerBuffer<'a, R>) -> MaResult<()> {
            resource_ffi::ma_resource_manager_data_buffer_result(t)
        }
    }

    impl<'a, R: AsRmPtr> AsyncCheckProvider<ResourceManagerStream<'a, R>> for StreamCheckProvider {
        fn as_result_check(t: &ResourceManagerStream<'a, R>) -> MaResult<()> {
            resource_ffi::ma_resource_manager_data_stream_result(t)
        }
    }

    pub fn result_check<T: AsAsyncSource + ?Sized>(t: &T) -> MaResult<()> {
        <T as AsAsyncSource>::__ResultProvider::as_result_check(t)
    }
}

/// Unifies async result checks across sources.
pub trait AsAsyncSource: AsSourcePtr + SharedSource {
    type __ResultProvider: private_async_src::AsyncCheckProvider<Self>;
}

impl<'a, R: AsRmPtr> AsAsyncSource for ResourceManagerSource<'a, R> {
    type __ResultProvider = private_async_src::SourceCheckProvider;
}
impl<'a, R: AsRmPtr> AsAsyncSource for ResourceManagerBuffer<'a, R> {
    type __ResultProvider = private_async_src::BufferCheckProvider;
}
impl<'a, R: AsRmPtr> AsAsyncSource for ResourceManagerStream<'a, R> {
    type __ResultProvider = private_async_src::StreamCheckProvider;
}

impl<F: PcmFormat> RmOps for ResourceManager<F> {}
impl<F: PcmFormat> RmOps for ResourceManagerRef<'_, F> {}

/// Methods shared between [`ResourceManager`] and [`ResourceManagerRef`]
pub trait RmOps: AsRmPtr {
    /// The [`RmSourceFlags`] used are:
    /// - [`RmSourceFlags::WAIT_INIT`] -
    ///   Only meaningful with [`RmSourceFlags::ASYNC`]. When set, blocks until the
    ///   async initialization step has completed before returning.
    ///   This does not necessarily wait for the entire file to be decoded.
    /// - [`RmSourceFlags::ASYNC`] -
    ///   Perform loading/decoding work on the resource manager’s background threads.
    ///   Without this flag, registration performs the work synchronously.
    ///   (If the resource manager has threading disabled, this flag is ignored.)
    /// - [`RmSourceFlags::DECODE`] -
    ///   Decode and cache PCM during registration instead of deferring
    ///   decoding until the resource is initialized or read.
    fn register_file<'a>(
        &'a self,
        path: &Path,
        flags: RmSourceFlags,
    ) -> MaResult<ResourceGuard<'a, Self>> {
        #[cfg(unix)]
        {
            use crate::engine::cstring_from_path;

            let c_path = cstring_from_path(path)?;
            resource_ffi::ma_resource_manager_register_file(self, c_path, flags)?;
            Ok(ResourceGuard::from_path(self, path))
        }

        #[cfg(windows)]
        {
            use crate::engine::wide_null_terminated;

            let c_path = wide_null_terminated(path);

            resource_ffi::ma_resource_manager_register_file_w(self, &c_path, flags)?;
            Ok(ResourceGuard::from_path(self, path))
        }

        #[cfg(not(any(unix, windows)))]
        compile_error!("init decoder from file is only supported on unix and windows");
    }

    /// The [`RmSourceFlags`] used are:
    /// - [`RmSourceFlags::WAIT_INIT`] -
    ///   Only meaningful with [`RmSourceFlags::ASYNC`]. When set, blocks until the
    ///   async initialization step has completed before returning.
    ///   This does not necessarily wait for the entire file to be decoded.
    /// - [`RmSourceFlags::ASYNC`] -
    ///   Perform loading/decoding work on the resource manager’s background threads.
    ///   Without this flag, registration performs the work synchronously.
    ///   (If the resource manager has threading disabled, this flag is ignored.)
    /// - [`RmSourceFlags::DECODE`] -
    ///   Decode and cache PCM during registration instead of deferring
    ///   decoding until the resource is initialized or read.
    fn register_decoded_u8<'a>(
        &'a self,
        name: &str,
        data: &'a [u8],
        channels: u32,
        sample_rate: SampleRate,
    ) -> MaResult<ResourceGuard<'a, Self>> {
        resource_ffi::ma_resource_manager_register_decoded_data_internal::<u8, Self>(
            self,
            name,
            data,
            Format::U8,
            channels,
            sample_rate,
        )?;
        Ok(ResourceGuard::from_data(self, name, None))
    }

    /// The [`RmSourceFlags`] used are:
    /// - [`RmSourceFlags::WAIT_INIT`] -
    ///   Only meaningful with [`RmSourceFlags::ASYNC`]. When set, blocks until the
    ///   async initialization step has completed before returning.
    ///   This does not necessarily wait for the entire file to be decoded.
    /// - [`RmSourceFlags::ASYNC`] -
    ///   Perform loading/decoding work on the resource manager’s background threads.
    ///   Without this flag, registration performs the work synchronously.
    ///   (If the resource manager has threading disabled, this flag is ignored.)
    /// - [`RmSourceFlags::DECODE`] -
    ///   Decode and cache PCM during registration instead of deferring
    ///   decoding until the resource is initialized or read.
    fn register_decoded_i16<'a>(
        &'a self,
        name: &str,
        data: &'a [i16],
        channels: u32,
        sample_rate: SampleRate,
    ) -> MaResult<ResourceGuard<'a, Self>> {
        resource_ffi::ma_resource_manager_register_decoded_data_internal::<i16, Self>(
            self,
            name,
            data,
            Format::S16,
            channels,
            sample_rate,
        )?;
        Ok(ResourceGuard::from_data(self, name, None))
    }

    /// The [`RmSourceFlags`] used are:
    /// - [`RmSourceFlags::WAIT_INIT`] -
    ///   Only meaningful with [`RmSourceFlags::ASYNC`]. When set, blocks until the
    ///   async initialization step has completed before returning.
    ///   This does not necessarily wait for the entire file to be decoded.
    /// - [`RmSourceFlags::ASYNC`] -
    ///   Perform loading/decoding work on the resource manager’s background threads.
    ///   Without this flag, registration performs the work synchronously.
    ///   (If the resource manager has threading disabled, this flag is ignored.)
    /// - [`RmSourceFlags::DECODE`] -
    ///   Decode and cache PCM during registration instead of deferring
    ///   decoding until the resource is initialized or read.
    fn register_decoded_i32<'a>(
        &'a self,
        name: &str,
        data: &'a [i32],
        channels: u32,
        sample_rate: SampleRate,
    ) -> MaResult<ResourceGuard<'a, Self>> {
        resource_ffi::ma_resource_manager_register_decoded_data_internal::<i32, Self>(
            self,
            name,
            data,
            Format::S32,
            channels,
            sample_rate,
        )?;
        Ok(ResourceGuard::from_data(self, name, None))
    }

    /// The [`RmSourceFlags`] used are:
    /// - [`RmSourceFlags::WAIT_INIT`] -
    ///   Only meaningful with [`RmSourceFlags::ASYNC`]. When set, blocks until the
    ///   async initialization step has completed before returning.
    ///   This does not necessarily wait for the entire file to be decoded.
    /// - [`RmSourceFlags::ASYNC`] -
    ///   Perform loading/decoding work on the resource manager’s background threads.
    ///   Without this flag, registration performs the work synchronously.
    ///   (If the resource manager has threading disabled, this flag is ignored.)
    /// - [`RmSourceFlags::DECODE`] -
    ///   Decode and cache PCM during registration instead of deferring
    ///   decoding until the resource is initialized or read.
    fn register_decoded_s24_packed<'a>(
        &'a self,
        name: &str,
        data: &'a [u8],
        channels: u32,
        sample_rate: SampleRate,
    ) -> MaResult<ResourceGuard<'a, Self>> {
        resource_ffi::ma_resource_manager_register_decoded_data_internal::<S24Packed, Self>(
            self,
            name,
            data,
            Format::S24Packed,
            channels,
            sample_rate,
        )?;
        Ok(ResourceGuard::from_data(self, name, None))
    }

    /// The [`RmSourceFlags`] used are:
    /// - [`RmSourceFlags::WAIT_INIT`] -
    ///   Only meaningful with [`RmSourceFlags::ASYNC`]. When set, blocks until the
    ///   async initialization step has completed before returning.
    ///   This does not necessarily wait for the entire file to be decoded.
    /// - [`RmSourceFlags::ASYNC`] -
    ///   Perform loading/decoding work on the resource manager’s background threads.
    ///   Without this flag, registration performs the work synchronously.
    ///   (If the resource manager has threading disabled, this flag is ignored.)
    /// - [`RmSourceFlags::DECODE`] -
    ///   Decode and cache PCM during registration instead of deferring
    ///   decoding until the resource is initialized or read.
    fn register_decoded_s24<'a>(
        &'a self,
        name: &str,
        data: &[i32],
        channels: u32,
        sample_rate: SampleRate,
    ) -> MaResult<ResourceGuard<'a, Self>> {
        if channels == 0 {
            return Err(crate::MaudioError::from_ma_result(
                sys::ma_result_MA_INVALID_ARGS,
            ));
        }

        let data_len = data.len();
        if data_len % channels as usize != 0 {
            return Err(crate::MaudioError::new_ma_error(
                crate::ErrorKinds::InvalidDecodedDataLength,
            ));
        }

        let frames = data_len / channels as usize;
        let mut dst = SampleBuffer::<S24>::new_zeroed(frames, channels)?;
        <S24 as PcmFormatInternal>::write_to_storage_internal(
            &mut dst,
            data,
            frames,
            channels as usize,
        )?;
        resource_ffi::ma_resource_manager_register_decoded_data_internal::<S24Packed, Self>(
            self,
            name,
            &dst,
            Format::S24Packed,
            channels,
            sample_rate,
        )?;
        Ok(ResourceGuard::from_data(self, name, Some(dst.into())))
    }

    /// The [`RmSourceFlags`] used are:
    /// - [`RmSourceFlags::WAIT_INIT`] -
    ///   Only meaningful with [`RmSourceFlags::ASYNC`]. When set, blocks until the
    ///   async initialization step has completed before returning.
    ///   This does not necessarily wait for the entire file to be decoded.
    /// - [`RmSourceFlags::ASYNC`] -
    ///   Perform loading/decoding work on the resource manager’s background threads.
    ///   Without this flag, registration performs the work synchronously.
    ///   (If the resource manager has threading disabled, this flag is ignored.)
    /// - [`RmSourceFlags::DECODE`] -
    ///   Decode and cache PCM during registration instead of deferring
    ///   decoding until the resource is initialized or read.
    fn register_decoded_f32<'a>(
        &'a self,
        name: &str,
        data: &'a [f32],
        channels: u32,
        sample_rate: SampleRate,
    ) -> MaResult<ResourceGuard<'a, Self>> {
        resource_ffi::ma_resource_manager_register_decoded_data_internal::<f32, Self>(
            self,
            name,
            data,
            Format::F32,
            channels,
            sample_rate,
        )?;
        Ok(ResourceGuard::from_data(self, name, None))
    }

    /// Registers encoded/compressed audio bytes under a name.
    ///
    /// This only stores the provided bytes in the resource manager under `name`.
    /// No [`RmSourceFlags`] are applied at registration time because the underlying
    /// Miniaudio API does not accept flags for this operation.
    fn register_encoded<'a>(
        &'a self,
        name: &str,
        data: &'a [u8],
    ) -> MaResult<ResourceGuard<'a, Self>> {
        resource_ffi::ma_resource_manager_register_encoded_data_internal(self, name, data)?;
        Ok(ResourceGuard::from_data(self, name, None))
    }
}

impl<F: PcmFormat> ResourceManager<F> {
    fn new_with_config(config: &ResourceManagerBuilder) -> MaResult<Self> {
        let mut mem: Box<MaybeUninit<sys::ma_resource_manager>> = Box::new(MaybeUninit::uninit());

        resource_ffi::ma_resource_manager_init(config.as_raw_ptr(), mem.as_mut_ptr())?;

        let inner: *mut sys::ma_resource_manager =
            Box::into_raw(mem) as *mut sys::ma_resource_manager;

        Ok(Self {
            inner: Arc::new(InnerResourceManager {
                inner,
                channels: None,
                _format: PhantomData,
            }),
        })
    }
}

pub(crate) mod resource_ffi {
    use std::path::Path;

    use crate::{
        audio::{
            channels::Channel,
            formats::{Format, SampleBuffer},
            sample_rate::SampleRate,
        },
        data_source::{DataFormat, DataSourceOps},
        engine::resource::{
            private_rm,
            rm_buffer::{ResourceManagerBuffer, ResourceManagerBufferBuilder},
            rm_source::{ResourceManagerSource, ResourceManagerSourceBuilder},
            rm_source_flags::RmSourceFlags,
            rm_stream::{ResourceManagerStream, ResourceManagerStreamBuilder},
            AsRmPtr, InnerResourceManager, ResourceManager,
        },
        pcm_frames::PcmFormat,
        Binding, MaResult, MaudioError,
    };
    use crate::{AsRawRef, ErrorKinds};

    use maudio_sys::ffi as sys;

    #[inline]
    pub fn ma_resource_manager_init(
        config: *const sys::ma_resource_manager_config,
        rm: *mut sys::ma_resource_manager,
    ) -> MaResult<()> {
        let res = unsafe { sys::ma_resource_manager_init(config, rm) };
        MaudioError::check(res)?;
        Ok(())
    }

    #[inline]
    pub fn ma_resource_manager_uninit<F: PcmFormat>(rm: &mut InnerResourceManager<F>) {
        unsafe {
            sys::ma_resource_manager_uninit(rm.inner);
        }
    }

    // TODO: Implement Log
    #[inline]
    #[allow(dead_code)]
    pub fn ma_resource_manager_get_log<F: PcmFormat>(
        rm: &mut ResourceManager<F>,
    ) -> Option<*mut sys::ma_log> {
        let ptr = unsafe { sys::ma_resource_manager_get_log(rm.to_raw()) };
        if ptr.is_null() {
            None
        } else {
            Some(ptr)
        }
    }

    // REGISTRATION

    #[inline]
    #[cfg(unix)]
    pub fn ma_resource_manager_register_file<R: AsRmPtr + ?Sized>(
        rm: &R,
        path: std::ffi::CString,
        flags: RmSourceFlags,
    ) -> MaResult<()> {
        let res = unsafe {
            use crate::engine::resource::private_rm;
            sys::ma_resource_manager_register_file(
                private_rm::rm_ptr(rm),
                path.as_ptr(),
                flags.bits(),
            )
        };
        MaudioError::check(res)?;
        Ok(())
    }

    #[inline]
    #[cfg(windows)]
    pub fn ma_resource_manager_register_file_w<R: AsRmPtr + ?Sized>(
        rm: &R,
        path: &[u16],
        flags: RmSourceFlags,
    ) -> MaResult<()> {
        let res = unsafe {
            sys::ma_resource_manager_register_file_w(
                private_rm::rm_ptr(rm),
                path.as_ptr(),
                flags.bits(),
            )
        };
        MaudioError::check(res)?;
        Ok(())
    }

    // Different from the miniaudio `static ma_result ma_resource_manager_register_decoded_data_internal`
    pub fn ma_resource_manager_register_decoded_data_internal<F: PcmFormat, R: AsRmPtr + ?Sized>(
        rm: &R,
        name: &str,
        data: &[F::StorageUnit],
        format: Format,
        channels: u32,
        sample_rate: SampleRate,
    ) -> MaResult<()> {
        if channels == 0 {
            return Err(MaudioError::from_ma_result(sys::ma_result_MA_INVALID_ARGS));
        }

        let data_len = data.len();

        let units_per_frame = (channels as usize)
            .checked_mul(F::VEC_PCM_UNITS_PER_FRAME)
            .ok_or(MaudioError::new_ma_error(ErrorKinds::IntegerOverflow {
                op: "Units per frames",
                lhs: channels as u64,
                rhs: F::VEC_PCM_UNITS_PER_FRAME as u64,
            }))?;

        if data_len % units_per_frame != 0 {
            return Err(crate::MaudioError::new_ma_error(
                crate::ErrorKinds::InvalidDecodedDataLength,
            ));
        }

        let frame_count = (data_len / units_per_frame) as u64;

        #[cfg(unix)]
        {
            let name = std::ffi::CString::new(name)
                .map_err(|_| crate::MaudioError::new_ma_error(crate::ErrorKinds::InvalidCString))?;
            ma_resource_manager_register_decoded_data(
                rm,
                name.as_ptr(),
                data.as_ptr() as *const _,
                frame_count,
                format,
                channels,
                sample_rate,
            )
        }
        #[cfg(windows)]
        {
            use crate::engine::wide_null_terminated_name;

            let name = wide_null_terminated_name(name);
            ma_resource_manager_register_decoded_data_w(
                rm,
                &name,
                data.as_ptr() as *const _,
                frame_count,
                format,
                channels,
                sample_rate,
            )
        }

        #[cfg(not(any(unix, windows)))]
        compile_error!("init decoder from file is only supported on unix and windows");
    }

    #[inline]
    #[cfg(unix)]
    fn ma_resource_manager_register_decoded_data<R: AsRmPtr + ?Sized>(
        rm: &R,
        name: *const core::ffi::c_char,
        data: *const core::ffi::c_void,
        frame_count: u64,
        format: Format,
        channels: u32,
        sample_rate: SampleRate,
    ) -> MaResult<()> {
        let res = unsafe {
            sys::ma_resource_manager_register_decoded_data(
                private_rm::rm_ptr(rm),
                name,
                data,
                frame_count,
                format.into(),
                channels,
                sample_rate.into(),
            )
        };
        MaudioError::check(res)?;
        Ok(())
    }

    #[inline]
    #[cfg(windows)]
    fn ma_resource_manager_register_decoded_data_w<R: AsRmPtr + ?Sized>(
        rm: &R,
        name: &[u16],
        data: *const core::ffi::c_void,
        frame_count: u64,
        format: Format,
        channels: u32,
        sample_rate: SampleRate,
    ) -> MaResult<()> {
        let res = unsafe {
            sys::ma_resource_manager_register_decoded_data_w(
                private_rm::rm_ptr(rm),
                name.as_ptr(),
                data,
                frame_count,
                format.into(),
                channels,
                sample_rate.into(),
            )
        };
        MaudioError::check(res)?;
        Ok(())
    }

    pub fn ma_resource_manager_register_encoded_data_internal<R: AsRmPtr + ?Sized>(
        rm: &R,
        name: &str,
        data: &[u8],
    ) -> MaResult<()> {
        #[cfg(unix)]
        {
            let name = std::ffi::CString::new(name)
                .map_err(|_| crate::MaudioError::new_ma_error(crate::ErrorKinds::InvalidCString))?;
            ma_resource_manager_register_encoded_data(
                rm,
                name.as_ptr(),
                data.as_ptr() as *const _,
                data.len(),
            )
        }
        #[cfg(windows)]
        {
            use crate::engine::wide_null_terminated_name;

            let name = wide_null_terminated_name(name);
            ma_resource_manager_register_encoded_data_w(
                rm,
                &name,
                data.as_ptr() as *const _,
                data.len(),
            )
        }

        #[cfg(not(any(unix, windows)))]
        compile_error!("init decoder from file is only supported on unix and windows");
    }

    #[inline]
    #[cfg(unix)]
    fn ma_resource_manager_register_encoded_data<R: AsRmPtr + ?Sized>(
        rm: &R,
        name: *const core::ffi::c_char,
        data: *const core::ffi::c_void,
        size: usize,
    ) -> MaResult<()> {
        let res = unsafe {
            sys::ma_resource_manager_register_encoded_data(private_rm::rm_ptr(rm), name, data, size)
        };
        MaudioError::check(res)?;
        Ok(())
    }

    #[inline]
    #[cfg(windows)]
    fn ma_resource_manager_register_encoded_data_w<R: AsRmPtr + ?Sized>(
        rm: &R,
        name: &[u16],
        data: *const core::ffi::c_void,
        size: usize,
    ) -> MaResult<()> {
        let res = unsafe {
            sys::ma_resource_manager_register_encoded_data_w(
                private_rm::rm_ptr(rm),
                name.as_ptr(),
                data,
                size,
            )
        };
        MaudioError::check(res)?;
        Ok(())
    }

    pub fn ma_resource_manager_unregister_file_internal<R: AsRmPtr + ?Sized>(
        rm: &R,
        path: &Path,
    ) -> MaResult<()> {
        #[cfg(unix)]
        {
            use crate::engine::cstring_from_path;

            let c_path = cstring_from_path(path)?;
            ma_resource_manager_unregister_file(rm, c_path)
        }
        #[cfg(windows)]
        {
            use crate::engine::wide_null_terminated;

            let c_path = wide_null_terminated(path);
            ma_resource_manager_unregister_file_w(rm, &c_path)
        }

        #[cfg(not(any(unix, windows)))]
        compile_error!("init decoder from file is only supported on unix and windows");
    }

    #[inline]
    #[cfg(unix)]
    fn ma_resource_manager_unregister_file<R: AsRmPtr + ?Sized>(
        rm: &R,
        path: std::ffi::CString,
    ) -> MaResult<()> {
        let res = unsafe {
            sys::ma_resource_manager_unregister_file(private_rm::rm_ptr(rm), path.as_ptr())
        };
        MaudioError::check(res)?;
        Ok(())
    }

    #[inline]
    #[cfg(windows)]
    fn ma_resource_manager_unregister_file_w<R: AsRmPtr + ?Sized>(
        rm: &R,
        path: &[u16],
    ) -> MaResult<()> {
        let res = unsafe {
            sys::ma_resource_manager_unregister_file_w(private_rm::rm_ptr(rm), path.as_ptr())
        };
        MaudioError::check(res)?;
        Ok(())
    }

    pub fn ma_resource_manager_unregister_data_internal<R: AsRmPtr + ?Sized>(
        rm: &R,
        name: &str,
    ) -> MaResult<()> {
        #[cfg(unix)]
        {
            let name = std::ffi::CString::new(name)
                .map_err(|_| crate::MaudioError::new_ma_error(crate::ErrorKinds::InvalidCString))?;

            ma_resource_manager_unregister_data(rm, name.as_ptr())
        }
        #[cfg(windows)]
        {
            use crate::engine::wide_null_terminated_name;

            let name = wide_null_terminated_name(name);
            ma_resource_manager_unregister_data_w(rm, &name)
        }

        #[cfg(not(any(unix, windows)))]
        compile_error!("init decoder from file is only supported on unix and windows");
    }

    #[inline]
    #[cfg(unix)]
    fn ma_resource_manager_unregister_data<R: AsRmPtr + ?Sized>(
        rm: &R,
        name: *const core::ffi::c_char,
    ) -> MaResult<()> {
        let res = unsafe { sys::ma_resource_manager_unregister_data(private_rm::rm_ptr(rm), name) };
        MaudioError::check(res)?;
        Ok(())
    }

    #[inline]
    #[cfg(windows)]
    fn ma_resource_manager_unregister_data_w<R: AsRmPtr + ?Sized>(
        rm: &R,
        name: &[u16],
    ) -> MaResult<()> {
        let res = unsafe {
            sys::ma_resource_manager_unregister_data_w(private_rm::rm_ptr(rm), name.as_ptr())
        };
        MaudioError::check(res)?;
        Ok(())
    }

    // DATA BUFFERS

    #[inline]
    pub fn ma_resource_manager_data_buffer_init_ex<R: AsRmPtr + ?Sized>(
        rm: &R,
        config: &ResourceManagerBufferBuilder<'_, R>,
        data_buffer: *mut sys::ma_resource_manager_data_buffer,
    ) -> MaResult<()> {
        let res = unsafe {
            sys::ma_resource_manager_data_buffer_init_ex(
                private_rm::rm_ptr(rm),
                config.as_raw_ptr(),
                data_buffer,
            )
        };
        MaudioError::check(res)
    }

    #[inline]
    #[cfg(unix)]
    pub fn ma_resource_manager_data_buffer_init<R: AsRmPtr + ?Sized>(
        rm: &R,
        path: std::ffi::CString,
        flags: u32,
        notif: *const sys::ma_resource_manager_pipeline_notifications,
        data_buffer: *mut sys::ma_resource_manager_data_buffer,
    ) -> MaResult<()> {
        let res = unsafe {
            sys::ma_resource_manager_data_buffer_init(
                private_rm::rm_ptr(rm),
                path.as_ptr(),
                flags,
                notif,
                data_buffer,
            )
        };
        MaudioError::check(res)?;
        Ok(())
    }

    #[inline]
    #[cfg(windows)]
    pub fn ma_resource_manager_data_buffer_init_w<R: AsRmPtr + ?Sized>(
        rm: &R,
        path: &[u16],
        flags: u32,
        notif: *const sys::ma_resource_manager_pipeline_notifications,
        data_buffer: *mut sys::ma_resource_manager_data_buffer,
    ) -> MaResult<()> {
        let res = unsafe {
            sys::ma_resource_manager_data_buffer_init_w(
                private_rm::rm_ptr(rm),
                path.as_ptr(),
                flags,
                notif,
                data_buffer,
            )
        };
        MaudioError::check(res)?;
        Ok(())
    }

    #[inline]
    pub fn ma_resource_manager_data_buffer_init_copy<R: AsRmPtr + ?Sized>(
        rm: &R,
        existing: &ResourceManagerBuffer<'_, R>,
        data_buffer: *mut sys::ma_resource_manager_data_buffer,
    ) -> MaResult<()> {
        let res = unsafe {
            sys::ma_resource_manager_data_buffer_init_copy(
                private_rm::rm_ptr(rm),
                existing.to_raw(),
                data_buffer,
            )
        };
        MaudioError::check(res)?;
        Ok(())
    }

    #[inline]
    pub fn ma_resource_manager_data_buffer_uninit<R: AsRmPtr + ?Sized>(
        data_buffer: &ResourceManagerBuffer<'_, R>,
    ) -> MaResult<()> {
        let res = unsafe { sys::ma_resource_manager_data_buffer_uninit(data_buffer.to_raw()) };
        MaudioError::check(res)?;
        Ok(())
    }

    // Not used. Already available on DataSourceOps
    pub fn ma_resource_manager_data_buffer_read_pcm_frames<'a, R: AsRmPtr>(
        data_buffer: &mut ResourceManagerBuffer<'a, R>,
        frame_count: u64,
    ) -> MaResult<SampleBuffer<R::Format>> {
        let channels = data_buffer.data_format()?.channels;
        if channels == 0 {
            return Err(MaudioError::from_ma_result(sys::ma_result_MA_INVALID_ARGS));
        }
        let mut buffer = SampleBuffer::<R::Format>::new_zeroed(frame_count as usize, channels)?;

        let frames_read = ma_resource_manager_data_buffer_read_pcm_frames_internal::<R>(
            data_buffer,
            frame_count,
            buffer.as_mut_ptr() as *mut core::ffi::c_void,
        )?;

        SampleBuffer::<R::Format>::from_storage(buffer, frames_read as usize, 2)
    }

    #[inline]
    pub fn ma_resource_manager_data_buffer_read_pcm_frames_internal<'a, R: AsRmPtr>(
        data_buffer: &mut ResourceManagerBuffer<'a, R>,
        frame_count: u64,
        buffer: *mut core::ffi::c_void,
    ) -> MaResult<u64> {
        let mut frames_read = 0;
        let res = unsafe {
            sys::ma_resource_manager_data_buffer_read_pcm_frames(
                data_buffer.to_raw(),
                buffer,
                frame_count,
                &mut frames_read,
            )
        };
        MaudioError::check(res)?;
        Ok(frames_read)
    }

    #[inline]
    pub fn ma_resource_manager_data_buffer_seek_to_pcm_frame<R: AsRmPtr>(
        data_buffer: &ResourceManagerBuffer<'_, R>,
        frame_index: u64,
    ) -> MaResult<()> {
        let res = unsafe {
            sys::ma_resource_manager_data_buffer_seek_to_pcm_frame(
                data_buffer.to_raw(),
                frame_index,
            )
        };
        MaudioError::check(res)?;
        todo!()
    }

    #[inline]
    pub fn ma_resource_manager_data_buffer_get_data_format<R: AsRmPtr>(
        data_buffer: &ResourceManagerBuffer<'_, R>,
        format: *mut sys::ma_format,
        channels: *mut u32,
        sample_rate: *mut u32,
        channel_map: *mut sys::ma_channel,
        channel_map_cap: usize,
    ) -> MaResult<Format> {
        let res = unsafe {
            sys::ma_resource_manager_data_buffer_get_data_format(
                data_buffer.to_raw(),
                format,
                channels,
                sample_rate,
                channel_map,
                channel_map_cap,
            )
        };
        MaudioError::check(res)?;
        todo!()
    }

    #[inline]
    pub fn ma_resource_manager_data_buffer_get_cursor_in_pcm_frames<R: AsRmPtr>(
        data_buffer: &ResourceManagerBuffer<'_, R>,
    ) -> MaResult<u64> {
        let mut cursor: u64 = 0;
        let res = unsafe {
            sys::ma_resource_manager_data_buffer_get_cursor_in_pcm_frames(
                data_buffer.to_raw(),
                &mut cursor,
            )
        };
        MaudioError::check(res)?;
        Ok(cursor)
    }

    #[inline]
    pub fn ma_resource_manager_data_buffer_get_length_in_pcm_frames<R: AsRmPtr>(
        data_buffer: &ResourceManagerBuffer<'_, R>,
    ) -> MaResult<u64> {
        let mut length: u64 = 0;
        let res = unsafe {
            sys::ma_resource_manager_data_buffer_get_length_in_pcm_frames(
                data_buffer.to_raw(),
                &mut length,
            )
        };
        MaudioError::check(res)?;
        Ok(length)
    }

    #[inline]
    pub fn ma_resource_manager_data_buffer_result<R: AsRmPtr>(
        data_buffer: &ResourceManagerBuffer<'_, R>,
    ) -> MaResult<()> {
        let res = unsafe { sys::ma_resource_manager_data_buffer_result(data_buffer.to_raw()) };
        MaudioError::check(res)
    }

    // Not used. Already available on DataSourceOps
    #[inline]
    pub fn ma_resource_manager_data_buffer_set_looping<R: AsRmPtr>(
        data_buffer: &ResourceManagerBuffer<'_, R>,
        is_looping: bool,
    ) -> MaResult<()> {
        let is_looping = is_looping as u32;
        let res = unsafe {
            sys::ma_resource_manager_data_buffer_set_looping(data_buffer.to_raw(), is_looping)
        };
        MaudioError::check(res)
    }

    // Not used. Already available on DataSourceOps
    #[inline]
    pub fn ma_resource_manager_data_buffer_is_looping<R: AsRmPtr>(
        data_buffer: &ResourceManagerBuffer<'_, R>,
    ) -> bool {
        let res = unsafe { sys::ma_resource_manager_data_buffer_is_looping(data_buffer.to_raw()) };
        res == 1
    }

    #[inline]
    pub fn ma_resource_manager_data_buffer_get_available_frames<R: AsRmPtr>(
        data_buffer: &ResourceManagerBuffer<'_, R>,
    ) -> MaResult<u64> {
        let mut frames = 0;
        let res = unsafe {
            sys::ma_resource_manager_data_buffer_get_available_frames(
                data_buffer.to_raw(),
                &mut frames,
            )
        };
        MaudioError::check(res)?;
        Ok(frames)
    }

    // DATA SOURCES

    #[inline]
    pub fn ma_resource_manager_data_source_init_ex<R: AsRmPtr + ?Sized>(
        rm: &R,
        config: &ResourceManagerSourceBuilder<'_, R>,
        data_source: *mut sys::ma_resource_manager_data_source,
    ) -> MaResult<()> {
        let res = unsafe {
            sys::ma_resource_manager_data_source_init_ex(
                private_rm::rm_ptr(rm),
                config.as_raw_ptr(),
                data_source,
            )
        };
        MaudioError::check(res)
    }

    #[inline]
    pub fn ma_resource_manager_data_source_init<R: AsRmPtr + ?Sized>(
        rm: &R,
        name: *const core::ffi::c_char,
        flags: u32,
        notif: *const sys::ma_resource_manager_pipeline_notifications,
        data_source: *mut sys::ma_resource_manager_data_source,
    ) -> MaResult<()> {
        let res = unsafe {
            sys::ma_resource_manager_data_source_init(
                private_rm::rm_ptr(rm),
                name,
                flags,
                notif,
                data_source,
            )
        };
        MaudioError::check(res)?;
        Ok(())
    }

    #[inline]
    pub fn ma_resource_manager_data_source_init_copy<R: AsRmPtr + ?Sized>(
        rm: &R,
        existing: &ResourceManagerSource<'_, R>,
        data_source: *mut sys::ma_resource_manager_data_source,
    ) -> MaResult<()> {
        let res = unsafe {
            sys::ma_resource_manager_data_source_init_copy(
                private_rm::rm_ptr(rm),
                existing.to_raw(),
                data_source,
            )
        };
        MaudioError::check(res)?;
        Ok(())
    }

    #[inline]
    pub fn ma_resource_manager_data_source_uninit<R: AsRmPtr + ?Sized>(
        data_source: &ResourceManagerSource<'_, R>,
    ) -> MaResult<()> {
        let res = unsafe { sys::ma_resource_manager_data_source_uninit(data_source.to_raw()) };
        MaudioError::check(res)?;
        Ok(())
    }

    // Not used. Already available on DataSourceOps
    pub fn ma_resource_manager_data_source_read_pcm_frames<R: AsRmPtr>(
        data_source: &mut ResourceManagerSource<'_, R>,
        frame_count: u64,
    ) -> MaResult<SampleBuffer<R::Format>> {
        let channels = data_source.data_format()?.channels;
        if channels == 0 {
            return Err(MaudioError::from_ma_result(sys::ma_result_MA_INVALID_ARGS));
        }
        let mut buffer = SampleBuffer::<R::Format>::new_zeroed(frame_count as usize, channels)?;

        let frames_read = ma_resource_manager_data_source_read_pcm_frames_internal::<R>(
            data_source,
            frame_count,
            buffer.as_mut_ptr() as *mut core::ffi::c_void,
        )?;

        SampleBuffer::<R::Format>::from_storage(buffer, frames_read as usize, channels)
    }

    // Not used. Already available on DataSourceOps
    #[inline]
    fn ma_resource_manager_data_source_read_pcm_frames_internal<R: AsRmPtr>(
        data_source: &mut ResourceManagerSource<'_, R>,
        frame_count: u64,
        buffer: *mut core::ffi::c_void,
    ) -> MaResult<u64> {
        let mut frames_read = 0;
        let res = unsafe {
            sys::ma_resource_manager_data_source_read_pcm_frames(
                data_source.to_raw(),
                buffer,
                frame_count,
                &mut frames_read,
            )
        };
        MaudioError::check(res)?;
        Ok(frames_read)
    }

    // Not used. Already available on DataSourceOps
    #[inline]
    pub fn ma_resource_manager_data_source_seek_to_pcm_frame<R: AsRmPtr>(
        data_source: &mut ResourceManagerSource<'_, R>,
        frame: u64,
    ) -> MaResult<()> {
        let res = unsafe {
            sys::ma_resource_manager_data_source_seek_to_pcm_frame(data_source.to_raw(), frame)
        };
        MaudioError::check(res)
    }

    // Not used. Already available on DataSourceOps
    #[inline]
    pub fn ma_resource_manager_data_source_get_data_format<R: AsRmPtr>(
        data_source: &ResourceManagerSource<'_, R>,
    ) -> MaResult<DataFormat> {
        let mut format_raw: sys::ma_format = sys::ma_format_ma_format_unknown;
        let mut channels: u32 = 0;
        let mut sample_rate: u32 = 0;
        let mut channel_map_raw = vec![0 as sys::ma_channel; sys::MA_MAX_CHANNELS as usize];
        let res = unsafe {
            sys::ma_resource_manager_data_source_get_data_format(
                data_source.to_raw(),
                &mut format_raw,
                &mut channels,
                &mut sample_rate,
                channel_map_raw.as_mut_ptr(),
                channel_map_raw.len(),
            )
        };
        MaudioError::check(res)?;
        // Could cast when passing the ptr to miniaudio, but copying should be fine here
        let mut channel_map: Vec<Channel> =
            channel_map_raw.into_iter().map(Channel::from_raw).collect();
        channel_map.truncate(channels as usize);

        Ok(DataFormat {
            format: format_raw.try_into()?,
            channels,
            sample_rate: sample_rate.try_into()?,
            channel_map: Some(channel_map),
        })
    }

    // Not used. Already available on DataSourceOps
    #[inline]
    pub fn ma_resource_manager_data_source_get_cursor_in_pcm_frames<R: AsRmPtr>(
        data_source: &ResourceManagerSource<'_, R>,
    ) -> MaResult<u64> {
        let mut cursor = 0;
        let res = unsafe {
            sys::ma_resource_manager_data_source_get_cursor_in_pcm_frames(
                data_source.to_raw(),
                &mut cursor,
            )
        };
        MaudioError::check(res)?;
        Ok(cursor)
    }

    // Not used. Already available on DataSourceOps
    #[inline]
    pub fn ma_resource_manager_data_source_get_length_in_pcm_frames<R: AsRmPtr>(
        data_source: &ResourceManagerSource<'_, R>,
    ) -> MaResult<u64> {
        let mut length: u64 = 0;
        let res = unsafe {
            sys::ma_resource_manager_data_source_get_length_in_pcm_frames(
                data_source.to_raw(),
                &mut length,
            )
        };
        MaudioError::check(res)?;
        Ok(length)
    }

    #[inline]
    pub fn ma_resource_manager_data_source_result<R: AsRmPtr>(
        data_source: &ResourceManagerSource<'_, R>,
    ) -> MaResult<()> {
        let res = unsafe { sys::ma_resource_manager_data_source_result(data_source.to_raw()) };
        MaudioError::check(res)
    }

    // Not used. Already available on DataSourceOps
    #[inline]
    pub fn ma_resource_manager_data_source_set_looping<R: AsRmPtr>(
        data_source: &ResourceManagerSource<'_, R>,
        is_looping: bool,
    ) -> MaResult<()> {
        let is_looping = is_looping as u32;
        let res = unsafe {
            sys::ma_resource_manager_data_source_set_looping(data_source.to_raw(), is_looping)
        };
        MaudioError::check(res)
    }

    // Not used. Already available on DataSourceOps
    #[inline]
    pub fn ma_resource_manager_data_source_is_looping<R: AsRmPtr>(
        data_source: &ResourceManagerSource<'_, R>,
    ) -> bool {
        let res = unsafe { sys::ma_resource_manager_data_source_is_looping(data_source.to_raw()) };
        res == 1
    }

    #[inline]
    pub fn ma_resource_manager_data_source_get_available_frames<R: AsRmPtr>(
        data_source: &ResourceManagerSource<'_, R>,
    ) -> MaResult<u64> {
        let mut frames: u64 = 0;
        let res = unsafe {
            sys::ma_resource_manager_data_source_get_available_frames(
                data_source.to_raw(),
                &mut frames,
            )
        };
        MaudioError::check(res)?;
        Ok(frames)
    }

    // DATA STREAM

    #[inline]
    pub fn ma_resource_manager_data_stream_init_ex<R: AsRmPtr + ?Sized>(
        rm: &R,
        config: &ResourceManagerStreamBuilder<'_, R>,
        data_stream: *mut sys::ma_resource_manager_data_stream,
    ) -> MaResult<()> {
        let res = unsafe {
            sys::ma_resource_manager_data_stream_init_ex(
                private_rm::rm_ptr(rm),
                config.as_raw_ptr(),
                data_stream,
            )
        };
        MaudioError::check(res)
    }

    #[cfg(unix)]
    #[inline]
    pub fn ma_resource_manager_data_stream_init<R: AsRmPtr>(
        rm: &R,
        path: std::ffi::CString,
        flags: u32,
        notif: *const sys::ma_resource_manager_pipeline_notifications,
        data_stream: *mut sys::ma_resource_manager_data_stream,
    ) -> MaResult<()> {
        let res = unsafe {
            sys::ma_resource_manager_data_stream_init(
                private_rm::rm_ptr(rm),
                path.as_ptr(),
                flags,
                notif,
                data_stream,
            )
        };
        MaudioError::check(res)
    }

    #[cfg(windows)]
    #[inline]
    pub fn ma_resource_manager_data_stream_init_w<R: AsRmPtr>(
        rm: &R,
        path: &[u16],
        flags: u32,
        notif: *const sys::ma_resource_manager_pipeline_notifications,
        data_stream: *mut sys::ma_resource_manager_data_stream,
    ) -> MaResult<()> {
        let res = unsafe {
            sys::ma_resource_manager_data_stream_init_w(
                private_rm::rm_ptr(rm),
                path.as_ptr(),
                flags,
                notif,
                data_stream,
            )
        };
        MaudioError::check(res)
    }

    #[inline]
    pub fn ma_resource_manager_data_stream_uninit<R: AsRmPtr + ?Sized>(
        data_stream: &mut ResourceManagerStream<'_, R>,
    ) -> MaResult<()> {
        let res = unsafe { sys::ma_resource_manager_data_stream_uninit(data_stream.to_raw()) };
        MaudioError::check(res)
    }

    // Not used. Already available on DataSourceOps
    pub fn ma_resource_manager_data_stream_read_pcm_frames<R: AsRmPtr>(
        data_stream: &mut ResourceManagerStream<'_, R>,
        frame_count: u64,
    ) -> MaResult<SampleBuffer<R::Format>> {
        let channels = data_stream.data_format()?.channels;
        if channels == 0 {
            return Err(MaudioError::from_ma_result(sys::ma_result_MA_INVALID_ARGS));
        }
        let mut buffer = SampleBuffer::<R::Format>::new_zeroed(frame_count as usize, channels)?;

        let frames_read = ma_resource_manager_data_stream_read_pcm_frames_internal::<R>(
            data_stream,
            frame_count,
            buffer.as_mut_ptr() as *mut core::ffi::c_void,
        )?;

        SampleBuffer::<R::Format>::from_storage(buffer, frames_read as usize, channels)
    }

    // Not used. Already available on DataSourceOps
    #[inline]
    fn ma_resource_manager_data_stream_read_pcm_frames_internal<R: AsRmPtr>(
        data_stream: &mut ResourceManagerStream<'_, R>,
        frame_count: u64,
        buffer: *mut core::ffi::c_void,
    ) -> MaResult<u64> {
        let mut frames_read: u64 = 0;
        let res = unsafe {
            sys::ma_resource_manager_data_stream_read_pcm_frames(
                data_stream.to_raw(),
                buffer,
                frame_count,
                &mut frames_read,
            )
        };
        MaudioError::check(res)?;
        Ok(frames_read)
    }

    // Not used. Already available on DataSourceOps
    #[inline]
    pub fn ma_resource_manager_data_stream_seek_to_pcm_frame<R: AsRmPtr>(
        data_stream: &mut ResourceManagerStream<'_, R>,
        frame: u64,
    ) -> MaResult<()> {
        let res = unsafe {
            sys::ma_resource_manager_data_stream_seek_to_pcm_frame(data_stream.to_raw(), frame)
        };
        MaudioError::check(res)
    }

    // Not used. Already available on DataSourceOps
    #[inline]
    pub fn ma_resource_manager_data_stream_get_data_format<R: AsRmPtr>(
        data_stream: &ResourceManagerStream<'_, R>,
    ) -> MaResult<DataFormat> {
        let mut format_raw: sys::ma_format = sys::ma_format_ma_format_unknown;
        let mut channels: u32 = 0;
        let mut sample_rate: u32 = 0;
        let mut channel_map_raw = vec![0 as sys::ma_channel; sys::MA_MAX_CHANNELS as usize];
        let res = unsafe {
            sys::ma_resource_manager_data_stream_get_data_format(
                data_stream.to_raw(),
                &mut format_raw,
                &mut channels,
                &mut sample_rate,
                channel_map_raw.as_mut_ptr(),
                channel_map_raw.len(),
            )
        };
        MaudioError::check(res)?;
        // Could cast when passing the ptr to miniaudio, but copying should be fine here
        let mut channel_map: Vec<Channel> =
            channel_map_raw.into_iter().map(Channel::from_raw).collect();
        channel_map.truncate(channels as usize);

        Ok(DataFormat {
            format: format_raw.try_into()?,
            channels,
            sample_rate: sample_rate.try_into()?,
            channel_map: Some(channel_map),
        })
    }

    // Not used. Already available on DataSourceOps
    #[inline]
    pub fn ma_resource_manager_data_stream_get_cursor_in_pcm_frames<R: AsRmPtr>(
        data_stream: &ResourceManagerStream<'_, R>,
    ) -> MaResult<u64> {
        let mut cursor = 0;
        let res = unsafe {
            sys::ma_resource_manager_data_stream_get_cursor_in_pcm_frames(
                data_stream.to_raw(),
                &mut cursor,
            )
        };
        MaudioError::check(res)?;
        Ok(cursor)
    }

    // Not used. Already available on DataSourceOps
    #[inline]
    pub fn ma_resource_manager_data_stream_get_length_in_pcm_frames<R: AsRmPtr>(
        data_stream: &ResourceManagerStream<'_, R>,
    ) -> MaResult<u64> {
        let mut length: u64 = 0;
        let res = unsafe {
            sys::ma_resource_manager_data_stream_get_length_in_pcm_frames(
                data_stream.to_raw(),
                &mut length,
            )
        };
        MaudioError::check(res)?;
        Ok(length)
    }

    #[inline]
    pub fn ma_resource_manager_data_stream_result<R: AsRmPtr>(
        data_stream: &ResourceManagerStream<'_, R>,
    ) -> MaResult<()> {
        let res = unsafe { sys::ma_resource_manager_data_stream_result(data_stream.to_raw()) };
        MaudioError::check(res)
    }

    // Not used. Already available on DataSourceOps
    #[inline]
    pub fn ma_resource_manager_data_stream_set_looping<R: AsRmPtr>(
        data_stream: &ResourceManagerStream<'_, R>,
        is_looping: bool,
    ) -> MaResult<()> {
        let is_looping = is_looping as u32;
        let res = unsafe {
            sys::ma_resource_manager_data_stream_set_looping(data_stream.to_raw(), is_looping)
        };
        MaudioError::check(res)
    }

    // Not used. Already available on DataSourceOps
    #[inline]
    pub fn ma_resource_manager_data_stream_is_looping<R: AsRmPtr>(
        data_stream: &ResourceManagerStream<'_, R>,
    ) -> bool {
        let res = unsafe { sys::ma_resource_manager_data_stream_is_looping(data_stream.to_raw()) };
        res == 1
    }

    #[inline]
    pub fn ma_resource_manager_data_stream_get_available_frames<R: AsRmPtr>(
        data_stream: &ResourceManagerStream<'_, R>,
    ) -> MaResult<u64> {
        let mut frames: u64 = 0;
        let res = unsafe {
            sys::ma_resource_manager_data_stream_get_available_frames(
                data_stream.to_raw(),
                &mut frames,
            )
        };
        MaudioError::check(res)?;
        Ok(frames)
    }

    // JOB MANAGEMENT
    pub fn ma_resource_manager_post_job<R: AsRmPtr>(
        rm: &R,
        job: *const sys::ma_job,
    ) -> MaResult<()> {
        let res = unsafe { sys::ma_resource_manager_post_job(private_rm::rm_ptr(rm), job) };
        MaudioError::check(res)
    }

    #[inline]
    pub fn ma_resource_manager_post_job_quit<R: AsRmPtr>(rm: &R) -> MaResult<()> {
        let res = unsafe { sys::ma_resource_manager_post_job_quit(private_rm::rm_ptr(rm)) };
        MaudioError::check(res)
    }

    #[inline]
    pub fn ma_resource_manager_next_job<R: AsRmPtr>(rm: &R, job: *mut sys::ma_job) -> MaResult<()> {
        let res = unsafe { sys::ma_resource_manager_next_job(private_rm::rm_ptr(rm), job) };
        MaudioError::check(res)
    }

    #[inline]
    pub fn ma_resource_manager_process_next_job<R: AsRmPtr>(rm: &R) -> MaResult<()> {
        let res = unsafe { sys::ma_resource_manager_process_next_job(private_rm::rm_ptr(rm)) };
        MaudioError::check(res)
    }
}

impl<F: PcmFormat> Drop for InnerResourceManager<F> {
    fn drop(&mut self) {
        resource_ffi::ma_resource_manager_uninit(self);
        drop(unsafe { Box::from_raw(self.inner) });
    }
}

#[allow(dead_code)]
fn tiny_test_wav_mono(frames: usize) -> Vec<u8> {
    let mut samples = Vec::with_capacity(frames);
    for i in 0..frames {
        samples.push(((i as i32 * 300) % i16::MAX as i32) as i16);
    }
    wav_i16_le(1, SampleRate::Sr44100, &samples)
}

#[cfg(test)]
mod test {
    use crate::{
        engine::resource::{
            rm_builder::ResourceManagerBuilder, rm_source::ResourceManagerSourceBuilder,
            rm_source_flags::RmSourceFlags, tiny_test_wav_mono, RmOps,
        },
        test_assets::{
            decoded_data::{
                asset_interleaved_f32, asset_interleaved_i16, asset_interleaved_i32,
                asset_interleaved_s24_i32, asset_interleaved_s24_packed_le, asset_interleaved_u8,
            },
            temp_file::{unique_tmp_path, TempFileGuard},
        },
    };

    #[test]
    fn test_resource_man_basic_init() {
        let rm = ResourceManagerBuilder::new().build_f32().unwrap();
        drop(rm);
    }

    #[test]
    fn test_resource_man_basic_init_2() {
        let rm = ResourceManagerBuilder::new()
            .job_thread_count(1)
            .channels(2)
            .sample_rate(crate::audio::sample_rate::SampleRate::Sr11025)
            .build_f32()
            .unwrap();
        drop(rm);
    }

    #[test]
    fn test_resource_man_basic_register_file() {
        let rm = ResourceManagerBuilder::new().build_f32().unwrap();
        let wav = tiny_test_wav_mono(20);
        let path_guard = TempFileGuard::new(unique_tmp_path("wav"));
        std::fs::write(path_guard.path(), &wav).unwrap();
        let guard = rm
            .register_file(path_guard.path(), RmSourceFlags::NONE)
            .unwrap();
        let _buf = guard.build_buffer(RmSourceFlags::NONE).unwrap();
        let _src = guard.build_source(RmSourceFlags::NONE).unwrap();
        let _strm = guard.build_stream(RmSourceFlags::NONE).unwrap();
    }

    #[test]
    fn test_resource_man_basic_register_encoded_data() {
        let rm = ResourceManagerBuilder::new().build_f32().unwrap();
        let wav: Vec<u8> = tiny_test_wav_mono(20);
        let guard = rm.register_encoded("test:wav", &wav).unwrap();
        let _buf = guard.build_buffer(RmSourceFlags::NONE).unwrap();
        let _src = guard.build_source(RmSourceFlags::NONE).unwrap();
    }

    #[test]
    fn test_resource_man_decoded_u8() {
        let rm = ResourceManagerBuilder::new().build_f32().unwrap();
        let data = asset_interleaved_u8(2, 100, 1);
        let guard = rm
            .register_decoded_u8(
                "data",
                &data,
                2,
                crate::audio::sample_rate::SampleRate::Sr48000,
            )
            .unwrap();
        let _buf = guard.build_buffer(RmSourceFlags::NONE).unwrap();
        let _src = guard.build_source(RmSourceFlags::NONE).unwrap();
    }

    #[test]
    fn test_resource_man_decoded_i16() {
        let rm = ResourceManagerBuilder::new().build_f32().unwrap();
        let data = asset_interleaved_i16(2, 100, 1);
        let guard = rm
            .register_decoded_i16(
                "data",
                &data,
                2,
                crate::audio::sample_rate::SampleRate::Sr48000,
            )
            .unwrap();
        let _buf = guard.build_buffer(RmSourceFlags::NONE).unwrap();
        let _src = guard.build_source(RmSourceFlags::NONE).unwrap();
    }

    #[test]
    fn test_resource_man_decoded_i32() {
        let rm = ResourceManagerBuilder::new().build_f32().unwrap();
        let data = asset_interleaved_i32(2, 100, 1);
        let guard = rm
            .register_decoded_i32(
                "data",
                &data,
                2,
                crate::audio::sample_rate::SampleRate::Sr48000,
            )
            .unwrap();
        let _buf = guard.build_buffer(RmSourceFlags::NONE).unwrap();
        let _src = guard.build_source(RmSourceFlags::NONE).unwrap();
    }

    #[test]
    fn test_resource_man_decoded_f32() {
        let rm = ResourceManagerBuilder::new().build_f32().unwrap();
        let data = asset_interleaved_f32(2, 100, 1.0);
        let guard = rm
            .register_decoded_f32(
                "data",
                &data,
                2,
                crate::audio::sample_rate::SampleRate::Sr48000,
            )
            .unwrap();
        let buf = guard.build_buffer(RmSourceFlags::NONE).unwrap();
        drop(buf);
        let src = guard.build_source(RmSourceFlags::NONE).unwrap();
        drop(src);
    }

    #[test]
    fn test_resource_man_decoded_s24_packed() {
        let rm = ResourceManagerBuilder::new().build_f32().unwrap();
        let data = asset_interleaved_s24_packed_le(2, 100, 1);
        let guard = rm
            .register_decoded_s24_packed(
                "data",
                &data,
                2,
                crate::audio::sample_rate::SampleRate::Sr48000,
            )
            .unwrap();
        let _buf = guard.build_buffer(RmSourceFlags::NONE).unwrap();
        let _src = guard.build_source(RmSourceFlags::NONE).unwrap();
    }

    #[test]
    fn test_resource_man_decoded_s24() {
        let rm = ResourceManagerBuilder::new().build_f32().unwrap();
        let data = asset_interleaved_s24_i32(2, 100, 1);
        let guard = rm
            .register_decoded_s24(
                "data",
                &data,
                2,
                crate::audio::sample_rate::SampleRate::Sr48000,
            )
            .unwrap();
        let _buf = guard.build_buffer(RmSourceFlags::NONE).unwrap();
        let _src = guard.build_source(RmSourceFlags::NONE).unwrap();
    }

    #[test]
    fn test_resource_man_async_without_fence() {
        let rm = ResourceManagerBuilder::new().build_f32().unwrap();

        let wav = tiny_test_wav_mono(200);
        let path_guard = TempFileGuard::new(unique_tmp_path("wav"));
        let path = path_guard.path().to_path_buf();
        std::fs::write(&path, &wav).unwrap();

        let guard = rm.register_file(&path, RmSourceFlags::ASYNC).unwrap();
        let mut buffer = guard.build_buffer(RmSourceFlags::ASYNC).unwrap();
        let now = std::time::Instant::now();
        let mut elapsed: std::time::Duration;
        let mut loops: usize = 0;
        loop {
            elapsed = now.elapsed();
            if buffer.poll_ready().unwrap() {
                println!(
                    "Succesful poll after: {} micros and {loops} loops",
                    elapsed.as_micros()
                );
                break;
            }
            if elapsed.as_millis() > 20 {
                assert!(buffer.is_ready(), "Polling timed out, resource not ready");
                break;
            }
            loops += 1;
            std::thread::sleep(std::time::Duration::from_micros(5));
        }
    }

    #[test]
    fn test_resource_man_moving_to_thread() {
        let rm = ResourceManagerBuilder::new().build_f32().unwrap();

        let wav = tiny_test_wav_mono(20);
        let path_guard = TempFileGuard::new(unique_tmp_path("wav"));
        let path = path_guard.path().to_path_buf();
        std::fs::write(&path, &wav).unwrap();

        let moved_rm = rm.clone();
        let moved_path = path.clone();

        let handle = std::thread::spawn(move || {
            let _data_source = ResourceManagerSourceBuilder::new(&moved_rm)
                .file_path(&moved_path)
                .build()
                .unwrap();
        });
        handle.join().unwrap();

        let _data_source = ResourceManagerSourceBuilder::new(&rm)
            .file_path(&path)
            .build()
            .unwrap();
    }
}