#ifndef PITHREAD_H
#define PITHREAD_H

#include <signal.h>
#include "pimutex.h"

#ifdef WINDOWS
inline void msleep(int msecs) {Sleep(msecs);}
#else
inline void msleep(int msecs) {usleep(msecs * 1000);}
#endif

class PIThread {
public:
	PIThread(bool startNow = false, int timer_delay = -1);
	~PIThread();

#ifdef QNX
	enum Priority {piHighest = 12,
				   piHigh = 11,
				   piNormal = 10,
				   piLow = 9,
				   piLowerst = 8 };
#else
	enum Priority {piHighest = -2,
				   piHigh = -1,
				   piNormal = 0,
				   piLow = 1,
				   piLowerst = 2 };
#endif

	bool start(int timer_delay = -1);
	bool startOnce();
	void stop(bool wait = false) {terminating = true; if (wait) waitForFinish();}
	void terminate(bool hard = false);
	void setPriority(PIThread::Priority prior);
	PIThread::Priority priority() const {return priority_;}
	bool isRunning() const {return running;}
	bool waitForFinish(int timeout_msecs = -1);
	bool waitForStart(int timeout_msecs = -1);
	void needLockRun(bool need) {lockRun = need;}
	void lock() {mutex_.lock();}
	void unlock() {mutex_.unlock();}
	PIMutex & mutex() {return mutex_;}

private:
	virtual void begin() {;} // executed at start
	virtual void run() {;} // main loop
	virtual void end() {;} // executed at finish

protected:
	static void * thread_function(void * t);
	static void * thread_function_once(void * t);

	volatile bool terminating, running, lockRun;
	int timer, policy;
	PIMutex mutex_;
	PIThread::Priority priority_;
#ifndef WINDOWS
	pthread_t thread;
	sched_param sparam;
#else
	void * thread;
#endif

};

#endif // PITHREAD_H