/*=========================================================================
                                                                                
  Program:   gdcm
  Module:    $RCSfile: TestAllReadCompareDicom.cxx,v $
  Language:  C++
  Date:      $Date: 2005/05/02 17:56:44 $
  Version:   $Revision: 1.42 $
                                                                                
  Copyright (c) CREATIS (Centre de Recherche et d'Applications en Traitement de
  l'Image). All rights reserved. See Doc/License.txt or
  http://www.creatis.insa-lyon.fr/Public/Gdcm/License.html for details.
                                                                                
     This software is distributed WITHOUT ANY WARRANTY; without even
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
     PURPOSE.  See the above copyright notices for more information.
                                                                                
=========================================================================*/
#include "gdcmDirList.h"
#include "gdcmFile.h"
#include "gdcmFileHelper.h"
#include "gdcmGlobal.h"
#include "gdcmTS.h"

#include <iostream>

//Generated file:
#include "gdcmDataImages.h"

/**
 * /brief   File Read/Writer specific for the TestAllReadCompareDicom test
 * /remarks The Test file format is (only in little endian) :
 *  - 4 bytes : 'gdcm'
 *  - 4 bytes : size X
 *  - 4 bytes : size Y
 *  - 4 bytes : size Z
 *  - 2 bytes : scalar size (8,16,32)
 *  - 2 bytes : number of components per pixel (1,2,3)
 *  - n bytes : datas
 */
class TestFile
{
public:
   TestFile(void);
   ~TestFile(void);

   bool IsReadable(void) {return readable;}
   int GetXSize(void) {return sizeX;};
   void SetXSize(int size) {sizeX = size;};
   int GetYSize(void) {return sizeY;};
   void SetYSize(int size) {sizeY = size;};
   int GetZSize(void) {return sizeZ;};
   void SetZSize(int size) {sizeZ = size;};
   int GetScalarSize(void) {return scalarSize;};
   void SetScalarSize(int size) {scalarSize = size;};
   int GetNumberOfComponents(void) {return components;};
   void SetNumberOfComponents(int size) {components = size;};

   unsigned long GetDataSize(void) {return GetLineSize()*sizeY*sizeZ;}
   uint8_t *GetData(void) {return data;}
   void SetData(const uint8_t *newData);

   void Load(const std::string &filename);
   void Write(const std::string &filename);

private:
   unsigned long GetLineSize(void) {return sizeX*scalarSize*components;}
   int GetSwapCode(uint32_t tag);

   void NewData(void);
   void DeleteData(void);

   void ReadFile(void);
   bool ReadFileHeader(std::ifstream *fp);
   bool ReadFileData(std::ifstream *fp);
   void WriteFile(void);
   bool WriteFileHeader(std::ofstream *fp);
   bool WriteFileData(std::ofstream *fp);

   uint8_t  ReadInt8 (std::ifstream *fp)
#if !(__GNUC__==2  && __GNUC_MINOR__<=96)
 throw( std::ios::failure );
#else
 ;
#endif
   uint16_t ReadInt16(std::ifstream *fp)
#if !(__GNUC__==2  && __GNUC_MINOR__<=96)
  throw( std::ios::failure );
#else
 ;
#endif
   uint32_t ReadInt32(std::ifstream *fp)
#if !(__GNUC__==2  && __GNUC_MINOR__<=96)
  throw( std::ios::failure );
#else
 ;
#endif
   void WriteInt8 (std::ofstream *fp,uint8_t  value);
   void WriteInt16(std::ofstream *fp,uint16_t value);
   void WriteInt32(std::ofstream *fp,uint32_t value);

   std::string fileName;
   bool readable;

   int sizeX;
   int sizeY;
   int sizeZ;
   uint16_t scalarSize;
   uint16_t components;
   uint8_t *data;
   int swapCode;

   static const unsigned int HEADER_SIZE;
};

const unsigned int MAX_NUMBER_OF_DIFFERENCE = 10;
const unsigned int TestFile::HEADER_SIZE = 20;

TestFile::TestFile()
{
   fileName = "";
   readable=false;

   sizeX = 0;
   sizeY = 0;
   sizeZ = 0;
   scalarSize = 0;
   components = 0;
   data = NULL;

   swapCode = 1234;
}

TestFile::~TestFile(void)
{
   DeleteData();
}

void TestFile::SetData(const uint8_t *newData)
{
   DeleteData();
   NewData();
   if( data )
      memcpy(data,newData,GetDataSize());
}

void TestFile::Load(const std::string &filename)
{
   fileName = filename;
   ReadFile();
}

void TestFile::Write(const std::string &filename)
{
   fileName = filename;
   WriteFile();
}

