//
// SPDX-License-Identifier: BSD-3-Clause
// Copyright (c) Contributors to the OpenEXR Project.
//

#ifndef INCLUDED_ILM_THREAD_SEMAPHORE_H
#define INCLUDED_ILM_THREAD_SEMAPHORE_H

//-----------------------------------------------------------------------------
//
//	class Semaphore -- a wrapper class for
//	system-dependent counting semaphores
//
//-----------------------------------------------------------------------------

#include "IlmThreadExport.h"

#include "IlmThreadConfig.h"
#include "IlmThreadNamespace.h"

//
// Decipher the platform-specific threading support.
// Set the ILMTHREAD_SEMAPHORE_* defines to indicate the corresponding
// implementation of the Semaphore class. Only one of these should be
// defined.
//

#if ILMTHREAD_THREADING_ENABLED
#    if ILMTHREAD_HAVE_POSIX_SEMAPHORES
#        include <semaphore.h>
#        define ILMTHREAD_SEMAPHORE_POSIX 1
#    elif defined(__APPLE__)
#        include <AvailabilityMacros.h>
#        if MAC_OS_X_VERSION_MIN_REQUIRED > 1050 && !defined(__ppc__)
#            include <dispatch/dispatch.h>
#            define ILMTHREAD_SEMAPHORE_OSX 1
#        else
#            include <condition_variable>
#            include <mutex>
#            define ILMTHREAD_SEMAPHORE_OTHER 1
#        endif
#    elif (defined(_WIN32) || defined(_WIN64))
#        ifdef NOMINMAX
#            undef NOMINMAX
#        endif
#        define NOMINMAX
#        include <windows.h>
#        define ILMTHREAD_SEMAPHORE_WINDOWS 1
#    else
#        include <condition_variable>
#        include <mutex>
#        define ILMTHREAD_SEMAPHORE_OTHER 1
#    endif
#else
#    define ILMTHREAD_SEMAPHORE_DISABLED 1
#endif

ILMTHREAD_INTERNAL_NAMESPACE_HEADER_ENTER


class ILMTHREAD_EXPORT_TYPE Semaphore
{
  public:

    ILMTHREAD_EXPORT Semaphore (unsigned int value = 0);
    ILMTHREAD_EXPORT virtual ~Semaphore();

    ILMTHREAD_EXPORT void wait();
    ILMTHREAD_EXPORT bool tryWait();
    ILMTHREAD_EXPORT void post();
    ILMTHREAD_EXPORT int  value() const;

  private:

#if ILMTHREAD_SEMAPHORE_POSIX

    mutable sem_t _semaphore;

#elif ILMTHREAD_SEMAPHORE_OSX
    
    mutable dispatch_semaphore_t _semaphore;

#elif ILMTHREAD_SEMAPHORE_WINDOWS

    mutable HANDLE _semaphore;

#elif ILMTHREAD_SEMAPHORE_OTHER
    
    //
    // If the platform has threads but no semaphores,
    // then we implement them ourselves using condition variables
    //

	struct sema_t
	{
	    unsigned int count;
	    unsigned long numWaiting;
        std::mutex mutex;
        std::condition_variable nonZero;
	};

	mutable sema_t _semaphore;
  
#endif

    void operator = (const Semaphore& s) = delete;
    Semaphore (const Semaphore& s) = delete;
    void operator = (Semaphore&& s) = delete;
    Semaphore (Semaphore&& s) = delete;
};


ILMTHREAD_INTERNAL_NAMESPACE_HEADER_EXIT

#endif // INCLUDED_ILM_THREAD_SEMAPHORE_H