#include <iostream>
#include <vector>
#include <cstdlib>

#include "GLTB/mutex.h"
#include "GLTB/referencedobject.h"
#include "GLTB/refptr.h"
#include "GLTB/rng.h"
#include "GLTB/thread.h"
#include "GLTB/weakptr.h"

class TestClass : public gltb::ReferencedObject {
public:
	TestClass() : x(0) {};
	int x;
};

class StressTestRunnable : public gltb::Runnable {
public:
	StressTestRunnable() {
		testObjectLock=gltb::Mutex::createMutex();
		testObjectWeakRefLock=gltb::Mutex::createMutex();
		for(int i=0;i<10;i++) {
			objects.push_back(new TestClass);
			objectsWeakRefs.push_back(objects[i]);
		}
	};
	
	~StressTestRunnable() {
		objects.clear();
		objectsWeakRefs.clear();
	}
  
	virtual void run();
	
	int threadID;
	int numIterations;
	gltb::RefPtr<gltb::Mutex> testObjectLock;
	gltb::RefPtr<gltb::Mutex> testObjectWeakRefLock;
	std::vector<gltb::RefPtr<TestClass> > objects;
	std::vector<gltb::WeakPtr<TestClass> > objectsWeakRefs;
};

std::vector<StressTestRunnable *> runnables;