int TestFile::GetSwapCode(uint32_t tag)
{
   int swap = 0;
   for(int i=0;i<4;i++)
   {
      switch(tag&0x000000FF)
      {
         case 'g':
            swap += (i+1)*1000;
            break;
         case 'd':
            swap += (i+1)*100;
            break;
         case 'c':
            swap += (i+1)*10;
            break;
         case 'm':
            swap += (i+1);
            break;
         default:
            return 0;
      }
      tag >>= 8;
   }
   return swap;
}

void TestFile::NewData(void)
{
   DeleteData();
   if( GetDataSize() == 0 )
      return;
   data = new uint8_t[GetDataSize()];
}

void TestFile::DeleteData(void)
{
   if( data )
      delete[] data;
   data = NULL;
}

void TestFile::ReadFile(void)
{
   readable=true;
   std::ifstream fp(fileName.c_str(),std::ios::in | std::ios::binary);

   if(!fp)
   {
      readable=false;
      return;
   }

   try
   {
      readable=ReadFileHeader(&fp);
      if(!readable)
      {
         std::cout << "Problems when reading Header part" << std::endl;
         fp.close();
         return;
      }

      readable=ReadFileData(&fp);
      if(!readable)
      {
         std::cout << "Problems when reading datas" << std::endl;
         fp.close();
         return;
      }
   }
   catch(...)
   {
      readable=false;
      fp.close();
      return;
   }

   fp.close();
}

bool TestFile::ReadFileHeader(std::ifstream *fp)
{
   uint32_t tag = ReadInt32(fp);
   swapCode = GetSwapCode(tag);
   if( swapCode == 0 )
   {
      std::cout << "TestFile: Bad tag - Must be 'gdcm'" << std::endl;
      return(false);
   }

   sizeX = ReadInt32(fp); // Size X
   sizeY = ReadInt32(fp); // Size Y
   sizeZ = ReadInt32(fp); // Size Z
   scalarSize = ReadInt16(fp)/8; // bits per scalar
   components = ReadInt16(fp);   // Number of components

   return(true);
}

bool TestFile::ReadFileData(std::ifstream *fp)
{
   DeleteData();

   // Allocate datas
   NewData();
   if( !data )
      return(false);

   // Read datas
   fp->read((char *)data,GetDataSize());

   return(true);
}

void TestFile::WriteFile(void)
{
   std::ofstream fp(fileName.c_str(),std::ios::out | std::ios::binary);

   if(!fp)
   {
      readable=false;
      return;
   }

   WriteFileHeader(&fp);
   WriteFileData(&fp);

   fp.close();
}

bool TestFile::WriteFileHeader(std::ofstream *fp)
{
   WriteInt8(fp,'g'); // Bitmap tag - must be 'g'
   WriteInt8(fp,'d'); // Bitmap tag - must be 'd'
   WriteInt8(fp,'c'); // Bitmap tag - must be 'c'
   WriteInt8(fp,'m'); // Bitmap tag - must be 'm'
   WriteInt32(fp,sizeX); // Size X
   WriteInt32(fp,sizeY); // Size Y
   WriteInt32(fp,sizeZ); // Size Z
   WriteInt16(fp,scalarSize*8); // bits per scalar
   WriteInt16(fp,components);   // number of components

   return(true);
}

bool TestFile::WriteFileData(std::ofstream *fp)
{
   fp->write((char *)data,GetDataSize());

   return(true);
}

uint8_t  TestFile::ReadInt8 (std::ifstream *fp)
#if !(__GNUC__==2  && __GNUC_MINOR__<=96)
   throw( std::ios::failure )
#endif
{
   uint8_t g;
   fp->read ((char*)&g, (size_t)1);
#if !(__GNUC__==2  && __GNUC_MINOR__<=96)
   if ( fp->fail() )
      throw std::ios::failure( "TestFile::ReadInt8() - file error." );
   if( fp->eof() )
      throw std::ios::failure( "TestFile::ReadInt8() - EOF." );
#endif
   return g;
}

uint16_t TestFile::ReadInt16(std::ifstream *fp)
#if !(__GNUC__==2  && __GNUC_MINOR__<=96)
   throw( std::ios::failure )
#endif
{
   uint16_t g;
   fp->read ((char*)&g, (size_t)2);
#if !(__GNUC__==2  && __GNUC_MINOR__<=96)
   if ( fp->fail() )
      throw std::ios::failure( "TestFile::ReadInt16() - file error." );
   if( fp->eof() )
      throw std::ios::failure( "TestFile::ReadInt16() - EOF." );
#endif

#if defined(GDCM_WORDS_BIGENDIAN)
   g = ( g << 8 |  g >> 8  );
#endif
   return g;
}

uint32_t TestFile::ReadInt32(std::ifstream *fp)
#if !(__GNUC__==2  && __GNUC_MINOR__<=96)
   throw( std::ios::failure )
