#include <creaImageIOImageReader.h>
#include <creaImageIOTreeAttributeDescriptor.h>
#include <creaImageIOSystem.h>

#include <creaImageIOVtkImageReader.h>
#include <creaImageIODicomImageReader.h>

#include <vtkPNGReader.h>
#include <vtkTIFFReader.h>
#include <vtkJPEGReader.h>
#include <vtkBMPReader.h>
#include <vtkSLCReader.h>
#include <vtkMetaImageReader.h>
//#include <vtkGESignalReader.h>



#include "boost/filesystem/path.hpp"

namespace creaImageIO
{
  


  //===================================================================== 
  /*
  void IRFillFields(DicomNode* node, 
		  GDCM_NAME_SPACE::File* gdcmFile)
  {
    const DicomNodeTypeDescription::FieldDescriptionMapType& dm
      = node->GetTypeDescription().GetFieldDescriptionMap();
    DicomNodeTypeDescription::FieldDescriptionMapType::const_iterator i;
    
	
    DicomNode::FieldValueMapType& vm = node->GetFieldValueMap();
    for (i=dm.begin(); i!=dm.end(); ++i)
      {
	if ( (i->second.flags==0) && 
	     (i->second.group!=0) && 
	     (i->second.element!=0) )
	  {
		uint16_t gr = i->second.group;
		uint16_t el = i->second.element;

		std::string val = gdcmFile->GetEntryString(gr,el);

	    vm[i->first] = irclean(val);
	  }
	else 
	  {
	    vm[i->first] = "";
	  }
      }
  }
  */
  //=====================================================================




  //=====================================================================
  ImageReader::ImageReader()
    :   
    mUnreadableImage(0),
    mLastFilename("&&&&&&&&&&&&&&&&&&&&&&&&&&&&&"),
    mLastReader(0)

  {
    //    std::cout << "#### ImageReader::ImageReader()"<<std::endl;
    if (mUnreadableImage!=0) return;

    Register(new VtkImageReader(vtkPNGReader::New()));
    Register(new VtkImageReader(vtkTIFFReader::New()));
    Register(new VtkImageReader(vtkJPEGReader::New()));
    Register(new VtkImageReader(vtkBMPReader::New()));
    Register(new VtkImageReader(vtkSLCReader::New()));
    Register(new VtkImageReader(vtkMetaImageReader::New(),"MHD",".mhd"));
    //   Register(new VtkImageReader(vtkGESignalReader::New()));
    Register(new DicomImageReader);

    /*
    std::cout << "## Registered file extensions : "<<std::endl;
    std::vector<std::string>::const_iterator i;
    for (i=GetKnownExtensions().begin();
	 i!=GetKnownExtensions().end();
	 i++)
      {
	std::cout << "'"<<(*i)<<"'"<<std::endl;
      }
    */
    // 
    mUnreadableImage = vtkImageData::New();
    int dim[3];
    dim[0] = dim[1] = 128; 
    dim[2] = 1; 
    mUnreadableImage->SetDimensions ( dim );
    mUnreadableImage->SetScalarTypeToUnsignedChar();
    mUnreadableImage->AllocateScalars();    
    for (int i=0;i<dim[0];i++) 
      for (int j=0;j<dim[1];j++) 
	mUnreadableImage->SetScalarComponentFromFloat(i,j,0,0,0);
    for (int i=0;i<dim[0];i++) 
      {
	mUnreadableImage->SetScalarComponentFromFloat(i,i,0,0,255);
	mUnreadableImage->SetScalarComponentFromFloat(dim[0]-1-i,i,0,0,255);
      }


    
  }
  //=====================================================================

  //=====================================================================
  ImageReader::~ImageReader()
  {
    //    std::cout << "#### ImageReader::~ImageReader()"<<std::endl;
    std::vector<SpecificImageReader*>::iterator i;
    for (i=mReader.begin(); i!=mReader.end(); i++)
      {
	//	std::cout << "#### ImageReader::UnRegister("
	//		  << (*i)->GetName()<<")"<<std::endl;
	delete (*i);
      }
    mReader.clear();
    if (mUnreadableImage!=0) 
      {
	mUnreadableImage->Delete();
	mUnreadableImage = 0;
      }
  }
  //=====================================================================

  //=====================================================================
  void ImageReader::Register(SpecificImageReader* r)
  {
    //    std::cout << "#### ImageReader::Register("<<r->GetName()<<")"<<std::endl;
    mReader.push_back(r);
    r->PushBackExtensions(mKnownExtensions);
  }
  //=====================================================================

  //=====================================================================
  // Returns true iff the file is readable
  bool ImageReader::CanRead( const std::string& filename, 
			     const std::string& exclude )
  {
    //    std::cout << "## ImageReader::CanRead("<<filename<<")"<<std::endl;
    bool ok = false;
    std::vector<SpecificImageReader*>::iterator i;
    for (i=mReader.begin(); i!=mReader.end(); i++)
      {
	if ((*i)->GetName()==exclude) continue;
	ok = (*i)->CanRead(filename);
	if (ok) 
	  {
	    mLastFilename = filename;
	    mLastReader = *i;
	    break;
	  }
      }
    return ok;
  }
  //=====================================================================

  //=====================================================================
  // Reads the file (CanRead must be called before : no test here)
  vtkImageData*  ImageReader::ReadImage( const std::string& filename, 
					 const std::string& exclude )
  {
    //    std::cout << "## ImageReader::Read("<<filename<<")"<<std::endl;
    if (mLastFilename!=filename)
      {
	if (!CanRead(filename,exclude)) 
	  { 
	    //	    std::cout << "  -- Cannot read image "<<std::endl;
	    vtkImageData* im = vtkImageData::New();
	    im->ShallowCopy(mUnreadableImage);
	    return im;
	  }
      }
    vtkImageData* i = mLastReader->ReadImage(mLastFilename);
    //    std::cout << "i="<<i<<std::endl;
    if (i==0) 
      {
	//	std::cout << "i=UNREAD"<<i<<std::endl;
	i = vtkImageData::New();
	i->ShallowCopy(mUnreadableImage);
      }
    //    std::cout << "i="<<i<<std::endl;
    return i;
  }
  //=====================================================================


  //=====================================================================
   void ImageReader::ReadAttributes(const std::string& filename, 
				    std::map<std::string,std::string>& attr)
   {
     // std::cout << "ImageReader::ReadDicomInfo '"<<filename<<"'"<<std::endl;
    //    std::cout << "## ImageReader::Read("<<filename<<")"<<std::endl;
    if (mLastFilename!=filename)
      {
	if (!CanRead(filename)) 
	  { 
	    return;
	  }
      }
    mLastReader->ReadAttributes(mLastFilename,attr);
   }
  //=====================================================================



} // namespace creaImageIO