#include "BasicDefOrg_DefOrgViewerAdapter.h"

extern "C" 
#ifdef _WIN32
__declspec( dllexport ) 
#endif  
mial::DefOrgViewerAdapterBase* defOrgLoad()
{
	return new mial::BasicDefOrg_DefOrgViewerAdapter();
}


namespace mial{
	BasicDefOrg_DefOrgViewerAdapter::BasicDefOrg_DefOrgViewerAdapter():DefOrgViewerAdapterBaseTemplated(MaxNumberOfOutputImages()){
		geomLayerPointer = GeometricType::New();
		AddOrganismProperty("Sigma",0,10,1.0,0.1,"Sigma for Gradient Sensor");	
		/*AddOrganismProperty("numNodes",0,10,0.0,0.1,"Number of Nodes for Physics Layer");
		AddOrganismProperty("numSprings",0,10,0.0,0.1,"Number of Springs for Physics Layer");
		AddOrganismProperty("cognitiveTypeParameter",0,1000,5,1,"Ask Chris what this is");*/
		const char* physLayerChoices[] = 
		{"Euler","LevelSet"};
		const char* behLayerChoices[] = 
		{"Translate All",};
		const char* geoLayerChoices[] = 
		{"Mesh Geometry",};
		const char* cogLayerChoices[] = 
		{"Schedule Driven",};	
		AddLayer("Cognitive Layer: ",cogLayerChoices,1);
		//AddLayer("Behavior Layer: ",behLayerChoices,1);
		AddLayer("Physics Layer: ",physLayerChoices,2);
		AddLayer("Geometric Layer: ",geoLayerChoices,1);
		running =0;

	}


	int BasicDefOrg_DefOrgViewerAdapter::MaxNumberOfOutputItkSpatialObjects(){
		return 1;
	}


	unsigned int BasicDefOrg_DefOrgViewerAdapter::MaxNumberOfOutputImages(){
		return 1;
	}

	void BasicDefOrg_DefOrgViewerAdapter::HandleUserMouseInteraction(vtkTransform* userTransformation){
		userTransformation->Print(std::cout);
	}

	void BasicDefOrg_DefOrgViewerAdapter::PopulateItkScene(){
		itkScenePointer itkScene = m_OutputItkSpatialObjects[0].theItkScene;
		m_OutputItkSpatialObjects[0].isModified=true;
		/*itkScenePointer itkScene2 = m_OutputItkSpatialObjects[1].theItkScene;
		m_OutputItkSpatialObjects[1].isModified=true;*/
		geomLayerPointer->readTopologyFromFile( m_MeshFileName );
		itkScene->AddSpatialObject(geomLayerPointer->theMeshSpatialObject);  
		//itkScene2->AddSpatialObject(geomLayerPointer->theMeshSpatialObject);  
	}

	void BasicDefOrg_DefOrgViewerAdapter::PopulateVtkImage(){
		vtkImageImport* vtkImporter = m_OutputImages[0].theImageVolume;
		m_OutputImages[0].isModified=true;
		/*vtkImageImport* vtkImporter2 = m_OutputImages[1].theImageVolume;
		m_OutputImages[1].isModified=true;*/
		m_InputImageReader = ImageFileReader::New();
		m_InputImageReader->SetFileName(m_ImageFileName.c_str());

		m_InputImageReader->Update();
		ImageType::Pointer image = m_InputImageReader->GetOutput();	
		PopulateVtkImageHelper(image, vtkImporter);
		//PopulateVtkImageHelper(image, vtkImporter2);
	}


	void BasicDefOrg_DefOrgViewerAdapter::UpdateOrganism(){
		itkScenePointer itkScene = m_OutputItkSpatialObjects[0].theItkScene;
		m_OutputItkSpatialObjects[0].isModified=true;
		if(!running)
		{
			running =1;
			testOrg->run();
			running =0;
		}

		geomLayerPointer->theMeshSpatialObject->Modified();
		//itkScene->AddSpatialObject(geomLayerPointer->theMeshSpatialObject);  
	}


