#ifndef GLTB_WORKQUEUE_H
#define GLTB_WORKQUEUE_H

#include <functional>
#include <list>
#include <queue>
#include <vector>

#include "GLTB/conditionvariable.h"
#include "GLTB/mutex.h"
#include "GLTB/referencedobject.h"
#include "GLTB/semaphore.h"
#include "GLTB/systeminfo.h"
#include "GLTB/thread.h"

namespace gltb {
	class WorkItem : public ReferencedObject {
	public:
		virtual void run() = 0;
	};

	template<typename callable>
	class CallableWorkItem : public WorkItem {
	public:
		CallableWorkItem(callable c) : c(c) {};

		void run() override {
			c();
		}
	private:
		callable c;
	};

	class Worker;

	class WorkQueue : public ReferencedObject {
		std::queue<RefPtr<WorkItem> > workItems;

		RefPtr<Mutex> queueMutex;
		RefPtr<ConditionVariable> queueEmpty;

		std::list<RefPtr<Worker> > idleWorkerQueue;

		std::vector<RefPtr<WorkItem> > activeWorkItems;
		RefPtr<Mutex> activeWorkMutex;
		RefPtr<ConditionVariable> activeWorkEmpty;

	public:
		WorkQueue();

		void pushWorkItem(gltb::RefPtr<WorkItem> item);

		// MSVC and GCC have different opinions on what to call if this was called pushWorkItem as well
		template<typename callable>
		void pushCallable(callable c) {
			gltb::RefPtr<WorkItem> item=new CallableWorkItem<callable>(c);
			pushWorkItem(item);
		}

		bool hasWorkAvailable();
		bool isEmpty();

	private:
		gltb::RefPtr<WorkItem> popWorkItem(gltb::RefPtr<Worker> worker, bool withTimeout, int timeout);

	public:

		/**
		 * Pop a work item from the queue. When the work queue is empty, this 
		 * function blocks until a new item is added or wakeAllWaitingThreads() 
		 * is called. It does not time out.
		 *
		 * @param worker worker that requests the next job
		 * @return next work item to process or nullptr if queue is empty
		 */
		gltb::RefPtr<WorkItem> popWorkItem(gltb::RefPtr<Worker> worker) {
			return popWorkItem(worker,false,0);
		}

		/**
		 * Pop a work item from the queue. When the work queue is empty, this
		 * function waits for a certain time and gives up unless a new work 
		 * item is added or wakeAllWaitingThreads() is called.
		 *
		 * @param worker worker that requests the next job
		 * @return next work item to process or nullptr on timeout/empty queue
		 */
		gltb::RefPtr<WorkItem> popWorkItem(gltb::RefPtr<Worker> worker, int timeout) {
			return popWorkItem(worker,true,timeout);
		}

		void finishWorkItem(gltb::RefPtr<WorkItem> item);

		/**
		 * Signal all threads waiting for work. Use this with care as it may 
		 * have sideeffects. It is intended to be used to terminate worker
		 * threads that wait for work indefinitely.
		 */
		void wakeAllWaitingThreads();

		/**
		 * Wait until all jobs have been started, that is, until the queue of waiting jobs
		 * is empty.
		 */
		void waitForEmptyQueue();
		/**
		 * Wait until all jobs have been started, that is, until the queue of waiting jobs
		 * is empty, or until the given time in milliseconds has passed. Note that this
		 * function is prone to spurious wakeups and may return early.
		 *
		 * @return true if queue is empty, false if timeout or spurious wakeup occurred
		 */
		bool waitForEmptyQueue(int timeout);

		/**
		 * Wait until all jobs in the queue have been finished and all workers are idle.
		 */
		void waitForCompletedWork();
		/**
		 * Wait until all jobs in the queue have been finished and all workers are idle.
		 * Note that this function is prone to spurious wakeups and may return early.
		 *
		 * @return true if queue is empty, false if timeout or spurious wakeup occurred
		 */
		bool waitForCompletedWork(int timeout);
	};

