#include <cpPlugins/Plugins/ImageReader.h>
#include <cpPlugins/Interface/Image.h>

#include <set>

#undef ITK_MANUAL_INSTANTIATION
#include <itkImage.h>
#include <itkRGBPixel.h>
#include <itkImageFileReader.h>
#include <itkImageSeriesReader.h>

// -------------------------------------------------------------------------
cpPlugins::Plugins::ImageReader::
ImageReader( )
  : Superclass( )
{
  this->m_ClassName = "cpPlugins::ImageReader";
  this->m_ClassCategory = "ImageReader";

  this->SetNumberOfOutputs( 1 );
  this->_MakeOutput< cpPlugins::Interface::Image >( 0 );

  using namespace cpPlugins::Interface;
  this->m_DefaultParameters.Configure( Parameters::StringList, "FileNames" );
  this->m_Parameters = this->m_DefaultParameters;
}

// -------------------------------------------------------------------------
cpPlugins::Plugins::ImageReader::
~ImageReader( )
{
}

// -------------------------------------------------------------------------
std::string cpPlugins::Plugins::ImageReader::
_GenerateData( )
{
  // Get filenames
  TStringList names;
  this->m_Parameters.GetValueAsStringList( names, "FileNames" );

  std::string r = "";
  if( names.size( ) >= 1 )
  {
    // Guess image properties
    itk::ImageIOBase::Pointer io =
      itk::ImageIOFactory::CreateImageIO(
        names[ 0 ].c_str( ),
        itk::ImageIOFactory::ReadMode
        );
    if( io.IsNotNull( ) )
    {
      io->SetFileName( names[ 0 ] );
      io->ReadImageInformation( );
      if( names.size( ) == 1 )
      {
        switch( io->GetNumberOfDimensions( ) )
        {
        case 1: r = this->_GD0< 1 >( io, names ); break;
        case 2: r = this->_GD0< 2 >( io, names ); break;
        case 3: r = this->_GD0< 3 >( io, names ); break;
        default:
          r = "ImageReader: Image dimension not supported.";
          break;
        } // hctiws
      }
      else if( names.size( ) > 1 )
      {
        switch( io->GetNumberOfDimensions( ) )
        {
        case 1: r = this->_GD0< 2 >( io, names ); break;
        case 2: r = this->_GD0< 3 >( io, names ); break;
        default:
          r = "ImageReader: Image dimension not supported.";
          break;
        } // hctiws

      } // fi
    }
    else
      r = "ImageReader: Could not CreateImageIO for \"" + names[ 0 ] + "\"";
  }
  else
    r = "No image files given";
  return( r );
}

// -------------------------------------------------------------------------
template< unsigned int D >
std::string cpPlugins::Plugins::ImageReader::
_GD0( itk::ImageIOBase* io, const TStringList& names )
{
  std::string r = "";
  switch( io->GetComponentType( ) )
  {
  case itk::ImageIOBase::UCHAR:
    r = this->_GD1< unsigned char, D >( io, names );
    break;
  case itk::ImageIOBase::CHAR:
    r = this->_GD1< char, D >( io, names );
    break;
  case itk::ImageIOBase::USHORT:
    r = this->_GD1< unsigned short, D >( io, names );
    break;
  case itk::ImageIOBase::SHORT:
    r = this->_GD1< short, D >( io, names );
    break;
  case itk::ImageIOBase::UINT:
    r = this->_GD1< unsigned int, D >( io, names );
    break;
  case itk::ImageIOBase::INT:
    r = this->_GD1< int, D >( io, names );
    break;
  case itk::ImageIOBase::ULONG:
    r = this->_GD1< unsigned long, D >( io, names );
    break;
  case itk::ImageIOBase::LONG:
    r = this->_GD1< long, D >( io, names );
    break;
  case itk::ImageIOBase::FLOAT:
    r = this->_GD1< float, D >( io, names );
    break;
  case itk::ImageIOBase::DOUBLE:
    r = this->_GD1< double, D >( io, names );
    break;
  default:
    r = "ImageReader: Atomic pixel type not supported.";
    break;
  } // hctiws
  return( r );
}

