/*
	Besturingssystemen: opdracht 1
	Academiejaar 2010-2011

	Naam: Wouter Milants
 */

 /*
	Lees aandachtig de commentaar in de code!

	Je mag overal waar je dat nodig acht code aanvullen,
	dus niet enkel op de plaatsen waar commentaar staat.
 */

#include <iostream>
#include <fstream>
#include <pthread.h>
#include <stdlib.h>
#include <semaphore.h>
using namespace std;

#ifdef WIN32
#	include <process.h>
#else
#	include <time.h>
#endif

static void Error(const char *str)
{
	std::cerr << str << std::endl;
	exit(0);
}

class Data
{
public:
	enum Status {BeingProduced, Produced, BeingHandled, Handled, None};

	Data() : status(None), value(0) {}
	void setStatus(Status s) { status = s; }
	void setValue(int v) { value = v; }
	bool checkStatus(Status s) { return status == s; }
	void print(std::ostream &ostr) { ostr << status << ' ' << value << std::endl; }

private:
	Status status;
	int value;
};

class Buffer
{
    int lastProdIndex;
    sem_t wait;
public:
	Buffer() {
            cout<<"\nconstructor";
            sem_init(&wait, 0, 0);
        }

public:
	Data *getEmptyDataElement()
	{

            Data *d;
          //  if (*lastProduced)
            //{
		//Data *d /* = empty data element */;
                //Data *d =
        //    }
         //   else
          //  {

                d = &(storage[0]);

           // }
                cout<<"getempty";
		if( !d->checkStatus(Data::None) && !d->checkStatus(Data::Handled) )
               	Error("Error: status of data is wrong during producing");
		d->setStatus(Data::BeingProduced);
                lastProdIndex = 0;



		return d;
	}

	Data *getLastProducedData()
	{
            cout<<"\nbeforewait";
                sem_wait(&wait);
                cout<<"afterwait\n";
	//	Data *d /* = last produced element */;
                Data *d = &(storage[lastProdIndex]);
                cout<<"beforehandling";
		if( d->checkStatus(Data::None) || d->checkStatus(Data::BeingProduced) )
			Error("Error: status of data is wrong during handling");
		d->setStatus(Data::BeingHandled);
		return d;
	}

	void publish(Data *d) /* update last produced, so getLastProducedData returns the correct element */
	{
		/* previously produced Data element should be emptied if not being handled */
		d->setStatus(Data::Produced);
                cout<<"\nvoorpost";
                sem_post(&wait);
	}

	void release(Data *d) /* update handled element, to make it available via getEmptyDataElement */
	{
	//	if( /* data element no longer being handled */ )
                if (! d->checkStatus(Data::BeingHandled) )
                {
			d->setStatus(Data::Handled);
                }
	}

private:
	static const int BUFFERSIZE = 10;
	Data storage[BUFFERSIZE];
	Data *lastProduced;
};

static void *start_thread(void *t);
class Thread
{
public:
	Thread() : tid(0) {}

	void start()
	{
		if( pthread_create(&tid, 0, start_thread, (void *) this) != 0 )
			Error("Error: failed to create thread");
	}

	void wait()
	{
		void *status;
		pthread_join(tid, &status);
	}

	static void sleep(unsigned int msecs)
	{
#ifdef WIN32
		if( SleepEx(msecs, TRUE) != 0 )
			Error("Error: SleepEx interrupted");
#else
        struct timespec timeout; // timeout value for wait function

        // prepare timeout value
        timeout.tv_sec = msecs / 1000;
		msecs -= timeout.tv_sec * 1000;
        timeout.tv_nsec = (1000 * msecs) * 1000;

		if( nanosleep(&timeout, 0) != 0 )
			Error("Error: nanosleep interrupted or failed");
#endif
	}

	virtual void run() = 0;

private:
	pthread_t tid;
};

static void *start_thread(void *t)
{
	reinterpret_cast<Thread *>(t)->run();
	return 0;
}

class Producer : public Thread
{
public:
	Producer(Buffer &b, long sequenceNumber) : buffer(b), sequenceNumber(sequenceNumber) {}

private:
	void run()
	{
            cout<<"run";
		for(int i = 0; i < 1000; ++i)
		{
                    cout<<"loop";
			Data *d = buffer.getEmptyDataElement();
                        cout<<"loop2";
                       	produceData(d);
			buffer.publish(d);
		}
	}

	void produceData(Data *d)
	{
            cout<<"pro\n";
		Thread::sleep((float(rand()) / RAND_MAX) * 1000); // sleep between 0 and 1 sec
                cout<<"qs";
		d->setValue(sequenceNumber++);
                cout<<"dervoor";
		d->print(std::cout);
                cout<<"derna";
	}

	Buffer &buffer;
	long sequenceNumber;
};


class Handler : public Thread
{
public:
	Handler(Buffer &b, std::ostream &ostr) : buffer(b), ostr(ostr) {}

private:

	void run()
	{
            Data *d;
	//	while( /* data available or producer active */ )

            while (1)
		{
                cout<<"\nhandlerloop";
			d = buffer.getLastProducedData();
			handleData(d);
			buffer.release(d);
		}
	}
	void handleData(Data *d)
	{
		d->print(ostr);
		Thread::sleep((float(rand()) / RAND_MAX) * 1000); // sleep between 0 and 1 sec
	}

	Buffer &buffer;
	std::ostream &ostr;
};

int main()
{
	Buffer buff;

	std::ofstream file1;
	std::ofstream file2;

	// open the files
	file1.open("C:\\Users\\Wouter\\Desktop\\UHasselt\\BES\\opdracht1\\file1.txt", std::ios::out|std::ios::trunc);
	file2.open("C:\\Users\\Wouter\\Desktop\\UHasselt\\BES\\opdracht1\\file2.txt", std::ios::out|std::ios::trunc);

	Producer p(buff, 0);
         cout<<"prodData\n";

	p.start();

        Handler h1(buff, std::cout), h2(buff, file1), h3(buff, file2);
        cout<<"nahandler";

	h1.start();
	h2.start();
	h3.start();

	// wait until producers stopped producing and handlers handled all produced data

	return EXIT_SUCCESS;
}