#include "tthread.h"

#include <pthread.h></pthread.h>

//---------------------------------------------------------------------------

//    TMutex & TMutexImp

//---------------------------------------------------------------------------

class TMutexImp {

  pthread_mutex_t id;

public:

  TMutexImp();

  ~TMutexImp();

  void lock();

  void unlock();

};

//---------------------------------------------------------------------------

TMutex lockForTheList;

class TThreadGroupImp {

  list<tthread *=""> threads;</tthread>

public:

  TThreadGroupImp();

  ~TThreadGroupImp();

  void add(TThread *);

  void remove(TThread *);

  void wait();

};

//---------------------------------------------------------------------------

TMutexImp::TMutexImp() { pthread_mutex_init(&id, 0); }

//---------------------------------------------------------------------------

TMutexImp::~TMutexImp() { pthread_mutex_destroy(&id); }

//---------------------------------------------------------------------------

void TMutexImp::lock() { pthread_mutex_lock(&id); }

//---------------------------------------------------------------------------

void TMutexImp::unlock() { pthread_mutex_unlock(&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 {

  pthread_t threadId;

public:

  TThreadImp();

  ~TThreadImp();

  TThread *thread;

  void start();

  bool setThreadPriority(TThread::TThreadPriority p);

  bool setPreferredProcessor(int processorId);

  TMutex secureLock;

  bool isRunning;

  static void incNThreads() {

    mutex.lock();

    nThreads++;

    mutex.unlock();

  }

  static void decNThreads() {

    mutex.lock();

    nThreads--;

    mutex.unlock();

  }

  // some static stuff

  static TUINT32 nThreads;

  static TMutex mutex;

  friend class TThreadGroupImp;

  void setOwner(TThreadGroupImp *_owner) { owner = _owner; }

  TThreadGroupImp *owner;

};

TUINT32 TThreadImp::nThreads = 0;

TMutex TThreadImp::mutex     = TMutex();

//---------------------------------------------------------------------------

TThreadImp::TThreadImp() : isRunning(false), owner(0), thread(0) {}

//---------------------------------------------------------------------------

TThreadImp::~TThreadImp() {

  // CloseHandle(threadId);

}

//---------------------------------------------------------------------------

static void * /*__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);

  return 0;

}

//---------------------------------------------------------------------------

void TThreadImp::start() {

  incNThreads();

  pthread_create(&threadId, 0, fun, (void *)this);

}

//---------------------------------------------------------------------------

bool TThreadImp::setThreadPriority(TThread::TThreadPriority) {

  assert(!"not implemented");

  return false;

}

//---------------------------------------------------------------------------

bool TThreadImp::setPreferredProcessor(int processorId) {

#ifdef __sgi

#if (OP_RELEASE == rel_2)

  assert(!"Not implemented");

  return false;

#else

  int rc = pthread_setrunon_np(processorId);

  return (rc != -1);

#endif

#else

  assert(0);

  return false;

#endif

}

//---------------------------------------------------------------------------

TThread::TThread() : m_imp(new TThreadImp()) { m_imp->thread = this; }

//---------------------------------------------------------------------------

TThread::~TThread() { delete m_imp; }

//---------------------------------------------------------------------------

void TThread::start() { m_imp->start(); }

//---------------------------------------------------------------------------

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) {

  lockForTheList.lock();

  threads.push_back(t);

  lockForTheList.unlock();

  t->m_imp->setOwner(this);

}

//---------------------------------------------------------------------------

void TThreadGroupImp::remove(TThread *t) {

  lockForTheList.lock();

  threads.remove(t);

  lockForTheList.unlock();

  t->m_imp->setOwner(0);

}

//---------------------------------------------------------------------------

static void * /*__stdcall*/ mainFun(void *data) {

  // cout << "mainfun" << endl;

  list<tthread *=""> *threads = (list<tthread *=""> *)data;</tthread></tthread>

  // lockForTheList.lock();

  ULONG s = threads->size();

  // lockForTheList.unlock();

  // cout <<"ci sono " << s << "thread in ballo..." << endl;

  while (s != 0) {

    lockForTheList.lock();

    s = threads->size();

    lockForTheList.unlock();

  }

  return 0;

}

//---------------------------------------------------------------------------

void TThreadGroupImp::wait() {

  // cout << "wait()" << endl;

  lockForTheList.lock();

  ULONG count = threads.size();

  for (list<tthread *="">::iterator it = threads.begin(); it != threads.end();</tthread>

       it++) {

    TThread *t = *it;

    t->start();

  }

  lockForTheList.unlock();

  if (count == 0) return;

  void *mainRet = 0;

  pthread_t mainThread;

  // cout << "creo il main" << endl;

  pthread_create(&mainThread, 0, mainFun, &threads);

  // cout << mainThread << endl;

  pthread_join(mainThread, &mainRet);

}

//---------------------------------------------------------------------------

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(); }