#endif
{
   uint32_t g;
   fp->read ((char*)&g, (size_t)4);
#if !(__GNUC__==2  && __GNUC_MINOR__<=96)
   if ( fp->fail() )
      throw std::ios::failure( "TestFile::ReadInt32() - file error." );
   if( fp->eof() )
      throw std::ios::failure( "TestFile::ReadInt32() - EOF." );
#endif

#if defined(GDCM_WORDS_BIGENDIAN)
   g = (  (g<<24)               | ((g<<8)  & 0x00ff0000) | 
       (  (g>>8)  & 0x0000ff00) |  (g>>24)               );
#endif
   return g;
}

void TestFile::WriteInt8 (std::ofstream *fp,uint8_t value)
{
   fp->write((char*)&value, (size_t)1);
}

void TestFile::WriteInt16(std::ofstream *fp,uint16_t value)
{
#if defined(GDCM_WORDS_BIGENDIAN)
   value = ( value << 8 |  value >> 8  );
#endif
   fp->write((char*)&value, (size_t)2);
}

void TestFile::WriteInt32(std::ofstream *fp,uint32_t value)
{
#if defined(GDCM_WORDS_BIGENDIAN)
   value = (  (value<<24)               | ((value<<8)  & 0x00ff0000) | 
           (  (value>>8)  & 0x0000ff00) |  (value>>24)               );
#endif
   fp->write((char*)&value, (size_t)4);
}

int InternalTest(std::string const &filename, 
                 std::string const &referenceFileName )
{
      std::cout << "   Testing: " << filename << std::endl;
      std::cout << "      ";

      ////// Step 1:
      std::cout << "1...";
      gdcm::FileHelper *tested = new gdcm::FileHelper( filename );
      if( !tested->GetFile()->IsReadable() )
      {
        std::cout << " Failed" << std::endl
                   << "      Image not gdcm compatible:"
                  << filename << std::endl;
        delete tested;
        return 1;
      }

      ////// Step 2:
      ////// Check for existence of reference baseline dicom file:
      std::cout << "2...";

      TestFile *reference = new TestFile();
      std::ifstream refFile(referenceFileName.c_str(),
                            std::ios::binary|std::ios::in);
      if(!refFile)
      {
         std::cout << " Failed" << std::endl
                   << "      Image not found:"
                   << referenceFileName << std::endl;
         reference->SetXSize(tested->GetFile()->GetXSize());
         reference->SetYSize(tested->GetFile()->GetYSize());
         reference->SetZSize(tested->GetFile()->GetZSize());
         reference->SetScalarSize(tested->GetFile()->GetPixelSize());
         reference->SetNumberOfComponents(tested->GetFile()->GetNumberOfScalarComponents());
         reference->SetData(tested->GetImageData());
         reference->Write(referenceFileName);
      }
      else
         refFile.close();

      reference->Load(referenceFileName);
      if(!reference->IsReadable())
      {
        std::cout << " Failed" << std::endl
                   << "      Image not Testing compatible:"
                  << filename << std::endl;
         delete reference;
         delete tested;
         return 1;
      }

      ////// Step 3:
      std::string PixelType = tested->GetFile()->GetPixelType();
      std::cout << "3...";
      int testedDataSize    = tested->GetImageDataSize();
      uint8_t *testedImageData = tested->GetImageData();
    
      int    referenceDataSize = reference->GetDataSize();
      uint8_t *referenceImageData = reference->GetData();

      // Test the image size
      if (tested->GetFile()->GetXSize() != reference->GetXSize() ||
          tested->GetFile()->GetYSize() != reference->GetYSize() ||
          tested->GetFile()->GetZSize() != reference->GetZSize())
      {
         std::cout << "Failed" << std::endl
                   << "        Size differs: "
                   << "X: " << tested->GetFile()->GetXSize() << " # " 
                   << reference->GetXSize() << " | "
                   << "Y: " << tested->GetFile()->GetYSize() << " # " 
                   << reference->GetYSize() << " | "
                   << "Z: " << tested->GetFile()->GetZSize() << " # " 
                   << reference->GetZSize() << std::endl;
         delete reference;
         delete tested;
         return 1;
      }

      // Test the pixel size
      if (tested->GetFile()->GetPixelSize() != reference->GetScalarSize() ||
          tested->GetFile()->GetNumberOfScalarComponents() != reference->GetNumberOfComponents())
      {
         std::cout << "Failed" << std::endl
                   << "        Pixel size differs: " << std::endl
                   << "        Scalar size: " << tested->GetFile()->GetPixelSize() << " # " 
                   << reference->GetScalarSize() << std::endl
                   << "        Number of scalar: " << tested->GetFile()->GetNumberOfScalarComponents() << " # " 
                   << reference->GetNumberOfComponents() << std::endl;
         delete reference;
         delete tested;
         return 1;
      }

      // Test the data size
      if (testedDataSize != referenceDataSize)
      {
         std::cout << " Failed" << std::endl
                   << "        pixel ("
                   << PixelType
                   <<") areas lengths differ: "
                   << testedDataSize << " # " << referenceDataSize
                   << std::endl
                   << "        Image size: ("
                   << tested->GetFile()->GetXSize() << ","
                   << tested->GetFile()->GetYSize() << ","
                   << tested->GetFile()->GetZSize() << ")"
                   << std::endl;
         delete tested;
         delete reference;
         return 1;
      }

      // Test the data content
      if (int res = memcmp(testedImageData, referenceImageData,
                           testedDataSize) != 0 )
      {
         (void)res;
         std::string ts  = tested->GetFile()->GetTransferSyntax();

         std::cout << " Failed" << std::endl
                   << "        pixel (" 
                   << PixelType
                   << ") differ (as expanded in memory)."
                   << std::endl
                   << "        compression : " 
                   << gdcm::Global::GetTS()->GetValue(ts) << std::endl;

         std::cout << "        list of the first " << MAX_NUMBER_OF_DIFFERENCE
                   << " pixels differing (pos : test - ref) :" 
                   << std::endl;
         int i;
         unsigned int j;
         for(i=0, j=0;i<testedDataSize && j<MAX_NUMBER_OF_DIFFERENCE;i++)
         {
            if(testedImageData[i]!=referenceImageData[i])
              {
               std::cout << std::hex << "(" << i << " : " 
                         << std::hex << (int)(testedImageData[i]) << " - "
                         << std::hex << (int)(referenceImageData[i]) << ") "
                         << std::dec;
               ++j;
              }
         }
         std::cout << std::endl;

         delete tested;
         delete reference;
         return 1;
      }

      //////////////// Clean up:
      delete tested;
      delete reference;

      std::cout << "OK." << std::endl;
      
      return 0;
}

