#ifndef GENETIC_EXPLICIT_SIMULATION_H
#define GENETIC_EXPLICIT_SIMULATION_H

#include "genetic/population.h"
#include "genetic/config.h"

#include <bu/thread.h>
#include <bu/mutex.h>
#include <bu/synchroqueue.h>

namespace Genetic
{
	class Operator;
	class FitnessFunction;

	class ExplicitSimulation
	{
	public:
		ExplicitSimulation( Operator *pOper, FitnessFunction *pFunc,
				int iThreads, int iPopSize, float fKeep, float fRandom,
				bool bKeepBest=true, bool bRecalcSurvivors=false );
		virtual ~ExplicitSimulation();

		void timestep();
		const Population &getPopulation() const { return xPop; }

		Genetic::PhenotypeId selectWeighted();

		double getMinFitness() const { return dMinFitness; }
		double getMaxFitness() const { return dMaxFitness; }
        Genetic::PhenotypeId getMaxFitnessId() const;
        Genetic::Phenotype *getMaxFitnessPhenotype() const;
		double getFitness( Genetic::PhenotypeId id ) const
			{ return hFitness.get( id ); }

	protected:
		void updateFitness();
		void setFitness( Genetic::PhenotypeId, double dFitness );
		void workDone();
		void setRunning( bool b );
		bool isRunning();

	protected:
		Population xPop;
		Operator *pOper;

	private:
		int iPopSize;
		float fKeep;
		float fRandom;
		bool bKeepBest;
		bool bRecalcSurvivors;
		typedef Bu::Hash<Genetic::PhenotypeId, double> FitnessHash;
		FitnessHash hFitness;
		double dMinFitness;
		double dMaxFitness;
		double dTotalFitness;
		PhenotypeId uMaxFitness;

		Bu::Mutex mFitness;
		Bu::Condition cWorkDone;
		typedef Bu::SynchroQueue<Phenotype *> WorkQueue;
		WorkQueue qWork;
		int iWorkDone;
		bool bRunning;
		Bu::Mutex mRunning;

		class Processor : public Bu::Thread
		{
		public:
			Processor( ExplicitSimulation &rSim, FitnessFunction *pFunc,
					WorkQueue &rqWork, int iId );
			virtual ~Processor();

		protected:
			virtual void run();

			ExplicitSimulation &rSim;
			FitnessFunction *pFunc;
			WorkQueue &rqWork;
			int iId;
		};

		typedef Bu::List<Processor *> ProcessorList;
		ProcessorList lProcessor;
	};
};

#endif