// Copyright (c) 2026 Vector 35 Inc
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to
// deal in the Software without restriction, including without limitation the
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
// sell copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
// IN THE SOFTWARE.

#pragma once

// Mutex types that satisfy the C++ Lockable requirements.
//
// On macOS, mutex wraps os_unfair_lock and recursive_mutex wraps
// os_unfair_recursive_lock. These are faster and significantly smaller than
// std::mutex / std::recursive_mutex, which wrap the equivalent pthread mutexes.
//
// On other platforms, these are type aliases for the std equivalents.
//
// Note that `std::mutex` must still be used with `std::condition_variable` as
// `std::condition_variable` only works with `std::mutex`.

#ifndef __APPLE__

#include <mutex>

namespace bn::base {

using mutex = std::mutex;
using recursive_mutex = std::recursive_mutex;

} // namespace bn::base

#else

#include <os/lock.h>

namespace bn::base {

class mutex
{
	os_unfair_lock m_lock = OS_UNFAIR_LOCK_INIT;

public:
	mutex() = default;

	mutex(const mutex&) = delete;
	mutex& operator=(const mutex&) = delete;
	mutex(mutex&&) = delete;
	mutex& operator=(mutex&&) = delete;

	void lock()
	{
		os_unfair_lock_lock(&m_lock);
	}

	bool try_lock()
	{
		return os_unfair_lock_trylock(&m_lock);
	}

	void unlock()
	{
		os_unfair_lock_unlock(&m_lock);
	}
};

// os_unfair_recursive_lock is private API. We provide our own declarations for it here.
// From https://github.com/apple-oss-distributions/libplatform/blob/libplatform-359.60.3/private/os/lock_private.h#L404-L463
namespace detail {

struct os_unfair_recursive_lock {
	os_unfair_lock ourl_lock;
	uint32_t ourl_count;
};

extern "C" {

OS_NOTHROW OS_NONNULL_ALL
void os_unfair_recursive_lock_lock_with_options(os_unfair_recursive_lock* lock,
		int options);

OS_NOTHROW OS_NONNULL_ALL
bool os_unfair_recursive_lock_trylock(os_unfair_recursive_lock* lock);

OS_NOTHROW OS_NONNULL_ALL
void os_unfair_recursive_lock_unlock(os_unfair_recursive_lock* lock);

};

} // namespace bn::base::detail

class recursive_mutex
{
	detail::os_unfair_recursive_lock m_lock{OS_UNFAIR_LOCK_INIT, 0};

public:
	recursive_mutex() = default;

	recursive_mutex(const recursive_mutex&) = delete;
	recursive_mutex& operator=(const recursive_mutex&) = delete;
	recursive_mutex(recursive_mutex&&) = delete;
	recursive_mutex& operator=(recursive_mutex&&) = delete;

	void lock()
	{
		os_unfair_recursive_lock_lock_with_options(&m_lock, 0);
	}

	bool try_lock()
	{
		return os_unfair_recursive_lock_trylock(&m_lock);
	}

	void unlock()
	{
		os_unfair_recursive_lock_unlock(&m_lock);
	}
};

} // namespace bn::base

#endif