// -------------------------------------------------------------------------
template< class P, unsigned int D >
std::string cpPlugins::Plugins::ImageReader::
_GD1( itk::ImageIOBase* io, const TStringList& names )
{
  std::string r = "";
  switch( io->GetPixelType( ) )
  {
  case itk::ImageIOBase::SCALAR:
    r = this->_GD2< P, D >( names );
    break;
  case itk::ImageIOBase::RGB:
    r = this->_GD2< itk::RGBPixel< P >, D >( names );
    break;
  case itk::ImageIOBase::RGBA:
    r = this->_GD2< itk::RGBAPixel< P >, D >( names );
    break;
    /* TODO
       case itk::ImageIOBase::OFFSET:
       r = this->_GD2< itk::Offset< P >, D >( names );
       break;
       case itk::ImageIOBase::VECTOR:
       r = this->_GD2< P, D >( names );
       break;
       case itk::ImageIOBase::POINT:
       r = this->_GD2< P, D >( names );
       break;
       case itk::ImageIOBase::COVARIANTVECTOR:
       r = this->_GD2< P, D >( names );
       break;
       case itk::ImageIOBase::SYMMETRICSECONDRANKTENSOR:
       r = this->_GD2< P, D >( names );
       break;
       case itk::ImageIOBase::DIFFUSIONTENSOR3D:
       r = this->_GD2< P, D >( names );
       break;
    */
    /* TODO
       case itk::ImageIOBase::COMPLEX:
       r = this->_GD2< std::complex< P >, D >( names );
       break;
       case itk::ImageIOBase::FIXEDARRAY:
       r = this->_GD2< P, D >( names );
       break;
       case itk::ImageIOBase::MATRIX:
       r = this->_GD2< P, D >( names );
       break;
    */
  default:
    r = "ImageReader: Pixel type not supported.";
    break;
  } // hctiws
  return( r );
}

// -------------------------------------------------------------------------
template< class P, unsigned int D >
std::string cpPlugins::Plugins::ImageReader::
_GD2( const TStringList& names )
{
  typedef itk::Image< P, D > _I;

  std::string r = "";
  if( names.size( ) == 1 )
  {
    // Read single image
    typedef itk::ImageFileReader< _I > _SR;
    _SR* reader =
      dynamic_cast< _SR* >( this->m_RealProcessObject.GetPointer( ) );
    if( reader == NULL )
    {
      this->m_RealProcessObject = _SR::New( );
      reader =
        dynamic_cast< _SR* >( this->m_RealProcessObject.GetPointer( ) );

    } // fi
    reader->SetFileName( names[ 0 ] );
    try
    {
      reader->Update( );
      this->m_Outputs[ 0 ]->SetITKDataObject( reader->GetOutput( ) );
    }
    catch( itk::ExceptionObject& err )
    {
      r = "ImageReader: " + std::string( err.GetDescription( ) );
      this->m_Outputs[ 0 ]->SetITKDataObject( NULL );

    } // yrt
  }
  else if( names.size( ) > 1 )
  {
    // Read image series
    std::set< std::string > ordered_names;
    for( unsigned int i = 0; i < names.size( ); ++i )
      ordered_names.insert( names[ i ] );

    typedef itk::ImageSeriesReader< _I > _MR;
    _MR* reader =
      dynamic_cast< _MR* >( this->m_RealProcessObject.GetPointer( ) );
    if( reader == NULL )
    {
      this->m_RealProcessObject = _MR::New( );
      reader =
        dynamic_cast< _MR* >( this->m_RealProcessObject.GetPointer( ) );

    } // fi
    std::set< std::string >::const_iterator fnIt = ordered_names.begin( );
    for( ; fnIt != ordered_names.end( ); ++fnIt )
      reader->AddFileName( *fnIt );
    try
    {
      reader->Update( );
      this->m_Outputs[ 0 ]->SetITKDataObject( reader->GetOutput( ) );
    }
    catch( itk::ExceptionObject& err )
    {
      r = "ImageReader: " + std::string( err.GetDescription( ) );
      this->m_Outputs[ 0 ]->SetITKDataObject( NULL );

    } // yrt
  }
  else
    r = "ImageReader: No image files given";
  return( r );
}

// eof - $RCSfile$