private import std.thread;

private class Signal
{
	bool done=false;
}
private class WorkThread:Thread//TODO check if thread safe if not make it
{
	private Signal _signal;
	private synchronized Signal signal(Signal s,bool set)
	{
		if(set)
		{
			if(_signal&&!s)
				_signal.done=true;
			_signal=s;
		}
		return _signal;
	}
	private Signal signal(Signal s)
	{
		return signal(s,true);
	}
	private Signal signal()
	{
		return signal(null,false);
	}
	
	private void delegate() _work;
	private synchronized void delegate() work(void delegate() val)
	{
		auto a=_work;
		_work=val;
		return a;
	}
	
	private int main()
	{
		while(true)
		{
			if(signal())
			{
				work(null)();
				signal(null);
			}
			else
			{
				yield();
			}
		}
		return 0;
	}
	this()
	{
		super(&main,0);
		this.start();
	}
	Signal execute(void delegate() dg)
	{
		work(dg);
		return signal(new Signal());
	}
	bool idle()
	{
		return !signal();
	}
}
///executes functions in parallel with the first function executed in the
///calling thread. returns when all threads have finished
void parallelize(void delegate()[] functions)
{
	if((!functions)||(functions.length<=1))
		return;
	Signal[] s;
	bool running(Signal[] s)
	{
		foreach(b;s)
			if(!b.done)
				return true;
		return false;
	}
	void start(int i,void delegate() f)
	{
		WorkThread free_thread()
		{
			static WorkThread[] threads;
			foreach(t;threads)
				if(t.idle())
					return t;
			threads.length=threads.length+1;
			return threads[$-1]=new WorkThread();
		}
		s[i]=free_thread().execute(f);
	}
	s.length=functions.length-1;
	foreach(i,f;functions[1..$])
		if(f)
			synchronized start(i,f);
	if(functions[0])
		functions[0]();
	while(running(s))Thread.yield();
}
uint cores()
{
	//TODO
}