	void BasicDefOrg_DefOrgViewerAdapter::SetupOrganism()
	{
		//const char* test = GetLayer("Behavior Layer: ");
		if (m_Initialized){
			geomLayerPointer = GeometricType::New();
			PopulateItkScene();
		}
		m_Initialized=true;
		//TODO:: make this robust (i.e. flag errors if image not set, geom not set etc).

		// Instantiate the organism:
		testOrg = OrganismType::New();
		std::cout << "Organism created..." << std::endl;
		int a;
		std::cin >> a;
		//Setup the sensor
		GradientSensorType::sensorIn::Pointer input = GradientSensorType::sensorIn::New();

		input->sigma = GetOrganismProperty("Sigma");
		this->m_InputImageReader->Update();
		input->imageIn = this->m_InputImageReader->GetOutput();
		gradientSensorPointer = GradientSensorType::New();
		gradientSensorPointer->run(input);
		std::cout << "Gradient sensor setup complete..." << std::endl;
		GradientSensorType::sensorOut::Pointer output = (GradientSensorType::sensorOut *) (gradientSensorPointer->getOutput()).GetPointer();


		//Instantiate geomtery and physics layers
		eulerPhysLayerPointer = EulerPhysicsType::New() ;//new EulerPhysicsType(GetOrganismProperty("numNodes"),GetOrganismProperty("numSprings"),GetOrganismProperty("numPossibleDeformations"));	
		levelSetPhysLayerPointer = LevelSetPhysicsType::New() ;//new EulerPhysicsType(GetOrganismProperty("numNodes"),GetOrganismProperty("numSprings"),GetOrganismProperty("numPossibleDeformations"));	


		//Setup the LevelSet Physics
		std::cout << "This is a test of the Phys_LevelSet class." << std::endl << std::endl;
		levelSetPhysLayerPointer->setInput(this->m_InputImageReader->GetOutput());
		levelSetPhysLayerPointer->setGeometry(geomLayerPointer);


		//Setup The Euler physics
		eulerPhysLayerPointer->setExternalForces((void *) &(output->imageOut));
		eulerPhysLayerPointer->setGeometry(geomLayerPointer);

		
		testOrg->setGeometricLayer(geomLayerPointer);
		std::cout << "Physics layer added..." << std::endl;


		cognitiveLayerPointer = CognitiveType::New();//new CognitiveType(GetOrganismProperty("cognitiveTypeParameter"));

		//Pass the output of the reader to the filter, then to the writer.
		testOrg->SetInput(m_InputImageReader->GetOutput());

		if( strcmp(m_LayerBag[1].chosenOption,"Euler"))
		{
			std::cout << "Using LevelSet physics" << std::endl;
			std::cout << "Starting fast marching initialization of distance image..." << std::endl;
			levelSetPhysLayerPointer->initializeDistanceImg();
			std::cout << "Finished initializing distance image..." << std::endl;
			testOrg->setPhysicsLayer(levelSetPhysLayerPointer);
			
			beh2 = Beh_UniformScaleType::New();
			def2LevelSet = Def_UniformScaleLevelSetType::New();

			cognitiveLayerPointer->setSchedule(m_ScheduleFileName);
			this->testOrg->setCognitiveLayer(cognitiveLayerPointer);

			this->testOrg->addBehaviour(beh2);
			this->testOrg->addDeformation(def2LevelSet);



		}
		else
		{
			std::cout << "Using Euler physics" << std::endl;
			testOrg->setPhysicsLayer(eulerPhysLayerPointer);

			beh0 = Beh_SearchForObjectType::New();
			beh1 = Beh_TranslateAllType::New();
			beh2 = Beh_UniformScaleType::New();
			def1 = Def_TranslateAllType::New();
			def2Euler = Def_UniformScaleEulerType::New();
			cognitiveLayerPointer->setSchedule(m_ScheduleFileName);
			//Beh_TranslateAll<float, 3> beh1;
			//Def_Translation<float, 3> def1;								
			this->testOrg->setCognitiveLayer(cognitiveLayerPointer);

			beh0->image = this->m_InputImageReader->GetOutput();
			beh0->geomLayer = geomLayerPointer;

			this->testOrg->addBehaviour(beh0);
			this->testOrg->addBehaviour(beh1);
			this->testOrg->addDeformation(def1);

			this->testOrg->addBehaviour(beh2);
			this->testOrg->addDeformation(def2Euler);



		}

	}


	void BasicDefOrg_DefOrgViewerAdapter::PopulateVtkUnstructuredGrid(vtkUnstructuredGrid* vtkGrid /*in/out*/){
		geomLayerPointer->readTopologyFromFile( m_MeshFileName );
		MeshToUnstructuredGrid( geomLayerPointer->theMesh, vtkGrid/*in/out*/ );
	}
}