//#include "creaImageIOWxISimpleDlg.h"

#include "creaImageIOWxGimmickReaderDialog.h"
#include <itkAnalyzeImageIO.h>
#include <itkImageFileReader.h>
#include <itkImage.h>
#include <itkImageSeriesWriter.h>
#include <itkNumericSeriesFileNames.h>
#include "itkImageToVTKImageFilter.h"
#include <vtkImageReader2.h>
#include <boost/filesystem/path.hpp>
#include <boost/filesystem.hpp>
#include <boost/utility.hpp>

namespace creaImageIO
{
		template <typename TImage2> 
  typename TImage2::Pointer ReadImage( const std::string &fileName) 
  { 



    typename TImage2::Pointer image; 

    typedef itk::ImageFileReader<TImage2> ReaderType; 
    typename ReaderType::Pointer reader = ReaderType::New(); 
    reader->SetFileName( fileName.c_str() ); 
    try 
      { 
      reader->Update(); 
      } 
    catch( itk::ExceptionObject & err ) 
      { 
      std::cout << "Caught an exception reading" << fileName << ": " << std::endl; 
      std::cout << err << " " << __FILE__ << " " << __LINE__ << std::endl; 
      throw err; 
      } 
    catch(...) 
      { 
      std::cout << "Error while reading image " << fileName << std::endl; 
      throw; 
      } 
     image = reader->GetOutput(); 
    
    return image; 
  } 


	///Ctor
  template <typename TImage> 
   WxISimpleDlg<TImage>::WxISimpleDlg(wxWindow *parent, 
							wxString i_title,  
							const std::string i_namedescp , 
							const std::string i_namedb)
    : wxDialog(parent, -1,_T("DISPLAY IMAGES"), wxDefaultPosition, wxSize(230,150))
   {
		namedescp	= i_namedescp; 
		namedb		= i_namedb;

	   if(!i_title.empty())
	   {
			this->SetTitle(i_title);  
	   }
	   // Button to select file(s)
	   wxButton *fileBut = new wxButton(this, -1,_T("Select a file to display"), wxPoint(10,7) );
  	   Connect( fileBut->GetId(), wxEVT_COMMAND_BUTTON_CLICKED , (wxObjectEventFunction) &WxISimpleDlg::OnReadFile ); 

	   // Button to select directory
	   wxButton *directoryBut = new wxButton(this, -1,_T("Select a directory to display"), wxPoint(10,40) );
	   Connect( directoryBut->GetId(), wxEVT_COMMAND_BUTTON_CLICKED , (wxObjectEventFunction) &WxISimpleDlg::OnReadDirectory ); 

	   // button to select creaImageIO
	   wxButton *gimmickBut = new wxButton(this, -1,_T("Select Gimmick"), wxPoint(10,70) );
	   Connect( gimmickBut->GetId(), wxEVT_COMMAND_BUTTON_CLICKED , (wxObjectEventFunction) &WxISimpleDlg::OnReadGimmick ); 

	   /// \TODO  Button to select Bruker directory
	
	Layout(); 
	
	}
//////////////////////////////////////////////////////////////////////
//                                                                  //
//////////////////////////////////////////////////////////////////////
     template <typename TImage> 
	  void WxISimpleDlg<TImage>::OnReadFile(wxCommandEvent& event)
	  {
		  int resultShowModal;
		  wxFileDialog* fileDlg = new wxFileDialog( 0,  _T("Select file"), _T(""), _T(""), crea::std2wx("*"), wxOPEN |wxFD_MULTIPLE, wxDefaultPosition);
    
		    resultShowModal = fileDlg->ShowModal();
			if ( resultShowModal==wxID_OK )
			{
				wxArrayString wxArray;
				fileDlg->GetPaths(wxArray);
				if(wxArray.size() >0)
				{
					for( int i = 0; i < wxArray.GetCount(); i++)
					{
						readImg( crea::wx2std(wxArray[i]));
					}
				} 
				else {
					// TO DO WARNING MESSAGES
				}
			}
		  SetReturnCode( resultShowModal );
//		 Close();
		 EndModal( resultShowModal );
	  }


