// ----------------------------------------------------------------------------
// $Id: LCDreadSIOFile.cxx,v 1.1 2001/05/10 22:06:37 toshi Exp $
// ----------------------------------------------------------------------------
//
// $Log: LCDreadSIOFile.cxx,v $
// Revision 1.1  2001/05/10 22:06:37  toshi
// File IO (stdHEP, SIO,...) utilities.
//
//
#include "LCDreadSIOFile.h"

#include <iostream.h>

// ----------------------------------------------------------------------------
// CVS $Id: LCDreadSIOFile.cxx,v 1.1 2001/05/10 22:06:37 toshi Exp $
// ----------------------------------------------------------------------------
//
// General Description:
//
// ----------------------------------------------------------------------------

#ifdef _MSC_VER
#   pragma warning(disable:4786)        // >255 characters in debug information
#endif

ClassImp(LCDreadSIOFile)

// ----------------------------------------------------------------------------
 LCDreadSIOFile::LCDreadSIOFile() {
  Init();
}
// ----------------------------------------------------------------------------

// ----------------------------------------------------------------------------
 LCDreadSIOFile::LCDreadSIOFile(Char_t* siofilename, LCDEvent* event) {
  Init();
  if (event == 0) {
    m_event = new LCDEvent();
    m_ownevent=kTRUE;
  } else {
    m_event = event;
    m_ownevent=kFALSE;
  }
  SetSIOFileName(siofilename);
}
// ----------------------------------------------------------------------------

// ----------------------------------------------------------------------------
 LCDreadSIOFile::~LCDreadSIOFile() {
  if (m_ownevent) {
    m_event->Delete();
    delete m_event;
  }
}
// ----------------------------------------------------------------------------

// ----------------------------------------------------------------------------
 void LCDreadSIOFile::SetSIOFileName(Char_t* siofilename) {
  i_file=siofilename;
  InitSIO();
}
// ----------------------------------------------------------------------------

// ----------------------------------------------------------------------------
//
// Put thes in global scope so the block readers can use them.
//
// ----------------------------------------------------------------------------
 void LCDreadSIOFile::Init() {
  m_ownevent=kFALSE;
  ParticleList = new TMap( 17, 0 );
  stream = NULL;
    
  recred = NULL;
  header = NULL;
  record = NULL;
    
  //bufsize = 64000;
  //comp    = 1;
  //split   = 1;
    
  status  = 0;
    
  i_file  = 0;

  det_ID=0;
  det_CVS=0;

  f_debug=0;
}
// ----------------------------------------------------------------------------

// ----------------------------------------------------------------------------
// Deal with SIO
// ----------------------------------------------------------------------------
 Int_t LCDreadSIOFile::InitSIO() {
  //
  // Look at SIO errors
  //
  //SIO_streamManager::setVerbosity( SIO_ALL );
  //SIO_recordManager::setVerbosity( SIO_ALL );
  //SIO_blockManager::setVerbosity(  SIO_ALL );
  SIO_streamManager::setVerbosity( SIO_ERRORS );
  SIO_recordManager::setVerbosity( SIO_ERRORS );
  SIO_blockManager::setVerbosity(  SIO_ERRORS );
  
  //
  // Make header I/O blocks.
  //
  det_ID  = new LCD_detector_ID(   "LCD_detector_ID"   );
  det_CVS = new LCD_detector_CVS(  "LCD_detector_CVS"  );

  SIO_blockManager::add(det_ID);
  SIO_blockManager::add(det_CVS);

  //
  // Make I/O blocks.
  //
  EMCalorimeter = 
    new S2R_EMCalorimeter( "EMCalorimeter" ,&m_event,&ParticleList);
  HADCalorimeter= 
    new S2R_HADCalorimeter("HADCalorimeter",&m_event,&ParticleList);
  LUMCalorimeter= 
    new S2R_LUMCalorimeter("LUMCalorimeter",&m_event,&ParticleList);
  MUCalorimeter = 
    new S2R_MUCalorimeter( "MUCalorimeter" ,&m_event,&ParticleList);
  Tracker       = 
    new S2R_Tracker(       "Tracker"       ,&m_event,&ParticleList);
  VXD           = 
    new S2R_VXD(           "VXD"           ,&m_event,&ParticleList);
  MCPrint       = 
    new S2R_MCPrint(       "MCPrint"       ,&m_event,&ParticleList);
  EventMarker   = 
    new S2R_EventMarker(   "EventMarker"   ,&m_event,&ParticleList);

  SIO_blockManager::add(  EMCalorimeter );
  SIO_blockManager::add( HADCalorimeter );
  SIO_blockManager::add( LUMCalorimeter );
  SIO_blockManager::add(  MUCalorimeter );
  SIO_blockManager::add( Tracker        );
  SIO_blockManager::add( VXD            );
  SIO_blockManager::add( MCPrint        );
  SIO_blockManager::add( EventMarker    );

  //
  // Add an input stream and open the input file on it.
  //
  stream = SIO_streamManager::add( "input" );
  if( !stream )
    return( 1 );

  if( !( (status = stream->open( i_file, SIO_MODE_READ )) & 1 ) )
    return( 1 );

  //
  // Set up to interpret records of type "LCD_Gismo_Detector".
  //
  header = SIO_recordManager::add( "LCD_Gismo_Detector" );
  if( !header )
    return( 1 );

  header->setUnpack( true );

  //
  // Set up to interpret records of type "LCD_Gismo_Event".
  //
  record = SIO_recordManager::add( "LCD_Gismo_Event" );
  if( !record )
    return( 1 );

  record->setUnpack( true );

  return( 0 );
}

