//  $Id: BrGeantData.cxx,v 1.3 1998/04/06 21:12:11 videbaek Exp $
//  $Log: BrGeantData.cxx,v $
//  Revision 1.3  1998/04/06 21:12:11  videbaek
//  Clean up and additions for Win95
//
//  Revision 1.2  1998/03/06 22:10:01  videbaek
//  Working update
//
//  Revision 1.1.1.1  1998/03/04 21:33:10  brahmlib
//  Brat geant
//
//
#include <stdlib.h>
#include <math.h>
#ifdef UNIX
#include <unistd.h>
#endif

// #include "BratDefines.h"
#include "BrGeantData.h"
#include "BrDataTable.h"
#include "BrGeantHit.h"
#include "BrGeantTrack.h"
#include "BrEvent.h"
#include <iostream.h>


ClassImp(BrGeantData)

const int END_OF_STREAM_EVENT = -1;
const int EVENT_STREAM_HEADER = 1;
const int EVENT_STREAM_HIT = 2;
const int EVENT_STREAM_TRACK =  3;


//#define _BRDEBUG

////////////////////////////////////////////////////////////////
//                                                            //
// BrGeantData provides an interface to GBRAHMS output       //
//                                                            //
////////////////////////////////////////////////////////////////

  BrGeantData::BrGeantData()
{
//  Constructor. Set fFilePointer and fEventCounter to NULL
#ifdef _BRDEBUG
  cout << "Ctor : BrGeantData " << endl;
#endif
    fFilePointer  = NULL;
    fEventCounter = 0;
    rHeader = kFALSE;
    
}

  BrGeantData::BrGeantData(Char_t *filename)
{
  // Constructor. Set fFilePointer and fEventCounter to NULL
  // and open the file pointed to by *filename. Open also
  // reads the file header.
  // This is a problem. A constructor cannot return a type and thus not
  // assign any reasonable value.
  // 

    fFilePointer  = NULL;
    fEventCounter = 0;
    rHeader = kFALSE;
    Open(filename);
}

  Bool_t BrGeantData::Open(Char_t *fname)
{
// Open the ASCII data file *fname. Returns kFALSE
// if the file can't be opened.
// Otherwise the fFileName data member is set to the 
// corresponding filepointer. The file header is read

    if(!fname)
    {
        printf("Can't open file NULLn");
        return kFALSE;
    }

#ifdef _BRDEBUG
    cout << "Opening File "<< fname << endl;
#endif
    sprintf(fFileName,"%s",fname);
    fFilePointer = new ifstream();
    if(!fFilePointer) {
       printf("Can't create fFilePointer object %s\n",fFileName);
       return kFALSE;
       }
    fFilePointer->open(fFileName,ios::binary|ios::in);
    if(fFilePointer->fail()) {
      printf("Can't open File %s\n",fFileName);
      delete fFilePointer;
      fFilePointer = NULL;
      return kFALSE;
    }
    else {
      return ReadStreamHeader();
    }
}

  Bool_t BrGeantData::Close()
{
// Close the file pointed to by fFilePointer. Returns 
// kFALSE if no file was open.

    if(fFilePointer)
    {
        fFilePointer->close();
	delete fFilePointer;
        fFilePointer = NULL;
        return kTRUE;
    }
    else
    {
        return kFALSE;
    }
}

 Bool_t BrGeantData::ReadStreamHeader()
{
  Int_t i, ivol;
  Int_t nb = 4;
  
  Char_t*  VolumeName;
  
  
  Char_t * numvol = (Char_t *) (&fNumberOfVolumes);

  fFilePointer->read(numvol,nb);
#ifdef _BRDEBUG
    int ik= fFilePointer->eof();
    cout << ik << " " << fNumberOfVolumes << endl;
#endif
  if(fNumberOfVolumes > MAXGVOLU){
    cout << "Try to convert file first " << endl;
    return kFALSE;
  };

  for(ivol=0; ivol<fNumberOfVolumes; ivol++) {
    Char_t *bufp = (Char_t*) (&fVolume[ivol]);
    int vsize = sizeof(GeantVolume);

    fFilePointer->read(bufp, vsize);
#ifdef _BRDEBUG
    int ik= fFilePointer->eof();
    cout << "Reading volume #"<< ivol << " " << ik << endl;
#endif

    VolumeName = fVolume[ivol].Name;
    VolumeName[sizeof(fVolume[ivol].Name)] = 0;
    //   VolumeName[sizeof(fVolume[ivol].Name)] = 0;
    //need to do this because fortran(geant?) pads with blank (32)
    for(i=0;i<sizeof(fVolume[ivol].Name);i++) {
      if(fVolume[ivol].Name[i] == 32) fVolume[ivol].Name[i] = 0;
    }

  }
SetrHeader( kTRUE );
return kTRUE;
}

 BrEvent* BrGeantData::GetNextEvent()
{
// Reads one event from the stream i/o data file. A BrEvent 
// object is created and the hitlist and tracklist for 
// this object is filled with data read from the file. 
// 
// Releasing the memory for this event is the responsibility
// of the function/macro calling GetNextEvent()
// The memory
// is completely released by a call to the BrEvent destructor
// (e.g. delete event;)

  Int_t      rectyp=0,nb,ivol;
  Char_t*    bufp;
  Int_t      EventHeader[2];

  Char_t     name[64];
  
  GeantStreamHits fHits;
  GeantStreamTracks fTracks;
  
  BrDataTable *HitBuffer[20];
#ifdef _BRDEBUG  
  printf("Create new event\n");
  cout << "Number of Volumes " << fNumberOfVolumes << endl;
#endif  
  BrEvent *event = new BrEvent("Geant",0,0);
  //
  // Create new data container for Geant Tracks and
  // Geant Hits (for each of the possible volumes
  //
  BrDataTable *TrackBuffer = new BrDataTable("GeantTracks");
  for(ivol=0;ivol<fNumberOfVolumes;ivol++) {
    if(fVolume[ivol].Active == 1 ){
      sprintf(name,"GeantHits %sx0",fVolume[ivol].Name);
#ifdef _BRDEBUG
      cout << " Adding Object " << name << endl;
#endif
      HitBuffer[ivol] = new BrDataTable(name);
      event->AddObject(HitBuffer[ivol]);
    }
  }
  
  event->AddObject(TrackBuffer);
  event->GetEventHeader()->SetRunNumber(0);
  event->GetEventHeader()->SetEventNumber(fEventCounter);
  
  while(rectyp != END_OF_STREAM_EVENT) {
    nb = 4;
    bufp = (char*) &rectyp;
    fFilePointer->read(bufp, nb);
    int ik = fFilePointer->eof();
#ifdef _BRDEBUG
    cout << ik << endl;
#endif
    if(fFilePointer->eof()) {
      cout<<"End of STREAM file found: closing file"<<endl;
      delete event;		//clean up since not returning it
      fFilePointer->close();
      fFilePointer = NULL;
      return NULL;
    }
    if(fFilePointer->bad()) cout << "Unexpected Bad file\n";

    switch (rectyp) {
    case END_OF_STREAM_EVENT:
      break;
    case  EVENT_STREAM_HEADER:
      nb = sizeof(EventHeader);
      bufp = (char*) EventHeader;
      fFilePointer->read(bufp,nb);
      break;
    case  EVENT_STREAM_TRACK:
      nb = sizeof(GeantStreamTracks);
      bufp = (char*) &fTracks;
      fFilePointer->read(bufp,nb);
      if(fFilePointer->bad()) cout<<"1Bad status"<<endl;
      if(fFilePointer->eof()) cout<<"1EOF status"<<endl;
      if(fFilePointer->fail()) cout<<"1Fail status"<<endl;
      TrackBuffer->Add(new BrGeantTrack(fTracks));
      break;
    case  EVENT_STREAM_HIT:
      nb = sizeof(GeantStreamHits);
      bufp = (char*) & fHits;
      fFilePointer->read(bufp,nb);
      if(fFilePointer->bad()) cout<<"Bad status"<<endl;
      if(fFilePointer->eof()) cout<<"EOF status"<<endl;
      if(fFilePointer->fail()) cout<<"Fail status"<<endl;
      ivol = fHits.DetectorId - 1; //-1 needed because indices start at 0
      if( fHits.dedx > 0 ) {
	HitBuffer[ivol]->Add(new BrGeantHit(fHits));
      }
      else {
	int ijk = 0;//for debugger
      }
      break;
    default:
      //          This should not happen!!!
      cout<<"*** Problem in data:" << endl;
      cout << "rectype in stream file is " << rectyp<< endl;
      break;
    }
  }
  
  sprintf(name,"event_%d_%d",event->GetRunNumber(),event->GetEventNumber());
  event->SetName(name);
  sprintf(name,"BRAHMS  Event %d %d",event->GetRunNumber(),event->GetEventNumber());
  event->SetTitle(name);
//  printf("Event %d has %d tracks n",
//	 event->EventNumber(),
//	 TrackBuffer->GetEntries());

  fEventCounter++;
  return event;
}