	    template <typename TImage> 
		void WxISimpleDlg<TImage>::setExts(std::vector<std::string> i_exts)
		{
			m_exts = i_exts;
		}
 //////////////////////////////////////////////////////////////////////
//																	//
//////////////////////////////////////////////////////////////////////
	    template <typename TImage> 
	  void WxISimpleDlg<TImage>::OnReadDirectory(wxCommandEvent &event)
	  {
		  int resultShowModal;
		  bool bvalid = false;
	     long style = wxDD_DEFAULT_STYLE | wxDD_DIR_MUST_EXIST;
		 wxDirDialog* dirDlg = new wxDirDialog( 0, _T("Select the directory to display"), _T(""), style);
		 
		 resultShowModal = dirDlg->ShowModal();
		 if ( resultShowModal==wxID_OK )
		 {  
			std::string path = crea::wx2std(dirDlg->GetPath());
			typedef boost::filesystem::directory_iterator dir_it;
			dir_it itr(path);
			dir_it end_itr;
			/*if (boost::filesystem::exists(path))
			{*/
				for(;itr != end_itr; ++itr)
				{
					   bvalid = m_exts.size() == 0? true : false;
					   std::vector<std::string>::iterator it = m_exts.begin();
					   std::string ext = itr->filename().substr(itr->filename().find_last_of("."));
					   for(; it != m_exts.end(); it++)
					   {
						   if(ext == (*it) )
						   {
							   bvalid = true;
							   break;
						   }
					   }
					if (!boost::filesystem::is_directory(itr->status()) && bvalid)
					{
						readImg(itr->string().c_str());
					}
				}
		 }
		 SetReturnCode( resultShowModal );
//		 Close();
		 EndModal( resultShowModal );
	  }

	  //////////////////////////////////////////////////////////////////////
//																	//
//////////////////////////////////////////////////////////////////////
		    template <typename TImage> 
	  void WxISimpleDlg<TImage>::OnReadGimmick(wxCommandEvent &event)
	  {
		  // Run Gimmick
		   WxGimmickReaderDialog dlg(0,-1, 
				   namedescp,
				   namedb, 
				   _T("Select image(s)        - Gimmick! (c) CREATIS-LRMN 2008"),
                   wxDefaultPosition,
                   wxSize(810,750),
                   GIMMICK_2D_IMAGE_SELECTION,
                   GIMMICK_3D_IMAGE_SELECTION,
                   _3D,
				   1);
		 dlg.ShowModal();
		 if (dlg.GetReturnCode() == wxID_OK)
	     {
	//		infoimage=_T("DICOM: ???_EED_???");
//EED 07JUIN2010			dlg.GetSelectedImages(m_results,3);
			std::vector<creaImageIO::OutStrGimmick> out;
			std::vector<std::string> attr;
//				attr.push_back("D0028_0010");
//				attr.push_back("D0008_0023");
//				attr.push_back("D0008_1070");
				dlg.stopReading();
				dlg.getSelected(out, attr,true,"");
//				crea::VtkBasicSlicer(out.front().img);
			//m_results.clear();
			int size=out.size();
			int ii;
			//for (ii=0;ii<size;ii++)
			//{
				//m_results.push_back(out[ii].img);
			//}

			dlg.OnExit();
		 }
		 SetReturnCode( dlg.GetReturnCode() );
//		 Close();
		 EndModal( dlg.GetReturnCode() );
	   }


     template <typename TImage> 
	 wxString WxISimpleDlg<TImage>::getInfoImage()
	{
		return infoimage;
	}


    //////////////////////////////////////////////////////////////////////
    // Return the results vector										//
    //////////////////////////////////////////////////////////////////////
	 template <typename TImage>  
	 std::vector<typename TImage::Pointer> WxISimpleDlg<TImage>::getImagesSelected()
	  {
		  return m_Iresults;
	  }

