/////////////////////////////////////////////////////////////////////////////// 
// Copyright (C) 2002-2016, Open Design Alliance (the "Alliance"). 
// All rights reserved. 
// 
// This software and its documentation and related materials are owned by 
// the Alliance. The software may only be incorporated into application 
// programs owned by members of the Alliance, subject to a signed 
// Membership Agreement and Supplemental Software License Agreement with the
// Alliance. The structure and organization of this software are the valuable  
// trade secrets of the Alliance and its suppliers. The software is also 
// protected by copyright law and international treaty provisions. Application  
// programs incorporating this software must include the following statement 
// with their copyright notices:
//   
//   This application incorporates Teigha(R) software pursuant to a license 
//   agreement with Open Design Alliance.
//   Teigha(R) Copyright (C) 2002-2016 by Open Design Alliance. 
//   All rights reserved.
//
// By use of this software, its documentation or related materials, you 
// acknowledge and accept the above terms.
///////////////////////////////////////////////////////////////////////////////

#ifndef _THREADS_COUNTER_H_
#define _THREADS_COUNTER_H_

#include "TD_PackPush.h"
#include "OdMutex.h"

/** \details
    This class implements pointer to a Mutex in a Teigha context,
    which is initialized on demand.

    Library: Root
    <group Other_Classes>
*/
class FIRSTDLL_EXPORT OdMutexPtr
{
public:
  OdMutexPtr(): m_ptr(0){}
  ~OdMutexPtr();
  OdMutex* get() { if(!m_ptr) create(); return m_ptr; }
  void clear();
private:
  void create();

private:
  static OdMutex s_mt;
  OdMutex* m_ptr;
};

/** \details
    This class implements AutoLock object for OdMutex*.
    
    \remarks
    Mutex objects are used to synchronize between threads and across processes.
    
    MutexAutoLock objects automatically lock the specified OdMutex object
    when constructed and unlock it when destroyed.
    
    Library: Root
    <group Other_Classes>
*/
class OdMutexPtrAutoLock
{
public:
  /** \param mutex [in]  Mutex to be Autolocked.
  */
  OdMutexPtrAutoLock(OdMutex* mutex) : m_mutex(mutex), m_bEnable(false)
  {
    lock();
  }

  ~OdMutexPtrAutoLock()
  {
    unlock();
  }

  void lock() { set(true); }
  void unlock() { set(false); }

protected:
  OdMutexPtrAutoLock(): m_mutex(NULL), m_bEnable(false){}
  void set(bool bEnable)
  {
    if(m_mutex && (m_bEnable != bEnable))
    {
      m_bEnable = bEnable;
      if(bEnable)
        m_mutex->lock();
      else
        m_mutex->unlock();
    }
  }
protected:
  OdMutex* m_mutex;
private:
  bool m_bEnable;
};

/** \details
        
    Library: Root

    <group Other_Classes> 
*/
class ThreadsCounterReactor
{
  public:
    ThreadsCounterReactor() { }
    virtual ~ThreadsCounterReactor() { }

    /** \details
      Called from initial thread to increase execution threads count.
      \param nThreads [in]  Count of threads in aThreads array.
      \param aThreads [in]  Thread ID's array.
      \param nThreadAttributes [in]  Set of attributes for running threads.
    */
    virtual void increase(unsigned /*nThreads*/, const unsigned* /*aThreads*/, unsigned /*nThreadAttributes*/) { }
    /** \details
      Called from initial thread to decrease execution threads count.
      \param nThreads [in]  Count of threads in aThreads array.
      \param aThreads [in]  Thread ID's array.
      \param nThreadAttributes [in]  Set of attributes for running threads.
    */
    virtual void decrease(unsigned /*nThreads*/, const unsigned* /*aThreads*/, unsigned /*nThreadAttributes*/) { }

    /** \details
      Called from running thread immediately before any operations processing.
      \param nThreadId [in]  Running Thread ID.
      \param nThreadAttributes [in]  Set of attributes for running thread.
    */
    virtual void startThread(unsigned /*nThreadId*/, unsigned /*nThreadAttributes*/) { }
    /** \details
      Called from running thread immediately after thread operations processed.
      \param nThreadId [in]  Running Thread ID.
      \param nThreadAttributes [in]  Set of attributes for running thread.
    */
    virtual void stopThread(unsigned /*nThreadId*/, unsigned /*nThreadAttributes*/) { }
};

// Function for execute in the main thread
typedef void (*MainThreadFunc)(void*);
// Function for initiate execution in the main thread by external process
typedef void (*ExecuteMainThreadFunc)(MainThreadFunc, void*);

class OdRxThreadPoolService;

/** \details
        
    Library: Root

    <group Other_Classes> 
*/
class FIRSTDLL_EXPORT ThreadsCounter
{
public:
  enum ThreadAttributes
  {
    kNoAttributes = 0, // Simple Mt-process which doesn't require any special initializations