int TestAllReadCompareDicom(int argc, char *argv[]) 
{
   if ( argc == 3 )
   {
      // The test is specified a specific filename, use it instead of looping
      // over all images
      const std::string input = argv[1];
      const std::string reference = argv[2];
      return InternalTest( input, reference );
   }
   else if ( argc > 3 || argc == 2 )
   {
      std::cerr << "   Usage: " << argv[0]
                << " (no arguments needed)." << std::endl;
      std::cerr << "or   Usage: " << argv[0]
                << " filename.dcm reference.dcm" << std::endl;
      return 1;
   }
   // else other cases:
   
   std::cout << "   Description (Test::TestAllReadCompareDicom): "
             << std::endl;
   std::cout << "   For all images in gdcmData (and not blacklisted in "
                "Test/CMakeLists.txt)"
             << std::endl;
   std::cout << "   apply the following to each filename.xxx: "
             << std::endl;
   std::cout << "   step 1: parse the image (as gdcmFile) and call"
             << " IsReadable(). "
             << std::endl;
   std::cout << "   step 2: find in GDCM_DATA_ROOT/BaselineDicom/filename.tst"
             << std::endl
             << "           special internal file format containing the"
             << std::endl
             << "           caracteristic of the image and the pixel datas "
             << "(uncompressed). This file is written if it's not found."
             << std::endl;
   std::cout << "   step 3: compare the DICOM image with the reference image"
             << std::endl
             << "           (.tst file). The test is made on the caracteristics"
             << std::endl
             << "           of the image and the pixel datas"
             << std::endl << std::endl;

   int i = 0;
   int result = 0;
   while( gdcmDataImages[i] != 0 )
   {
      ////// Check for existence of reference baseline directory

      std::string baseLineDir = GDCM_DATA_ROOT;
      baseLineDir += "/BaselineDicom";

      if( !gdcm::DirList::IsDirectory(baseLineDir) )
      {
         std::cerr << "   The reference baseline directory " << std::endl
                   << "      "
                   << baseLineDir << std::endl
                   << "   couldn't be opened."
                   << std::endl;
         return 1;
      }

      ////// Step 1 (see above description):
      std::string filename = GDCM_DATA_ROOT;
      filename += "/";
      filename += gdcmDataImages[i];
      
      baseLineDir += '/';
      std::string referenceFileName = baseLineDir + gdcmDataImages[i++];
      std::string::size_type slash_pos = referenceFileName.rfind( "." );
      if( slash_pos != std::string::npos )
      {
         referenceFileName.replace( slash_pos + 1, 3, "tst" );
      }

      if( InternalTest( filename, referenceFileName ) != 0 )
      {
         result++;
      }
   }

   return result;
}