// ----------------------------------------------------------------------------
// Do the conversion
// ----------------------------------------------------------------------------
 Int_t LCDreadSIOFile::GetEvent(LCDEvent* event) {
  LCDEvent* event_save=m_event;
  if (event) {
    m_event=event;
  }

  m_event->Clean();

  if (f_debug > 0)
    cout<<"LCDreadSIOFile::GetEvent event->Clean()...";
  m_event->Clean();
  if (f_debug > 0)
    cout<<"done"<<endl;


  if (f_debug > 0)
    cout<<"LCDreadSIOFile::GetEvent stream->read...start"<<endl;;
  status = stream->read( &recred );
  if (f_debug > 0)
    cout<<"LCDreadSIOFile::GetEvent stream->read...done status="<<status<<endl;
  if( !(status & 1) ) {
    if( status != SIO_STREAM_EOF ) {
      printf("------------------------------------------------------n");
      printf("Error reading SIO recordn" );
      printf("------------------------------------------------------n");
    }
    m_event=event_save;
    return 0;
  }

  if( recred == header ) {
    printf("n");
    printf("LCD Gismo Header Record Read                              n");
    printf("----------------------------------------------------------n");
    printf("Detector ID    type: %sn",    det_ID->getType()             );
    printf("              major: %dn",    det_ID->getMajor()            );
    printf("              minor: %dn",    det_ID->getMinor()            );
    printf("n");
    printf("Detector CVS header: %sn",    det_CVS->getHeader()          );
    printf("                CRC: 0x%8xn", det_CVS->getCRC()             );
    printf("n");
    printf("----------------------------------------------------------n");

    if (f_debug > 0)
      cout<<"LCDreadSIOFile::GetEvent stream->read...";
    status = stream->read( &recred );
    if (f_debug > 0)
      cout<<"done status="<<status<<endl;

    if( !(status & 1) ) {
      if( status != SIO_STREAM_EOF ) {
	printf("--------------------------------------------------n");
	printf("Error reading SIO recordn" );
	printf("--------------------------------------------------n");
      }
      m_event=event_save;
      return 0;
    }

    if( recred != record ) {
      printf("------------------------------------------------------n");
      printf("Error reading SIO record ... expected event recordn" );
      printf("------------------------------------------------------n");
      m_event=event_save;
      return 0;
    }
  }

  //event->Clean();
  ParticleList->Delete();

  if (event) {
    m_event=event_save;
  }
  return 1;
}

// ----------------------------------------------------------------------------
// SetDebugLevel
// ----------------------------------------------------------------------------
 void LCDreadSIOFile::SetDebugLevel(Int_t a) {
  f_debug=a;
  if ( EMCalorimeter)  EMCalorimeter->SetDebugLevel(a);
  if (HADCalorimeter) HADCalorimeter->SetDebugLevel(a);
  if (LUMCalorimeter) LUMCalorimeter->SetDebugLevel(a);
  if ( MUCalorimeter)  MUCalorimeter->SetDebugLevel(a);
  if (       Tracker)        Tracker->SetDebugLevel(a);
  if (           VXD)            VXD->SetDebugLevel(a);
  if (       MCPrint)        MCPrint->SetDebugLevel(a);
  if (   EventMarker)    EventMarker->SetDebugLevel(a);
}