    kMtLoadingAttributes = (1 << 0), // Actual for both MtLoading and loading of DB's in multiple threads
    kMtRegenAttributes   = (1 << 1), // Multithread regeneration
    kStRegenAttributes   = (1 << 2), // Regeneration w/o cache (local heaps not required)
    kMtDisplayAttributes = (1 << 3), // Multithread display
    kMtModelerAttributes = (1 << 4), // Modeling operations in parallel threads
    kAllAttributes       = 0xFFFFFFFF // Applicable for Mt functionality tests
  };
protected:
  ThreadsCounter()
    : m_count(1)
    , m_mainThreadFunc(NULL)
    , m_threadPool(NULL) { }
  ~ThreadsCounter() { }
public:
  /** \details
      Returns true if ThreadsCounter has registered threads and Teigha works in multithreading mode.
  */
  operator bool() const { return m_count > 1; }

  /** \details
      Adds reactor into threads counter reactors chain.
      \param pReactor [in]  Function to add into reactors chain.
      \remarks
      Returns true if reactor added; returns false if reactor already available in chain.
  */
  bool addReactor(ThreadsCounterReactor *pReactor);
  /** \details
      Removes reactor from threads counter reactors chain.
      \param pReactor [in]  Reactor to remove from reactors chain.
      \remarks
      Returns true if reactor removed; returns false if reactor isn't available in chain.
  */
  bool removeReactor(ThreadsCounterReactor *pReactor);
  /** \details
      Checks whether reactor is available in threads counter reactors chain.
      \param pReactor [in]  Reactor to check.
  */
  bool hasReactor(ThreadsCounterReactor *pReactor) const;
  /** \details
      Returns count of reactors in threads counter reactors chain.
  */
  int nReactors() const;

  /* Following methods are intended for internal usage by Teigha libraries and not recommended for usage outside. */

  /** \details
      Save pointer for current OdRxThreadPoolService.
      \param pServices [in]  OdRxThreadPoolService pointer.
  */
  void setThreadPoolService(OdRxThreadPoolService *pService) { m_threadPool = pService; }
  /** \details
      Returns pointer for current OdRxThreadPoolService.
  */
  OdRxThreadPoolService *getThreadPoolService() { return m_threadPool; }

  /** \details
      Increase execution threads count.
      \param nThreads [in]  Count of threads in aThreads array.
      \param aThreads [in]  Thread ID's array.
      \param nThreadAttributes [in]  Set of attributes for running threads.
  */
  void increase(unsigned nThreads, const unsigned* aThreads, unsigned nThreadAttributes = ThreadsCounter::kNoAttributes)
  { ++m_count; increaseProc(nThreads, aThreads, nThreadAttributes); }
  /** \details
      Decrease execution threads count.
      \param nThreads [in]  Count of threads in aThreads array.
      \param aThreads [in]  Thread ID's array.
  */
  void decrease(unsigned nThreads, const unsigned* aThreads)
  { --m_count; decreaseProc(nThreads, aThreads); }

  /** \details
      Called when execution thread started.
  */
  void startThread() { startThreadProc(); }
  /** \details
      Called when execution thread stopped.
  */
  void stopThread() { stopThreadProc(); }

  /** \details
      Returns true if increase called for specified thread. Optionally returns thread attributes.
      \param nThreadId [in]  Requested thread ID.
      \param pThreadAttributes [out]  If set takes requested thread attributes.
  */
  bool hasThread(unsigned nThreadId, unsigned *pThreadAttributes)
  { return hasThreadProc(nThreadId, pThreadAttributes); }

  /** \details
      Setup function for execution in the external main thread.
      \param func [in]  Function for execution in the main thread.
  */
  void setMainThreadFunc(ExecuteMainThreadFunc func) { m_mainThreadFunc = func; }
  /** \details
      Returns function for execution in the external main thread.
  */
  ExecuteMainThreadFunc getMainThreadFunc() { return m_mainThreadFunc; }

protected:
  void increaseProc(unsigned nThreads, const unsigned* aThreads, unsigned nThreadAttributes);
  void decreaseProc(unsigned nThreads, const unsigned* aThreads);
  void startThreadProc();
  void stopThreadProc();
  bool hasThreadProc(unsigned nThreadId, unsigned *pThreadAttributes);

protected:
  OdRefCounter           m_count;
  ExecuteMainThreadFunc  m_mainThreadFunc;
  OdRxThreadPoolService *m_threadPool;
};

FIRSTDLL_EXPORT ThreadsCounter&   odThreadsCounter();

FIRSTDLL_EXPORT bool              odExecuteMainThreadAction(MainThreadFunc mtFunc, void *pArg, bool bExecST = true);

FIRSTDLL_EXPORT unsigned          odGetCurrentThreadId();
FIRSTDLL_EXPORT void              odThreadYield();

#define TD_AUTOLOCK_P(Mutex)      OdMutexPtrAutoLock autoLock(Mutex);
#define TD_AUTOLOCK_P_DEF(Mutex)  OdMutexPtrAutoLock autoLock(odThreadsCounter() ? Mutex.get() : NULL);

#include "TD_PackPop.h"

#endif //_THREADS_COUNTER_H_