	  template <typename TImage> 
	  void WxISimpleDlg<TImage>::readImg(const std::string &i_name)
	  {
		    // FCY : just to check but not needed, we hardly suppose that we load only same type and dim of images
		    // uncomment to test
		  	/*typedef itk::ImageIOBase::IOComponentType ScalarPixelType;
			itk::ImageIOBase::Pointer imageIO =  itk::ImageIOFactory::CreateImageIO(i_name.c_str(), itk::ImageIOFactory::ReadMode);
		    imageIO->SetFileName(i_name.c_str());
			imageIO->ReadImageInformation();
			ScalarPixelType pixelType = imageIO->GetComponentType();
			const size_t dims =  imageIO->GetNumberOfDimensions();*/

			typedef itk::ImageFileReader<TImage> ReaderType; 
		    typename ReaderType::Pointer reader = ReaderType::New(); 
			reader->SetFileName( i_name ); 
			try 
			{ 
				reader->Update(); 
			} 
			catch( itk::ExceptionObject & err ) 
			{ 
				std::cout << "Caught an exception reading" << i_name << ": " << std::endl; 
				std::cout << err << " " << __FILE__ << " " << __LINE__ << std::endl; 
				throw err; 
			} 
			catch(...) 
			{ 
				std::cout << "Error while reading image " << i_name << std::endl; 
				throw; 
			} 
			m_Iresults.push_back(reader->GetOutput()); 
    
	  }



	  template <typename TImage> 
	  void WxISimpleDlg<TImage>::split3Din3Dvtk()
	  {
		 
		 int ii;
		  if ((m_Iresults).size() != 0)
		  {

			  typename TImage::Pointer image = m_Iresults[0];
			  image->GetImageDimension();
			  typedef itk::ImageToVTKImageFilter< TImage > ConnectorType;
			  ConnectorType::Pointer connector = ConnectorType::New();
			  for(unsigned int i = 0 ;i < m_Iresults.size(); i++)
				   {
						connector->SetInput(m_Iresults[i]);
						connector->Update();
						vtkImageData *im = vtkImageData::New();
						im->ShallowCopy(connector->GetOutput());
						m_Vresults.push_back(im);
				   }
		  }
	  }



	  template <typename TImage> 
	  void WxISimpleDlg<TImage>::split4Din3Dvtk(const std::string &i_dir)
	  {
			if ((m_Iresults).size() != 0)
			{
			    typename TImage::Pointer image = m_Iresults[0];
			
				 // Size and dims for Input Image
				typedef itk::Size<4> iSize;
				typedef const itk::Size<4>::SizeValueType iSizeVal;
				iSize size = image->GetLargestPossibleRegion().GetSize();
				iSizeVal *dims_size  = size.GetSize();

				 // Output Type
				 typedef itk::Image<short,3> ImageOutputType;  
			     typedef itk::ImageSeriesWriter<TImage, ImageOutputType >  SeriesWriterType;
		  
				 SeriesWriterType::Pointer seriesWriter = SeriesWriterType::New();
				 seriesWriter->SetInput( image);
			
				 // from JPR file to generate output files
				 typedef itk::NumericSeriesFileNames NamesGeneratorType;
				 NamesGeneratorType::Pointer namesGenerator = NamesGeneratorType::New();
				 namesGenerator->SetStartIndex(0);
				 namesGenerator->SetEndIndex(dims_size[3]-1);
				 namesGenerator->SetIncrementIndex(1);
				 std::string format = i_dir;
			     format += "/image%03d.vtk";
				 namesGenerator->SetSeriesFormat( format.c_str() );
      
				 seriesWriter->SetFileNames( namesGenerator->GetFileNames() );
			
				 try
				{
					seriesWriter->Update();
					vtkImageReader2 *vReader =vtkImageReader2::New();
					for(unsigned int i = 0 ;i < dims_size[3]; i++)
					{
						vReader->SetFileName(namesGenerator->GetFileNames()[i].c_str());
						vReader->Update();
						m_Vresults.push_back(vReader->GetOutput());
					}
				}
				catch( itk::ExceptionObject & excp )
				{
					std::cerr << "Exception thrown while writing the series " << std::endl;
					std::cerr << excp << std::endl;
					//return EXIT_FAILURE;
				}
				
		  }

	  }

 }// namespace end