#include <iostream>
#include <iomanip>
#include "TOneEvent.hh"

using std::cout;
using std::endl;
using std::setw;
using std::setprecision;
using std::vector;

ClassImp(TOneEvent)

//__________________________________________________________________________
  TOneEvent::TOneEvent(const char* name, const char* title):
    TStnModule(name,title),lastRun(NULL),fGoodRun(-1),lGoodRun(-1) {}

//__________________________________________________________________________
  TOneEvent::~TOneEvent() {}


//_____________________________________________________________________________
Int_t TOneEvent::BeginJob()
{
  fHeaderBlock = (TStnHeaderBlock*) 
          RegisterDataBlock("HeaderBlock","TStnHeaderBlock");
  return 0;
}

//_____________________________________________________________________________
Int_t TOneEvent::Event(Int_t ientry)
{

  if(fHeaderBlock) fHeaderBlock->GetEntry(ientry);
  else return 1;

  UInt_t r = fHeaderBlock->RunNumber();
  UInt_t e = fHeaderBlock->EventNumber();

  if(lGoodRun>0 && (r<fGoodRun || r>lGoodRun) ) {
    SetPassed(0);
    return 1;
  }

  TOneEventRun* thisRun;
  if(lastRun!=NULL && r==lastRun->run) {
    thisRun = lastRun;
  } else {  // need to look for matching run
    unsigned int ipt = 0;
    while(ipt<runs.size() && runs[ipt].run!=r) ipt++;
    if(ipt>=runs.size()) {   // then this run not in list
      runs.push_back(TOneEventRun(r));
      thisRun = &(runs[runs.size()-1]);
    } else {         // this run found
      thisRun = &(runs[ipt]);
    }
    lastRun = thisRun;
  } // endif same as last run

  unsigned int iept=0;
  TOneEventRun::intVector&  ev = thisRun->events;
  TOneEventRun::byteVector& cv = thisRun->count;
  while(iept<ev.size() && ev[iept]!=e) iept++;
  if(iept>=ev.size()) {
    ev.push_back(e);
    cv.push_back((unsigned char) 1);
    SetPassed(1);
  } else {
    cv[iept]++;
    SetPassed(0);
  }

  return 0;
}

//_____________________________________________________________________________
void TOneEvent::PrintSummary(Int_t level)
{
  if(level<=0) return;

  if(fGoodRun>0) {
    cout << "Removed all runs not in ["
	 <<fGoodRun<<","<<lGoodRun<<"] inclusive" << endl;
  } else {
    cout <<"No good run list used" << endl;
  }

  int totalEvents = 0;
  int totalDups = 0;
  int runsWithDups = 0;

  for(unsigned int irun=0; irun<runs.size(); irun++) {
    TOneEventRun run = runs[irun];
    TOneEventRun::intVector&  ev = run.events;
    TOneEventRun::byteVector& cv = run.count;
    int evtsThisRun=0;
    int dupsThisRun=0;
    bool dupFlag = false;
    for(unsigned int iev=0; iev<ev.size(); iev++) {
      if(level>=3) {
	cout << setw(7) << run.run << " " << setw(8) << ev[iev] 
	     << setw(6) << int(cv[iev]) << endl;
      }
      totalDups +=  cv[iev]-1;
      dupsThisRun +=  cv[iev]-1;
      evtsThisRun +=  cv[iev];
      totalEvents +=  cv[iev];
      if(cv[iev]>1) dupFlag = true;
    }
    if(dupFlag) runsWithDups++;

    if(level>=2) {
      cout << "Run: " << setw(6) << run.run 
	   << "   events:" << setw(7) << evtsThisRun 
	   << "   unique:" << setw(7) << evtsThisRun-dupsThisRun 
	   << "   repeated (%):" << setw(7) << dupsThisRun 
	   << "   (" << setw(6) << setprecision(4)
	              << 100.0*float(dupsThisRun)/float(evtsThisRun)
	   << ")" << endl;
    }
  }

  if(level>=1) {
    cout << "Runs " << runs.size() << endl;
    cout << "Runs with repeats " << runsWithDups << endl;
    cout << "Events     " << setw(7) <<totalEvents << endl;
    cout << "Unique     " << setw(7) <<totalEvents - totalDups << endl;
    cout << "Repeated   " << setw(7) <<totalDups << endl;
    cout << "% repeated " << setw(7) << setprecision(4) 
	 << 100.0*float(totalDups)/float(totalEvents) << endl;
  }

  return;
}