/*
 * ThreadManager.h
 *
 * Copyright (C) 2009 Matthias Schiffer <matthias@gamezock.de>
 *
 * This program is free software: you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program. If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef MAD_COMMON_THREADMANAGER_H_
#define MAD_COMMON_THREADMANAGER_H_

#include <config.h>

#include <Common/Initializable.h>
#include <Common/LogManager.h>

#include <queue>
#include <set>
#include <sigc++/slot.h>

#include "glthread/thread.h"
#include "glthread/lock.h"
#include "glthread/cond.h"

namespace Mad {
namespace Net {

class ThreadManager : public Common::Initializable {
  private:
    gl_thread_t mainThread, workerThread, loggerThread;
    std::set<gl_thread_t> threads;

    gl_lock_t threadLock;

    gl_lock_t runLock;
    bool running;

    gl_lock_t workLock;
    gl_cond_t workCond;
    std::queue<sigc::slot<void> > work;

    gl_lock_t ioLock;
    bool hasIO;
    int ioNotifyPipe[2];
    std::queue<sigc::slot<void> > ioQueue;

    static ThreadManager threadManager;

    ThreadManager() {}

    static void* workerStart(void*) {
      threadManager.workerFunc();
      return 0;
    }

    static void* loggerStart(void*) {
      Common::LogManager::get()->loggerThread();
      return 0;
    }

    void workerFunc();

    void threadFinished(gl_thread_t thread) {
      gl_lock_lock(threadLock);
      threads.erase(thread);
      gl_lock_unlock(threadLock);

      gl_thread_join(thread, 0);
    }

  protected:
    virtual void doInit();
    virtual void doDeinit();

  public:
    bool isThisMainThread() {
      return (mainThread == (gl_thread_t)gl_thread_self());
    }

    bool isThisWorkerThread() {
      gl_lock_lock(threadLock);
      bool ret = (workerThread == (gl_thread_t)gl_thread_self());
      gl_lock_unlock(threadLock);
      return ret;
    }

    void detach();

    void pushWork(const sigc::slot<void> &newWork);
    void pushIO(const sigc::slot<void> &newIO);

    void runIO();

    static ThreadManager* get() {
      return &threadManager;
    }
};

}
}

#endif /* MAD_COMMON_THREADMANAGER_H_ */