/*
    PIP - Platform Independent Primitives
    Thread
    Copyright (C) 2013  Ivan Pelipenko peri4ko@gmail.com

    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/>.
*/

#include "pithread.h"
#include "pisystemtests.h"


void piUSleep(int usecs) {
#ifdef WINDOWS
	if (usecs > 0) Sleep(usecs / 1000);
#else
	usecs -= PISystemTests::usleep_offset_us;
	if (usecs > 0) usleep(usecs);
#endif
}


/*! \class PIThread
 * \brief Thread class
 * \details This class allow you exec your code in separate thread.
 * 
 * \section PIThread_sec0 Synopsis
 * Multithread .
 * 
 * \section PIThread_sec1 To/from data convertions
 * Most common constructor is \a PIThread(const char * str), where "str"
 * is null-terminated string, e.g. \c "string". This is 7 chars with last char = 0.
 * Also you can constructs \a PIThread from single \a PIChar, \a PIByteArray,
 * other \a PIThread or sequency of the same characters with custom length.\n \n
 * This class has implicit conversions to <tt>const char * </tt> and 
 * \c std::string. Also there are functions to make same convertions:
 * * \a data() - to <tt>const char * </tt>,
 * * \a stdString() - to \c std::string,
 * * \a toByteArray() - to \a PIByteArray.
 * 
 * \section PIThread_sec2 Numeric operations
 * You can get symbolic representation of any numeric value with function
 * \a setNumber(any integer value, int base = 10, bool * ok = 0). Default 
 * arguments are set for decimal base system, but you can choose any system
 * from 2 to 40. There are the same static functions \a fromNumber(), that
 * returns \a PIThread. \n
 * Also there is function \a setReadableSize() which is set human-readable
 * size in bytes, Kb, Mb, Gb or Pb. Static analog is \a readableSize().
 * 
 */


PIThread::PIThread(void * data, ThreadFunc func, bool startNow, int timer_delay): PIObject() {
	piMonitor.threads++;
	data_ = data;
	ret_func = func;
	running = lockRun = false;
	priority_ = piNormal;
	timer = timer_delay;
	if (startNow) start(timer_delay);
}


PIThread::PIThread(bool startNow, int timer_delay): PIObject() {
	piMonitor.threads++;
	ret_func = 0;
	running = lockRun = false;
	priority_ = piNormal;
	timer = timer_delay;
	if (startNow) start(timer_delay);
}


PIThread::~PIThread() {
	piMonitor.threads--;
	if (!running) return;
#ifndef WINDOWS
	pthread_cancel(thread);
#else
	TerminateThread(thread, 0);
	CloseHandle(thread);
#endif
}


bool PIThread::start(int timer_delay) {
	if (running) return false;
	terminating = running = false;
	timer = timer_delay;
#ifndef WINDOWS
	pthread_attr_t attr;
	pthread_attr_init(&attr);
	pthread_attr_setschedparam(&attr, &sparam);
	if (pthread_create(&thread, &attr, thread_function, this) == 0) {
		setPriority(priority_);
		running = true;
		return true;
	}
#else
	thread = CreateThread(0, 0, (LPTHREAD_START_ROUTINE)thread_function, this, 0, 0);
	if (thread != 0) {
		setPriority(priority_);
		running = true;
		return true;
	}
#endif
	return false;
}


bool PIThread::startOnce() {
	if (running) return false;
	terminating = running = false;
#ifndef WINDOWS
	pthread_attr_t attr;
	pthread_attr_init(&attr);
	pthread_attr_setschedparam(&attr, &sparam);
	if (pthread_create(&thread, &attr, thread_function_once, this) == 0) {
		setPriority(priority_);
		running = true;
		return true;
	}
#else
	thread = CreateThread(0, 0, (LPTHREAD_START_ROUTINE)thread_function_once, this, 0, 0);
	if (thread != 0) {
		setPriority(priority_);
		running = true;
		return false;
	}
#endif
	return false;
}


void PIThread::terminate() {
	if (thread == 0) return;
	running = false;
#ifndef WINDOWS
	pthread_cancel(thread);
#else
	TerminateThread(thread, 0);
	CloseHandle(thread);
#endif
	thread = 0;
	end();
}


void * PIThread::thread_function(void * t) {
#ifndef WINDOWS
	pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, 0);
	pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, 0);
#endif
	PIThread & ct = *((PIThread * )t);
	ct.running = true;
	ct.begin();
	ct.started();
	while (!ct.terminating) {
		if (ct.lockRun) ct.mutex_.lock();
		ct.run();
		if (ct.ret_func != 0) ct.ret_func(ct.data_);
		if (ct.lockRun) ct.mutex_.unlock();
		if (ct.timer > 0) msleep(ct.timer);
	}
	ct.stopped();
	ct.end();
	ct.running = false;
	//cout << "thread " << t << " exiting ... " << endl;
#ifndef WINDOWS
	pthread_exit(0);
#else
	ExitThread(0);
#endif
	return 0;
}


void * PIThread::thread_function_once(void * t) {
#ifndef WINDOWS
	pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, 0);
	pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, 0);
#endif
	PIThread & ct = *((PIThread * )t);
	ct.running = true;
	ct.begin();
	ct.started();
	if (ct.lockRun) ct.mutex_.lock();
	ct.run();
	if (ct.ret_func != 0) ct.ret_func(ct.data_);
	if (ct.lockRun) ct.mutex_.unlock();
	ct.stopped();
	ct.end();
	ct.running = false;
	//cout << "thread " << t << " exiting ... " << endl;
#ifndef WINDOWS
	pthread_exit(0);
#else
	ExitThread(0);
#endif
	return 0;
}


void PIThread::setPriority(PIThread::Priority prior) {
	priority_ = prior;
#ifndef WINDOWS
#  ifndef LINUX
	sparam.sched_priority = (int)priority_;
#  else
	sparam.__sched_priority = (int)priority_;
#  endif
	if (!running) return;
	pthread_getschedparam(thread, &policy, &sparam);
	pthread_setschedparam(thread, policy, &sparam);
#else
	if (!running) return;
	SetThreadPriority(thread, -(int)priority_);
#endif
}


bool PIThread::waitForFinish(int timeout_msecs) {
	if (timeout_msecs < 0) {
		while (running)
			msleep(1);
		return true;
	}
	int cnt = 0;
	while (running && cnt < timeout_msecs) {
		msleep(1);
		++cnt;
	}
	return cnt < timeout_msecs;
}


bool PIThread::waitForStart(int timeout_msecs) {
	if (timeout_msecs < 0) {
		while (!running)
			msleep(1);
		return true;
	}
	int cnt = 0;
	while (!running && cnt < timeout_msecs) {
		msleep(1);
		++cnt;
	}
	return cnt < timeout_msecs;
}