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

#include <set>

#include <itkImageFileReader.h>
#include <itkImageSeriesReader.h>

#ifdef cpPlugins_Interface_QT4
#include <QFileDialog>
#endif // cpPlugins_Interface_QT4

// -------------------------------------------------------------------------
bool cpPlugins::IO::ImageReader::
ExecConfigurationDialog( QWidget* parent )
{
  bool r = false;

#ifdef cpPlugins_Interface_QT4

  // Show dialog and check if it was accepted
  QFileDialog dialog( parent );
  dialog.setFileMode( QFileDialog::ExistingFiles );
  dialog.setDirectory( QFileDialog::tr( "." ) );
  dialog.setNameFilter( QFileDialog::tr( "All files (*)" ) );
  if( dialog.exec( ) )
  {
    QStringList names = dialog.selectedFiles( );
    QStringList::const_iterator qIt = names.begin( );
    for( ; qIt != names.end( ); ++qIt )
      this->m_Parameters->AddToStringList(
        "FileNames", qIt->toStdString( )
        );
    this->m_Parameters->SetBool( "VectorType", false );
    r = true;

  } // fi

#endif // cpPlugins_Interface_QT4

  return( r );
}

// -------------------------------------------------------------------------
cpPlugins::IO::ImageReader::
ImageReader( )
  : Superclass( )
{
  this->_MakeOutput< cpPlugins::Interface::Image >( "Output" );

  this->m_Parameters->ConfigureAsStringList( "FileNames" );
  this->m_Parameters->ConfigureAsBool( "VectorType", false );
}

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

