#include <iostream>

#include "Locker.h"
#include "ContainerThread.h"
#include "Random.h"
#include "GlobalConfigFile.h"
#include "MicroSleep.h"

// This is a test program aimed at Locker.h
// g++ -Wall -O4 -lpthread  LockerTest.C LogFile.C shared.a
// Run the program, look for the string "UNEXPECTED" or an assertion failed.
// Change one of the contansts in the code to reconfigure this.
//
// We create a very simple Data struct.  This is what we are going to protect
// with the mutex.  We create several threads.  Each one will repeatedly
// acquire and release the lock.  Each will sleep for a random amount of time
// in and outside of the lock, simulating real work.

struct Data
{
  int64_t plus;
  int64_t minus;
  Data() : plus(0), minus(0) { }
};

Locker< Data > data;

// Just so we can clean up when we are done.
int threadsRemaining;

int main(int, char **)
{
  configItemsComplete();

  std::cout<<cMicroTimeString(getMicroTime())<<" About to sleep for 1 second\n";
  microSleep(1, 0);
  std::cout<<cMicroTimeString(getMicroTime())<<" About to sleep for 2½ seconds\n";
  microSleep(2500 * 1000LL);
  std::cout<<cMicroTimeString(getMicroTime())<<" Done\n";
  
  const int threadCount = 5;
  const int maxInLockTime = 1000;
  const int maxOutOfLockTime = 2 * threadCount * maxInLockTime;
  const int iterationsPerThread = 100;
  threadsRemaining = threadCount;
  for (int threadId = 0; threadId < threadCount; threadId++)
    {
      IContainerThread *const thread =
	IContainerThread::create("Thread", true);
      auto job = [=]() {
	for (int iteration = 0; iteration < iterationsPerThread; iteration++)
	  {
	    int sleepTime = getRandom31() % maxOutOfLockTime;
	    std::string msg = cMicroTimeString(getMicroTime())
	      + ":  Thread #" + ntoa(threadId) + ", iteration #"
	      + ntoa(iteration) + ", sleeping " + addCommas(sleepTime)
	      + "ms before trying to lock.\n";
	    std::cout<<msg;
	    microSleep(sleepTime * 1000LL);
	    bool allowedToFail = (getRandom31() % 5) == 0;
	    msg = cMicroTimeString(getMicroTime())
	      + ":  Thread #" + ntoa(threadId) + ", iteration #"
              + ntoa(iteration) + ", about to lock";
	    if (allowedToFail)
	      msg += ", allowed to fail";
	    msg += '\n';
	    std::cout<<msg;
	    if (auto access = allowedToFail?data.tryLock():data.lock())
	      {
		sleepTime = getRandom31() % maxInLockTime;
		std::string msg = cMicroTimeString(getMicroTime())
		  + ":  Thread #" + ntoa(threadId) + ", iteration #"
		  + ntoa(iteration) + ", sleeping " + addCommas(sleepTime)
		  + "ms before releasing lock.\n";
		std::cout<<msg;
		access->plus++;
		access->minus--;
		assert(access->plus == -access->minus);
		microSleep(sleepTime * 1000LL);
	      }
	    else
	      {
		msg = cMicroTimeString(getMicroTime())
		  + ":  Thread #" + ntoa(threadId) + ", iteration #"
		  + ntoa(iteration) + ", lock failed";
		if (!allowedToFail)
		  msg += " UNEXPECTEDLY";
		msg += '\n';
		std::cout<<msg;
	      }
	  }
	int remaining = __sync_add_and_fetch(&threadsRemaining, -1);
	std::string msg = cMicroTimeString(getMicroTime())
	+ ":  Thread #" + ntoa(threadId) + " signing off!  "
	+ ntoa(remaining) + " of " + ntoa(threadCount) + " remain.\n";
	std::cout<<msg;
      };
      thread->addLambdaToQueue(job);
    }
  while (threadsRemaining)
    sleep(10);
}