	class Worker : public ReferencedObject {
	public:
		Worker(gltb::RefPtr<WorkQueue> queue);

		void processOneJob(bool block=false);

		// FIXME these two functions and the worker argument to WorkQueue::popWorkItem produce a tangled mess
		void _waitForWork(gltb::RefPtr<Mutex> mutex) { workAvailable->wait(mutex); }
		bool _waitForWork(gltb::RefPtr<Mutex> mutex, int timeout) { return workAvailable->wait(mutex, timeout); };

		void wakeUp() { workAvailable->signal(); }

	protected:
		RefPtr<ConditionVariable> workAvailable;

		gltb::RefPtr<WorkQueue> queue;
	};

	class WorkerRunnable : public Worker, public Runnable {
	public:
		WorkerRunnable(gltb::RefPtr<WorkQueue> queue, RefPtr<Semaphore> startupSemaphore, RefPtr<WorkItem> perThreadInit = nullptr)
			: Worker(queue), Runnable(), keepRunning(true), startupSemaphore(startupSemaphore), perThreadInit(perThreadInit) {
		}

		void run() override {
			startupSemaphore->signal();
			startupSemaphore = nullptr; // don't need this anymore - forget reference

			if(perThreadInit!=nullptr) {
				perThreadInit->run();
				perThreadInit=nullptr;
			}

			while(keepRunning) {
				processOneJob(true);
			}
		}

		void quit() {
			keepRunning=false;
			wakeUp();
		}

	private:
		bool keepRunning;
		RefPtr<Semaphore> startupSemaphore;
		RefPtr<WorkItem> perThreadInit;
	};

	class WorkerPool : public ReferencedObject {
	public:
		WorkerPool(RefPtr<WorkQueue> queue, const unsigned int size, RefPtr<WorkItem> perThreadInit=nullptr);

		template<typename callable>
		WorkerPool(RefPtr<WorkQueue> queue, const unsigned int size, callable perThreadInit) 
			: workQueue(queue), alreadyShutDown(false)
		{
			initWorkerPool(size,new CallableWorkItem<callable>(perThreadInit));
		}

		WorkerPool(RefPtr<WorkQueue> queue, RefPtr<WorkItem> perThreadInit=nullptr);

		~WorkerPool();

		/**
		 * Assign worker threads to one processor each to reduce overhead caused by
		 * OS scheduling. If the number of threads is higher than the number of
		 * processors, only as many threads as there are processors are assigned.
		 *
		 * This only works if Thread::assignToProcessor() is implemented
		 * for the target platform. Otherwise this method does nothing.
		 */
		void assignThreadsToProcessors();
		/**
		 * Assign worker threads to the given processors to prevent the OS from
		 * scheduling them to random processors. If the number of threads is higher
		 * than the number of processors, only as many threads as there are
		 * processors are assigned.
		 *
		 * This only works if Thread::assignToProcessor() is implemented
		 * for the target platform. Otherwise this method does nothing.
		 */
		void assignThreadsToProcessors(const std::vector<unsigned int> &processors);

		/**
		 * Make the worker threads quit work and exit. By default, this function will wait until all
		 * pending work items are processed.
		 *
		 * @param immediately if set, don't wait until work queue is empty before terminating workers
		 */
		void quit(bool immediately=false);

		/**
		 * Get the number of worker threads in this worker pool.
		 */
		size_t getNumWorkers() const { return workerThreads.size(); };

		std::vector<unsigned int> getWorkerThreadIds();

	private:
		RefPtr<WorkQueue> workQueue;
		std::vector<RefPtr<WorkerRunnable> > workerRunnables;
		std::vector<RefPtr<Thread> > workerThreads;

		bool alreadyShutDown;

		void initWorkerPool(const unsigned int size, RefPtr<WorkItem> perThreadInit);
	};
}

#endif