#include "tthread.h"
#define _WIN32_WINNT 0x0400
#include <windows.h>
 
using std::list<TThread *>;
 
class TThreadGroupImp;
//---------------------------------------------------------------------------
//    TMutex & TMutexImp
//---------------------------------------------------------------------------
 
class TMutexImp {
  HANDLE id;
 
public:
  TMutexImp();
  ~TMutexImp();
  void lock();
  void unlock();
};
 
//---------------------------------------------------------------------------
 
class TThreadGroupImp {
  list<TThread *> threads;
 
public:
  TThreadGroupImp();
  ~TThreadGroupImp();
  void add(TThread *);
  void remove(TThread *);
  void wait();
};
//---------------------------------------------------------------------------
 
TMutexImp::TMutexImp() { id = CreateMutex(NULL, FALSE, NULL); }
 
//---------------------------------------------------------------------------
 
TMutexImp::~TMutexImp() { BOOL rc = CloseHandle(id); }
//---------------------------------------------------------------------------
 
void TMutexImp::lock() { DWORD rc = WaitForSingleObject(id, INFINITE); }
 
//---------------------------------------------------------------------------
 
void TMutexImp::unlock() { BOOL rc = ReleaseMutex(id); }
 
//---------------------------------------------------------------------------
 
TMutex::TMutex() : m_imp(new TMutexImp()) {}
 
//---------------------------------------------------------------------------
 
TMutex::~TMutex() { delete m_imp; }
//---------------------------------------------------------------------------
 
void TMutex::lock() { m_imp->lock(); }
 
//---------------------------------------------------------------------------
 
void TMutex::unlock() { m_imp->unlock(); }
 
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
//    TThread & TThreadImp
//---------------------------------------------------------------------------
 
class TThreadImp {
public:
  friend class TThreadGroupImp;
 
  HANDLE threadId;
  HANDLE mainThread;
  int m_refCount;
  TMutex secureLock;
  bool isRunning;
  TThreadGroupImp *owner;
  TThread *thread;
 
  // some static stuff
  static TUINT32 nThreads;
  static TMutex mutex;
 
  TThreadImp();
  ~TThreadImp();
 
  void start();
 
  bool setThreadPriority(TThread::TThreadPriority p);
  bool setPreferredProcessor(int processorId);
 
  static void incNThreads() {
    mutex.lock();
    nThreads++;
    mutex.unlock();
  }
  static void decNThreads() {
    mutex.lock();
    nThreads--;
    mutex.unlock();
  }
 
  void setOwner(TThreadGroupImp *_owner) { owner = _owner; }
};
 
TUINT32 TThreadImp::nThreads = 0;
TMutex TThreadImp::mutex     = TMutex();
 
//---------------------------------------------------------------------------
 
TThreadImp::TThreadImp()
    : isRunning(false)
    , threadId(0)
    , owner(0)
    , mainThread(0)
    , thread(0)
    , secureLock()
    , m_refCount(0) {}
 
//---------------------------------------------------------------------------
 
TThreadImp::~TThreadImp() {
  if (threadId) CloseHandle(threadId);
}
 
//---------------------------------------------------------------------------
 
static TUINT32 __stdcall fun(void *data) {
  TThreadImp *t = (TThreadImp *)data;
 
  t->secureLock.lock();
  if (t->isRunning) {
    t->secureLock.unlock();
    assert(!"thread is already running");
    return 0;
  }
  t->isRunning = true;
 
  t->secureLock.unlock();
 
  t->thread->run();
 
  t->decNThreads();
  if (t->owner) t->owner->remove(t->thread);
  t->thread->release();
  return 0;
}
 
//---------------------------------------------------------------------------
 
void TThreadImp::start() {
  TThreadImp::incNThreads();
  threadId = CreateThread(0, 0, fun, this, 0, 0);
}
//---------------------------------------------------------------------------
 
