// -*- C++ -*-
//
// __external_threading
//
// libc++ external threading API implementation for the Circle bare-metal
// framework. Selected when _LIBCPP_HAS_THREAD_API_EXTERNAL is defined.
//
// Backed by Circle's CMutex, CSemaphore, and CTask.
// Non-inline implementations are in libs/libcxx-threading/src/.
//

#ifndef _LIBCPP___EXTERNAL_THREADING
#define _LIBCPP___EXTERNAL_THREADING

#include <__chrono/duration.h>
#include <__config>
#include <ctime>
#include <errno.h>

#ifndef _LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER
#pragma GCC system_header
#endif

_LIBCPP_BEGIN_NAMESPACE_STD

using __libcpp_timespec_t _LIBCPP_NODEBUG = ::timespec;

//
// Mutex
//
// Opaque storage for NonRecursiveMutexImpl (see src/mutex_impl.h).
// std::mutex must be non-recursive; Circle's CMutex is recursive by design,
// so a non-recursive semaphore-based wrapper is used instead.
// Size: 32 B on ARM64, 20 B on ARM32 — both fit in __storage[32].
// Zero-initialised storage is a valid initial state.
//
struct __libcpp_mutex_t
{
    alignas(8) unsigned char __storage[32];
};
#define _LIBCPP_MUTEX_INITIALIZER                                              \
    {                                                                          \
    }

struct __libcpp_recursive_mutex_t
{
    alignas(8) unsigned char __storage[32];
};

_LIBCPP_EXPORTED_FROM_ABI int
__libcpp_recursive_mutex_init(__libcpp_recursive_mutex_t *__m);
_LIBCPP_NO_THREAD_SAFETY_ANALYSIS _LIBCPP_EXPORTED_FROM_ABI int
__libcpp_recursive_mutex_lock(__libcpp_recursive_mutex_t *__m);
_LIBCPP_NO_THREAD_SAFETY_ANALYSIS _LIBCPP_EXPORTED_FROM_ABI bool
__libcpp_recursive_mutex_trylock(__libcpp_recursive_mutex_t *__m);
_LIBCPP_NO_THREAD_SAFETY_ANALYSIS _LIBCPP_EXPORTED_FROM_ABI int
__libcpp_recursive_mutex_unlock(__libcpp_recursive_mutex_t *__m);
_LIBCPP_EXPORTED_FROM_ABI int
__libcpp_recursive_mutex_destroy(__libcpp_recursive_mutex_t *__m);

_LIBCPP_NO_THREAD_SAFETY_ANALYSIS _LIBCPP_EXPORTED_FROM_ABI int
__libcpp_mutex_lock(__libcpp_mutex_t *__m);
_LIBCPP_NO_THREAD_SAFETY_ANALYSIS _LIBCPP_EXPORTED_FROM_ABI bool
__libcpp_mutex_trylock(__libcpp_mutex_t *__m);
_LIBCPP_NO_THREAD_SAFETY_ANALYSIS _LIBCPP_EXPORTED_FROM_ABI int
__libcpp_mutex_unlock(__libcpp_mutex_t *__m);
_LIBCPP_EXPORTED_FROM_ABI int __libcpp_mutex_destroy(__libcpp_mutex_t *__m);

//
// Condition Variable
//
// Opaque storage for (CSemaphore + int waiters).
// Size covers the struct on both ARM64 (28 B) and ARM32 (16 B); 40 B with
// alignment padding. Zero-initialised storage is a valid initial state
// (semaphore count = 0, waiters = 0).
//
struct __libcpp_condvar_t
{
    alignas(8) unsigned char __storage[40];
};
#define _LIBCPP_CONDVAR_INITIALIZER                                            \
    {                                                                          \
    }

_LIBCPP_EXPORTED_FROM_ABI int __libcpp_condvar_signal(__libcpp_condvar_t *__cv);
_LIBCPP_EXPORTED_FROM_ABI int
__libcpp_condvar_broadcast(__libcpp_condvar_t *__cv);
_LIBCPP_NO_THREAD_SAFETY_ANALYSIS _LIBCPP_EXPORTED_FROM_ABI int
__libcpp_condvar_wait(__libcpp_condvar_t *__cv, __libcpp_mutex_t *__m);
_LIBCPP_NO_THREAD_SAFETY_ANALYSIS _LIBCPP_EXPORTED_FROM_ABI int
__libcpp_condvar_timedwait(__libcpp_condvar_t *__cv, __libcpp_mutex_t *__m,
                           __libcpp_timespec_t *__ts);
_LIBCPP_EXPORTED_FROM_ABI int
__libcpp_condvar_destroy(__libcpp_condvar_t *__cv);

//
// Execute once
//
using __libcpp_exec_once_flag = int;
#define _LIBCPP_EXEC_ONCE_INITIALIZER 0

_LIBCPP_EXPORTED_FROM_ABI int
__libcpp_execute_once(__libcpp_exec_once_flag *__flag,
                      void (*__init_routine)());

//
// Thread id
//
// CTask* cast to uintptr_t — unique per task, no Circle headers needed here.
//
using __libcpp_thread_id = uintptr_t;

inline _LIBCPP_HIDE_FROM_ABI bool
__libcpp_thread_id_equal(__libcpp_thread_id __t1, __libcpp_thread_id __t2)
{
    return __t1 == __t2;
}

inline _LIBCPP_HIDE_FROM_ABI bool
__libcpp_thread_id_less(__libcpp_thread_id __t1, __libcpp_thread_id __t2)
{
    return __t1 < __t2;
}

//
// Thread
//
// __opaque stores CTask*.
//
struct __libcpp_thread_t
{
    void *__opaque;
};
#define _LIBCPP_NULL_THREAD {nullptr}

inline _LIBCPP_HIDE_FROM_ABI bool
__libcpp_thread_isnull(__libcpp_thread_t const *__t)
{
    return __t->__opaque == nullptr;
}

_LIBCPP_EXPORTED_FROM_ABI int __libcpp_thread_create(__libcpp_thread_t *__t,
                                                     void *(*__func)(void *),
                                                     void *__arg);
_LIBCPP_EXPORTED_FROM_ABI __libcpp_thread_id __libcpp_thread_get_current_id();
_LIBCPP_EXPORTED_FROM_ABI __libcpp_thread_id
__libcpp_thread_get_id(__libcpp_thread_t const *__t);
_LIBCPP_EXPORTED_FROM_ABI int __libcpp_thread_join(__libcpp_thread_t *__t);
_LIBCPP_EXPORTED_FROM_ABI int __libcpp_thread_detach(__libcpp_thread_t *__t);
_LIBCPP_EXPORTED_FROM_ABI void __libcpp_thread_yield();
_LIBCPP_EXPORTED_FROM_ABI void
__libcpp_thread_sleep_for(chrono::nanoseconds const &__ns);

//
// Thread local storage
//
#define _LIBCPP_TLS_DESTRUCTOR_CC
using __libcpp_tls_key = unsigned;

_LIBCPP_EXPORTED_FROM_ABI int __libcpp_tls_create(__libcpp_tls_key *__key,
                                                  void (*__at_exit)(void *));
_LIBCPP_EXPORTED_FROM_ABI void *__libcpp_tls_get(__libcpp_tls_key __key);
_LIBCPP_EXPORTED_FROM_ABI int __libcpp_tls_set(__libcpp_tls_key __key,
                                               void *__p);

_LIBCPP_END_NAMESPACE_STD

#endif // _LIBCPP___EXTERNAL_THREADING