// -------------------------------------------------------------------------
std::string cpPlugins::IO::ImageReader::
_GenerateData( )
{
  // Get filenames
  TStringList names;
  this->m_Parameters->GetStringList( 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 2: r = this->_GD0< 2 >( io, names ); break;
        case 3: r = this->_GD0< 3 >( io, names ); break;
        case 4: r = this->_GD0< 4 >( 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::IO::ImageReader::
_GD0( itk::ImageIOBase* io, const TStringList& names )
{
  itk::ImageIOBase::IOComponentType ct = io->GetComponentType( );
  itk::ImageIOBase::IOPixelType pt = io->GetPixelType( );
  std::string r = "";

  if( pt == itk::ImageIOBase::SCALAR )
  {
    switch( ct )
    {
    case itk::ImageIOBase::UCHAR:
      r = this->_GD1< unsigned char, D >( names );
      break;
    case itk::ImageIOBase::CHAR:
      r = this->_GD1< char, D >( names );
      break;
    case itk::ImageIOBase::USHORT:
      r = this->_GD1< unsigned short, D >( names );
      break;
    case itk::ImageIOBase::SHORT:
      r = this->_GD1< short, D >( names );
      break;
    case itk::ImageIOBase::UINT:
      r = this->_GD1< unsigned int, D >( names );
      break;
    case itk::ImageIOBase::INT:
      r = this->_GD1< int, D >( names );
      break;
    case itk::ImageIOBase::ULONG:
      r = this->_GD1< unsigned long, D >( names );
      break;
    case itk::ImageIOBase::LONG:
      r = this->_GD1< long, D >( names );
      break;
    case itk::ImageIOBase::FLOAT:
      r = this->_GD1< float, D >( names );
      break;
    case itk::ImageIOBase::DOUBLE:
      r = this->_GD1< double, D >( names );
      break;
    default:
      r = "ImageReader: Scalar pixel type not supported.";
      break;
    } // hctiws
  }
  else if( pt == itk::ImageIOBase::RGB )
  {
    switch( ct )
    {
    case itk::ImageIOBase::UCHAR:
      r = this->_GD1< itk::RGBPixel< unsigned char >, D >( names );
      break;
    case itk::ImageIOBase::CHAR:
      r = this->_GD1< itk::RGBPixel< char >, D >( names );
      break;
    case itk::ImageIOBase::USHORT:
      r = this->_GD1< itk::RGBPixel< unsigned short >, D >( names );
      break;
    case itk::ImageIOBase::SHORT:
      r = this->_GD1< itk::RGBPixel< short >, D >( names );
      break;
    case itk::ImageIOBase::UINT:
      r = this->_GD1< itk::RGBPixel< unsigned int >, D >( names );
      break;
    case itk::ImageIOBase::INT:
      r = this->_GD1< itk::RGBPixel< int >, D >( names );
      break;
    case itk::ImageIOBase::ULONG:
      r = this->_GD1< itk::RGBPixel< unsigned long >, D >( names );
      break;
    case itk::ImageIOBase::LONG:
      r = this->_GD1< itk::RGBPixel< long >, D >( names );
      break;
    case itk::ImageIOBase::FLOAT:
      r = this->_GD1< itk::RGBPixel< float >, D >( names );
      break;
    case itk::ImageIOBase::DOUBLE:
      r = this->_GD1< itk::RGBPixel< double >, D >( names );
      break;
    default:
      r = "ImageReader: RGB pixel type not supported.";
      break;
    } // hctiws
  }
  else if( pt == itk::ImageIOBase::RGBA )
  {
    switch( ct )
    {
    case itk::ImageIOBase::UCHAR:
      r = this->_GD1< itk::RGBAPixel< unsigned char >, D >( names );
      break;
    case itk::ImageIOBase::CHAR:
      r = this->_GD1< itk::RGBAPixel< char >, D >( names );
      break;
    case itk::ImageIOBase::USHORT:
      r = this->_GD1< itk::RGBAPixel< unsigned short >, D >( names );
      break;
    case itk::ImageIOBase::SHORT:
      r = this->_GD1< itk::RGBAPixel< short >, D >( names );
      break;
    case itk::ImageIOBase::UINT:
      r = this->_GD1< itk::RGBAPixel< unsigned int >, D >( names );
      break;
    case itk::ImageIOBase::INT:
      r = this->_GD1< itk::RGBAPixel< int >, D >( names );
      break;
    case itk::ImageIOBase::ULONG:
      r = this->_GD1< itk::RGBAPixel< unsigned long >, D >( names );
      break;
    case itk::ImageIOBase::LONG:
      r = this->_GD1< itk::RGBAPixel< long >, D >( names );
      break;
    case itk::ImageIOBase::FLOAT:
      r = this->_GD1< itk::RGBAPixel< float >, D >( names );
      break;
    case itk::ImageIOBase::DOUBLE:
      r = this->_GD1< itk::RGBAPixel< double >, D >( names );
      break;
    default:
      r = "ImageReader: RGBA pixel type not supported.";
      break;
    } // hctiws
  }
  else if( pt == itk::ImageIOBase::VECTOR )
  {
    switch( ct )
    {
    case itk::ImageIOBase::FLOAT:
      r = this->_GD1< itk::Vector< float, D >, D >( names );
      break;
    case itk::ImageIOBase::DOUBLE:
      r = this->_GD1< itk::Vector< double, D >, D >( names );
      break;
    default:
      r = "ImageReader: Vector type not supported.";
      break;
    } // hctiws
  }
  else if( pt == itk::ImageIOBase::POINT )
  {
    switch( ct )
    {
    case itk::ImageIOBase::FLOAT:
      r = this->_GD1< itk::Point< float, D >, D >( names );
      break;
    case itk::ImageIOBase::DOUBLE:
      r = this->_GD1< itk::Point< double, D >, D >( names );
      break;
    default:
      r = "ImageReader: Point type not supported.";
      break;
    } // hctiws
  }
  else if( pt == itk::ImageIOBase::COVARIANTVECTOR )
  {
    switch( ct )
    {
    case itk::ImageIOBase::FLOAT:
      r = this->_GD1< itk::CovariantVector< float, D >, D >( names );
      break;
    case itk::ImageIOBase::DOUBLE:
      r = this->_GD1< itk::CovariantVector< double, D >, D >( names );
      break;
    default:
      r = "ImageReader: CovariantVector type not supported.";
      break;
    } // hctiws
  }
  else if( pt == itk::ImageIOBase::SYMMETRICSECONDRANKTENSOR )
  {
    switch( ct )
    {
    case itk::ImageIOBase::FLOAT:
      r =
        this->_GD1< itk::SymmetricSecondRankTensor< float, D >, D >(
          names
          );
      break;
    case itk::ImageIOBase::DOUBLE:
      r =
        this->_GD1< itk::SymmetricSecondRankTensor< double, D >, D >(
          names
          );
      break;
    default:
      r = "ImageReader: Vector type not supported.";
      break;
    } // hctiws
  }
  else if( pt == itk::ImageIOBase::DIFFUSIONTENSOR3D )
  {
    switch( ct )
    {
    case itk::ImageIOBase::FLOAT:
      r = this->_GD1< itk::DiffusionTensor3D< float >, D >( names );
      break;
    case itk::ImageIOBase::DOUBLE:
      r = this->_GD1< itk::DiffusionTensor3D< double >, D >( names );
      break;
    default:
      r = "ImageReader: Diffusion tensor type not supported.";
      break;
    } // hctiws
  }
  else if( pt == itk::ImageIOBase::COMPLEX )
  {
    switch( ct )
    {
    case itk::ImageIOBase::FLOAT:
      r = this->_GD1< std::complex< float >, D >( names );
      break;
    case itk::ImageIOBase::DOUBLE:
      r = this->_GD1< std::complex< double >, D >( names );
      break;
    default:
      r = "ImageReader: Complex type not supported.";
      break;
    } // hctiws
  }
  else if( pt == itk::ImageIOBase::OFFSET )
    r = this->_GD1< itk::Offset< D >, D >( names );
  else
    r = "ImageReader: Image pixel type not yet supported.";
  /* TODO
     itk::ImageIOBase::FIXEDARRAY
     itk::ImageIOBase::MATRIX
  */
  return( r );
}

// -------------------------------------------------------------------------
template< class P, unsigned int D >
std::string cpPlugins::IO::ImageReader::
_GD1( const TStringList& names )
{
  if( this->m_Parameters->GetBool( "VectorType" ) )
    return( this->_RealGD< itk::VectorImage< P, D > >( names ) );
  else
    return( this->_RealGD< itk::Image< P, D > >( names ) );
}

// -------------------------------------------------------------------------
template< class I >
std::string cpPlugins::IO::ImageReader::
_RealGD( const TStringList& names )
{
  cpPlugins::Interface::Image* out =
    this->GetOutput< cpPlugins::Interface::Image >( "Output" );
  if( out == NULL )
    return( "ImageReader: No output object properly created." );

  std::string r = "";
  if( names.size( ) == 1 )
  {
    // Read single image
    typedef itk::ImageFileReader< I > _SR;
    _SR* reader = this->_CreateITK< _SR >( );
    reader->SetFileName( names[ 0 ] );
    try
    {
      reader->Update( );
      out->SetITK< I >( reader->GetOutput( ) );
      out->SetName( names[ 0 ] );
    }
    catch( itk::ExceptionObject& err )
    {
      r = "ImageReader: " + std::string( err.GetDescription( ) );
      out->SetITK< I >( NULL );
      out->SetName( "" );

    } // 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 = this->_CreateITK< _MR >( );
    std::set< std::string >::const_iterator fnIt = ordered_names.begin( );
    for( ; fnIt != ordered_names.end( ); ++fnIt )
      reader->AddFileName( *fnIt );
    try
    {
      reader->Update( );
      out->SetITK< I >( reader->GetOutput( ) );
      out->SetName( *( ordered_names.begin( ) ) );
    }
    catch( itk::ExceptionObject& err )
    {
      r = "ImageReader: " + std::string( err.GetDescription( ) );
      out->SetITK< I >( NULL );
      out->SetName( "" );

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

// eof - $RCSfile$