void StressTestRunnable::run()
{
	gltb::Random rng;
	rng.init(threadID);
	
	
	int i=0;
	
	do {
		i++;

		switch(rng.genrandInt32()%12) {
		case 0:
			testObjectLock->lock();
			objects.push_back(new TestClass);
// 			if(objects[objects.size()-1].getNakedPointer()>(void*)0x7fff00000000) {
// 				std::cout << "case 0: new TestClass ptr is " << objects[objects.size()-1].getNakedPointer() << std::endl;
// 			}
			testObjectLock->unlock();
			break;
			
		case 1:
			testObjectLock->lock();
			if(objects.size()>10) {
			    int i=rng.genrandInt32()%objects.size();
			    objects.erase(objects.begin()+i);
			}
			testObjectLock->unlock();
			break;
			
		case 2:
		{
			int threadIdx=rng.genrandInt32()%runnables.size();
			runnables[threadIdx]->testObjectLock->lock();
			int i=rng.genrandInt32()%runnables[threadIdx]->objects.size();
			gltb::WeakPtr<TestClass> weakRef=runnables[threadIdx]->objects[i];
			runnables[threadIdx]->testObjectLock->unlock();
			
			testObjectWeakRefLock->lock();
			objectsWeakRefs.push_back(weakRef);
			testObjectWeakRefLock->unlock();
			break;
		}	
		case 3:
			testObjectWeakRefLock->lock();
			if(objectsWeakRefs.size()>10) {
			    int i=rng.genrandInt32()%objectsWeakRefs.size();
			    objectsWeakRefs.erase(objectsWeakRefs.begin()+i);  
			}
			testObjectWeakRefLock->unlock();
			break;
			
		case 4:
		{
			int threadIdx=rng.genrandInt32()%runnables.size();
			runnables[threadIdx]->testObjectWeakRefLock->lock();
			int i=rng.genrandInt32()%runnables[threadIdx]->objectsWeakRefs.size();
			gltb::WeakPtr<TestClass> weakRef=runnables[threadIdx]->objectsWeakRefs[i];
			runnables[threadIdx]->testObjectWeakRefLock->unlock();
			
			gltb::RefPtr<TestClass> ref=weakRef.getRefPtr();
			if(ref!=0) {
				ref->x++;
			}
			break;
		}	
		case 5:
		{
			int threadIdx=rng.genrandInt32()%runnables.size();
			runnables[threadIdx]->testObjectLock->lock();
			int i=rng.genrandInt32()%runnables[threadIdx]->objects.size();
			gltb::RefPtr<TestClass> ref=runnables[threadIdx]->objects[i];
			runnables[threadIdx]->testObjectLock->unlock();
			
			if(ref!=0) {
				ref->x++;
			}
			break;
		}	
		case 6:
		{
			int threadIdx1=rng.genrandInt32()%runnables.size();
			int threadIdx2=rng.genrandInt32()%runnables.size();
			
			runnables[threadIdx1]->testObjectLock->lock();
			int i=rng.genrandInt32()%runnables[threadIdx1]->objects.size();
			gltb::RefPtr<TestClass> ref=runnables[threadIdx1]->objects[i];
			runnables[threadIdx1]->testObjectLock->unlock();
			
			runnables[threadIdx2]->testObjectLock->lock();
			int j=rng.genrandInt32()%runnables[threadIdx2]->objects.size();
			runnables[threadIdx2]->objects[j]=ref;
			runnables[threadIdx2]->testObjectLock->unlock();
			break;
		}	
		case 7:
		{
			int threadIdx1=rng.genrandInt32()%runnables.size();
			int threadIdx2=rng.genrandInt32()%runnables.size();
			
			runnables[threadIdx1]->testObjectWeakRefLock->lock();
			int i=rng.genrandInt32()%runnables[threadIdx1]->objectsWeakRefs.size();
			gltb::WeakPtr<TestClass> ref=runnables[threadIdx1]->objectsWeakRefs[i];
			runnables[threadIdx1]->testObjectWeakRefLock->unlock();
			
			runnables[threadIdx2]->testObjectLock->lock();
			int j=rng.genrandInt32()%runnables[threadIdx2]->objects.size();
//			runnables[threadIdx2]->objects[j]=ref.getRefPtr();
			gltb::RefPtr<TestClass> temp=ref.getRefPtr();;
			runnables[threadIdx2]->objects[j]=temp;
			runnables[threadIdx2]->testObjectLock->unlock();
			break;
		}
		case 8:
		{
			int threadIdx1=rng.genrandInt32()%runnables.size();
			int threadIdx2=rng.genrandInt32()%runnables.size();
			
			runnables[threadIdx1]->testObjectLock->lock();
			int i=rng.genrandInt32()%runnables[threadIdx1]->objects.size();
			gltb::RefPtr<TestClass> ref=runnables[threadIdx1]->objects[i];
			runnables[threadIdx1]->testObjectLock->unlock();
			
			runnables[threadIdx2]->testObjectWeakRefLock->lock();
			int j=rng.genrandInt32()%runnables[threadIdx2]->objectsWeakRefs.size();
			runnables[threadIdx2]->objectsWeakRefs[j]=ref;
			runnables[threadIdx2]->testObjectWeakRefLock->unlock();
			break;
		}	
		case 9:
		{
			int threadIdx1=rng.genrandInt32()%runnables.size();
			int threadIdx2=rng.genrandInt32()%runnables.size();
			
			runnables[threadIdx1]->testObjectWeakRefLock->lock();
			int i=rng.genrandInt32()%runnables[threadIdx1]->objectsWeakRefs.size();
			gltb::WeakPtr<TestClass> ref=runnables[threadIdx1]->objectsWeakRefs[i];
			runnables[threadIdx1]->testObjectWeakRefLock->unlock();

			runnables[threadIdx2]->testObjectWeakRefLock->lock();
			int j=rng.genrandInt32()%runnables[threadIdx2]->objectsWeakRefs.size();
			runnables[threadIdx2]->objectsWeakRefs[j]=ref;
			runnables[threadIdx2]->testObjectWeakRefLock->unlock();
			break;
		}	
		case 10:
		{
			int threadIdx=rng.genrandInt32()%runnables.size();
			runnables[threadIdx]->testObjectLock->lock();
			int i=rng.genrandInt32()%runnables[threadIdx]->objects.size();
			runnables[threadIdx]->objects[i]=0;
			runnables[threadIdx]->testObjectLock->unlock();
			
			break;
		}
		case 11:
		{
			int threadIdx=rng.genrandInt32()%runnables.size();
			runnables[threadIdx]->testObjectWeakRefLock->lock();
			int i=rng.genrandInt32()%runnables[threadIdx]->objectsWeakRefs.size();
			runnables[threadIdx]->objectsWeakRefs[i]=gltb::RefPtr<TestClass>(0);
			runnables[threadIdx]->testObjectWeakRefLock->unlock();
			
			break;
		}
		}
	} while(numIterations==-1 || i<numIterations);
}

int main(int argc, char *argv[])
{
	int numThreads=atoi(argv[1]);
	int numIterations=atoi(argv[2]);
	
	std::cout << "numThreads=" << numThreads << std::endl;
	std::cout << "numIterations=" << numIterations << std::endl;
  
	std::vector<gltb::RefPtr<gltb::Thread> > threads;
	
	for(int i=0;i<numThreads;i++) {
		StressTestRunnable *runnable=new StressTestRunnable();
		runnable->threadID=i;
		runnable->numIterations=numIterations;
		runnables.push_back(runnable);
		threads.push_back(gltb::Thread::createThread(runnable));
	}
	std::cout  << "runnables.size()=" << runnables.size() << std::endl;
	std::cout << "threads.size()=" << threads.size() << std::endl;
 	for(int i=0;i<numThreads;i++) {
 		threads[i]->start();
 	}
	
	for(int i=0;i<numThreads;i++) {
		threads[i]->join();
	}
//	std::cout << "cleaning up" << std::endl;
	for(int i=0;i<numThreads;i++) {
		delete runnables[i];
	}
  
	return 0;
}