bool TThreadImp::setThreadPriority(TThread::TThreadPriority p) {
  int priority;
  switch (p) {
  case TThread::TIME_CRITICAL:
    priority = THREAD_PRIORITY_TIME_CRITICAL;
    break;
  case TThread::HIGHEST:
    priority = THREAD_PRIORITY_HIGHEST;
    break;
  case TThread::ABOVE_NORMAL:
    priority = THREAD_PRIORITY_ABOVE_NORMAL;
    break;
  case TThread::NORMAL:
    priority = THREAD_PRIORITY_NORMAL;
    break;
  case TThread::BELOW_NORMAL:
    priority = THREAD_PRIORITY_BELOW_NORMAL;
    break;
  case TThread::LOWEST:
    priority = THREAD_PRIORITY_LOWEST;
    break;
  case TThread::IDLE:
    priority = THREAD_PRIORITY_IDLE;
    break;
  default:
    priority = THREAD_PRIORITY_NORMAL;
    break;
  }
  return !!SetThreadPriority(threadId, priority);
}
 
//---------------------------------------------------------------------------
 
bool TThreadImp::setPreferredProcessor(int processorId) {
  DWORD rc = SetThreadIdealProcessor(threadId, processorId);
  return (rc != -1);
}
 
//---------------------------------------------------------------------------
 
TThread::TThread() : m_imp(new TThreadImp()) { m_imp->thread = this; }
 
//---------------------------------------------------------------------------
 
TThread::~TThread() { delete m_imp; }
 
//---------------------------------------------------------------------------
 
void TThread::start() {
  addRef();
  m_imp->start();
}
 
//---------------------------------------------------------------------------
 
void TThread::addRef() {
  m_imp->mutex.lock();
  m_imp->m_refCount++;
  m_imp->mutex.unlock();
}
 
//---------------------------------------------------------------------------
 
void TThread::release() {
  bool kill = false;
  m_imp->mutex.lock();
  m_imp->m_refCount--;
  if (m_imp->m_refCount <= 0) kill = true;
  m_imp->mutex.unlock();
  if (kill) delete this;
}
 
//---------------------------------------------------------------------------
 
int TThread::getRefCount() { return m_imp->m_refCount; }
 
//---------------------------------------------------------------------------
 
bool TThread::setPreferredProcessor(int processorId) {
  return m_imp->setPreferredProcessor(processorId);
}
 
//---------------------------------------------------------------------------
 
bool TThread::setThreadPriority(TThread::TThreadPriority p) {
  return m_imp->setThreadPriority(p);
}
 
//=======================
//    TThreadGroupImp
 
//---------------------------------------------------------------------------
 
TThreadGroupImp::TThreadGroupImp() {}
 
//---------------------------------------------------------------------------
 
TThreadGroupImp::~TThreadGroupImp() {}
 
//---------------------------------------------------------------------------
void TThreadGroupImp::add(TThread *t) {
  threads.push_back(t);
  t->m_imp->setOwner(this);
}
//---------------------------------------------------------------------------
 
void TThreadGroupImp::remove(TThread *t) {
  threads.remove(t);
  t->m_imp->setOwner(0);
}
//---------------------------------------------------------------------------
 
void TThreadGroupImp::wait() {
  DWORD count = threads.size();
  if (count == 0) return;
  HANDLE *hThreads = new HANDLE[count];
  int id           = 0;
  for (list<TThread *>::iterator it = threads.begin(); it != threads.end();
       it++, id++) {
    TThread *t = *it;
    if (t->m_imp->threadId == 0) t->start();
    hThreads[id] = t->m_imp->threadId;
  }
 
  DWORD rc = WaitForMultipleObjects(count, hThreads, FALSE, INFINITE);
  if (rc >= WAIT_OBJECT_0 && rc <= (WAIT_OBJECT_0 + count - 1)) {
    // cout << "obj #" << rc << endl;
  }
  if (rc >= WAIT_ABANDONED_0 && rc <= (WAIT_ABANDONED_0 + count - 1)) {
    // cout << "obj #" << rc << " abandoned" << endl;
  }
  if (rc == WAIT_TIMEOUT) {
    // cout << "timeout" << endl;
  }
 
  if (rc == WAIT_FAILED) {
    // cout << "failed" << endl;
  }
 
  delete[] hThreads;
  wait();
}
 
//---------------------------------------------------------------------------
 
TThreadGroup::TThreadGroup()
    : m_imp(new TThreadGroupImp())
 
{}
 
//---------------------------------------------------------------------------
 
TThreadGroup::~TThreadGroup() { delete m_imp; }
 
//---------------------------------------------------------------------------
 
void TThreadGroup::add(TThread *t) { m_imp->add(t); }
 
//---------------------------------------------------------------------------
 
void TThreadGroup::wait() { m_imp->wait(); }