#ifndef UTILS_H
#define UTILS_H


#include <cassert>
#include <cstdio>

#include <atomic>
#include <thread>
#include <chrono>


#define ShowDebugMSG(...) do { \
	printf("DEBUG %10ld %s:%s:%d:", \
		std::chrono::duration_cast<std::chrono::milliseconds>( \
			std::chrono::steady_clock::now().time_since_epoch() ).count(), \
		__FILE__, __func__, __LINE__); \
	printf(" " __VA_ARGS__); \
	printf("\n"); \
	fflush(stdout); \
} while(0)

#define HideDebugMSG(...) do {} while(0)



class ReadProtector {
private:
	std::atomic<int> enters;
	std::atomic<int> exits;
	
public:
	inline ReadProtector(): enters(0), exits(0) { }
	inline ~ReadProtector() { assert(!(enters - exits)); }
	inline void lock() { enters++; }
	inline void unlock() { exits++; }
	inline void wait() const {
		int en = enters;
		while(en - exits > 0) std::this_thread::yield();
	}
};


class ReadLock {
private:
	ReadProtector &protector;
	ReadLock(const ReadLock&) = delete;
public:
	inline explicit ReadLock(ReadProtector &protector): protector(protector) { protector.lock(); }
	inline ~ReadLock() { protector.unlock(); }
};




template<typename T, T* T::*NextField>
class ChainFuncs {
private:
	ChainFuncs() { }

public:
	typedef T Type;
	static constexpr Type* Type::*Next = NextField;
	
	static inline void push(Type* &first, Type &item)
		{ assert(!(item.*Next)); item.*Next = first; first = &item; }
	static inline void push(std::atomic<Type*> &first, Type &item)
		{ assert(!(item.*Next)); item.*Next = first; while(!first.compare_exchange_weak(item.*Next, &item)); }
	
	static inline Type* pop(Type* &first) {
		Type *item = first;
		if (!item) return nullptr;
		first = item->next;
		item->next = nullptr;
		return item;
	}
	static inline Type* pop(std::atomic<Type*> &first) {
		Type *item = first;
		do {
			if (!item) return nullptr;
		} while(!first.compare_exchange_weak(item, item->*Next));
		item->next = nullptr;
		return item;
	}
	
	static inline void invert(Type* &first) {
		if (Type *curr = first) {
			Type *prev = nullptr;
			while(Type *next = curr->*Next)
				{ curr->*Next = prev; prev = curr; curr = next; }
			first = curr;
		}
	}
	static inline Type* inverted(Type *first)
		{ invert(first); return first; }
};


// multhreaded input, single threaded output
// simultaneus read and write are allowed
template<typename T, T* T::*NextField>
class QueueMISO {
public:
	typedef T Type;
	typedef ChainFuncs<Type, NextField> Funcs;
	static constexpr Type* Type::*Next = NextField;
	
private:
	std::atomic<Type*> pushed;
	Type *first;
	
public:
	inline QueueMISO():
		pushed(nullptr), first() { }
	inline ~QueueMISO()
		{ assert(!pushed && !first); }
	inline void push(Type &item)
		{ Funcs::push(pushed, item); }
	inline Type& pop()
		{ assert(first); return *Funcs::pop(first); }
	inline void unpop(Type &item)
		{ return Funcs::push(first, item); }
	inline Type *peek()
		{ return first ? first : (first = Funcs::inverted(pushed.exchange(nullptr))); }
};


template<typename T, T* T::*NextField>
class CounteredQueueMISO: public QueueMISO<T, NextField> {
public:
	typedef T Type;
	typedef QueueMISO<Type, NextField> Queue;
	
private:
	std::atomic<int> counter;
	
public:
	inline CounteredQueueMISO():
		counter(0) { }
	inline ~CounteredQueueMISO()
		{ assert(!counter); }
	inline void push(Type &item)
		{ Queue::push(item); counter++; }
	inline Type& pop()
		{ Type &item = Queue::pop(); counter++; return item; }
	inline int count() const
		{ return counter; }
};


#endif