#ifndef __DefOrgViewerAdapter_h
#define __DefOrgViewerAdapter_h

#include "itkImageFileReader.h"
#include "itkImageFileWriter.h"
#include "itkMeanImageFilter.h"
#include "itkBinaryThresholdImageFilter.h"
#include "itkCovariantVector.h"

#include "vtkUnstructuredGrid.h"
#include "vtkCellArray.h"
#include "vtkProperty.h"

#include <iostream>
#include "itkOrganism.h"
#include "Phys_Euler.h"
#include "Ctrl_ScheduleDriven.h"
#include "Beh_TranslateAll.h"
#include "Def_Translation.h"
#include "Sense_Gradient.h"
#include "Geom_MeshSpatialObject.h"
#include "Phys_LevelSet.h"

#include "itkImage.h"
#include "itkImageFileReader.h"
#include "vtkImageImport.h"
#include "itkVTKImageExport.h"
#include "DefOrgViewerAdapter.h"

#include <vtksys/SystemTools.hxx>
#include <vtksys/CommandLineArguments.hxx>


#define N_DIMS 3
typedef unsigned char									PixelType;
typedef itk::Image< PixelType, N_DIMS >					ImageType;
typedef itk::ImageFileReader< ImageType >				ImageFileReader;
typedef ImageFileReader::Pointer						ImageFileReaderPointer;
typedef  itk::VTKImageExport< ImageType >				itkImageExportType;
typedef itkImageExportType::Pointer						itkImageExportTypePointer;
typedef itk::SceneSpatialObject<N_DIMS>::Pointer		itkScenePointer;

#define SetStringMacro(name) \
  virtual void Set##name (const char* _arg) \
  { \
    if ( _arg && (_arg == this->m_##name) ) { return;} \
    if (_arg) \
      { \
      this->m_##name = _arg;\
      } \
     else \
      { \
      this->m_##name = ""; \
      } \
  } 

class VistVTKCellsClass;

class DefOrgViewerAdapter{
public:
	// typedefs for the defOrg:
	typedef float											DataType;	
	typedef	 Geom_MeshSpatialObject< DataType, N_DIMS >		GeometricType;
	typedef itk::CovariantVector< DataType, N_DIMS >		GradientPixelType;
	typedef itk::Image< GradientPixelType, N_DIMS >			GradientImageType;
	typedef Phys_LevelSet< DataType, ImageType, N_DIMS >	LevelSetPhysicsType;
	typedef Phys_Euler< DataType, 
		GradientImageType, N_DIMS >							EulerPhysicsType;
	typedef Sense_Gradient< DataType, ImageType, 
		GradientImageType, N_DIMS >							GradientSensorType;
	typedef Ctrl_ScheduleDriven<DataType, N_DIMS>			CognitiveType;
	typedef Beh_TranslateAll<DataType, N_DIMS>				Beh_TranslateAllType;
	typedef Def_Translation<DataType, N_DIMS>				Def_TranslateAllType;

	typedef itk::ItkOrganism < ImageType, ImageType,
		GradientImageType, DataType, N_DIMS >				OrganismType;

	typedef itk::DefaultDynamicMeshTraits<
		DataType, N_DIMS, N_DIMS >							MeshTrait;
	typedef  itk::Mesh< DataType, N_DIMS, MeshTrait >		MeshType;
	typedef  MeshType::Pointer								MeshTypePointer;

	// typedefs for itk->vtk mesh conversion:
	typedef itk::CellInterfaceVisitorImplementation<
		DataType, MeshType::CellTraits,
		itk::TriangleCell< itk::CellInterface<MeshType::PixelType, MeshType::CellTraits > >, 
		VistVTKCellsClass> TriangleVisitor;

	typedef itk::CellInterfaceVisitorImplementation<
		DataType, MeshType::CellTraits,
		itk::QuadrilateralCell< itk::CellInterface<MeshType::PixelType, MeshType::CellTraits > >, 
		VistVTKCellsClass> QuadrilateralVisitor;
	
	SetStringMacro(ScheduleFileName);
	SetStringMacro(MeshFileName);
	SetStringMacro(ImageFileName);

	DefOrgViewerAdapter();
	void SetupOrganism();
	void UpdateOrganism(itkScenePointer itkScene /*in/out*/);
	void PopulateVtkImage(vtkImageImport* vtkImporter /*in/out*/);
	void PopulateVtkUnstructuredGrid(vtkUnstructuredGrid* vtkGrid /*in/out*/);
	void PopulateItkScene(itkScenePointer itkScene /*in/out*/);
	bool IsAllInputFilesSet();

	
private:
	void ConnectPipelines( itkImageExportTypePointer exporter, vtkImageImport* importer);
	void MeshToUnstructuredGrid( MeshTypePointer mesh, vtkUnstructuredGrid* vgrid);	

	std::string m_ImageFileName;
	std::string m_ScheduleFileName;
	std::string m_MeshFileName;

	ImageFileReaderPointer			m_InputImageReader;
	itkImageExportTypePointer		m_ItkExporter;
	OrganismType::Pointer			testOrg;
	LevelSetPhysicsType				levelSetPhysLayer;
	EulerPhysicsType*				eulerPhysLayerPointer;
	GradientSensorType::sensorIn	sensorInput;
	GradientSensorType				gradientSensor;
	GeometricType*					geomLayerPointer;
	CognitiveType*					cognitiveLayerPointer;
	Beh_TranslateAllType*			beh1;
	Def_TranslateAllType*			def1;						

};

class VistVTKCellsClass
{
	vtkCellArray* m_Cells;
	int* m_LastCell;
	int* m_TypeArray;
public:
	// typedef the itk cells we are interested in
	typedef itk::CellInterface<
		DefOrgViewerAdapter::MeshType::PixelType, 
		DefOrgViewerAdapter::MeshType::CellTraits >  CellInterfaceType;

	typedef itk::TriangleCell<CellInterfaceType>      floatTriangleCell;
	typedef itk::QuadrilateralCell<CellInterfaceType> floatQuadrilateralCell;

	// Set the vtkCellArray that will be constructed
	void SetCellArray(vtkCellArray* a) 
	{
		m_Cells = a;
	}
	// Set the cell counter pointer
	void SetCellCounter(int* i)
	{
		m_LastCell = i;
	}
	// Set the type array for storing the vtk cell types
	void SetTypeArray(int* i)
	{
		m_TypeArray = i;
	}
	// Visit a triangle and create the VTK_TRIANGLE cell 
	void Visit(unsigned long, floatTriangleCell* t)
	{
		m_Cells->InsertNextCell(3,  (vtkIdType*)t->PointIdsBegin());
		m_TypeArray[*m_LastCell] = VTK_TRIANGLE;
		(*m_LastCell)++;
	}
	// Visit a triangle and create the VTK_QUAD cell 
	void Visit(unsigned long, floatQuadrilateralCell* t)
	{
		m_Cells->InsertNextCell(4,  (vtkIdType*)t->PointIdsBegin());
		m_TypeArray[*m_LastCell] = VTK_QUAD;
		(*m_LastCell)++;
	}
};


#endif