#ifndef _Mutation_H__
#define _Mutation_H__

#include <vector>
using namespace std;

#include "common.h"
#include "Halton.h"

namespace GtpVisibilityPreprocessor {

class Vector2;
class Vector3;
class VssRay;
class Preprocessor;
struct SimpleRay;
class SimpleRayContainer;

struct VssRayContainer;

class MutationBasedDistribution: public SamplingStrategy
{
public:
  MutationBasedDistribution(Preprocessor &preprocessor);
  virtual void Update(VssRayContainer &vssRays);

  virtual bool RequiresRays() { return true; }

private:
  virtual bool GenerateSample(SimpleRay &ray);

  bool
  GenerateMutation(const int index, SimpleRay &ray);
  bool
  GenerateSilhouetteMutation(const int index, SimpleRay &ray);

  bool
  GenerateMutationCandidate(const int index,
							SimpleRay &ray,
							Intersectable *object,
							const AxisAlignedBox3 &box
							);


  
  struct RayEntry {
	// halton sequence for generatin gmutations of this ray
	VssRay *mRay;
	short mMutations;
	short mUnsuccessfulMutations;
	HaltonSequence mHalton;
	float mImportance;
	float mCdf;

	Vector3 mutatedOrigin;
	Vector3 mutatedTermination;
	
	float GetSamplingFactor() const { return mMutations/mImportance; }
	
	friend bool operator<(const RayEntry &a, const RayEntry &b) {
	  return a.GetSamplingFactor() > b.GetSamplingFactor();
	}
	
	RayEntry() {}
	RayEntry(VssRay *r):mRay(r),
						mMutations(0),
						mUnsuccessfulMutations(0),
						mHalton(),
						mImportance(1.0f)
	{
	  ResetReverseMutation();
	}

	void ResetReverseMutation() {
	  mutatedOrigin = mutatedTermination = Vector3(0,0,0);
	}
	bool HasReverseMutation() const {
	  return !(mutatedOrigin == mutatedTermination);
	}
	
	void SetReverseMutation(const Vector3 &a, const Vector3 &b) {
	  mutatedOrigin = a;
	  mutatedTermination = b;
	}

  };
  

  Vector3
  ComputeOriginMutation(const VssRay &ray,
						const Vector3 &U,
						const Vector3 &V,
						const Vector2 vr2,
						const float radius
						);

  Vector3
  ComputeTerminationMutation(const VssRay &ray,
							 const Vector3 &U,
							 const Vector3 &V,
							 const Vector2 vr2,
							 const float radius
							 );


  Vector3
  ComputeSilhouetteTerminationMutation(const VssRay &ray,
									   const Vector3 &origin,
									   const AxisAlignedBox3 &box,
									   const Vector3 &U,
									   const Vector3 &V,
									   const Vector2 vr2,
									   const float radius
									   );


  bool
  ComputeReverseMutation(
						 const VssRay &oldRay,
						 const VssRay &newRay,
						 Vector3 &origin,
						 Vector3 &termination
						 );

  RayEntry &GetEntry(const int index);

  
  vector<RayEntry> mRays;
  int mMaxRays;
  float mOriginMutationSize;
  int mBufferStart;
  int mLastIndex;
};


}

#endif