///////////////////////////////////////////////////////////////////////////////
//
//
//
///////////////////////////////////////////////////////////////////////////////
#include "TBrowser.h"
#include "RootMods/TModule.hh"
#include "Stntuple/mod/StntupleCut.hh"
#include "Stntuple/mod/StntupleFilter.hh"


ClassImp(StntupleFilter)


//_____________________________________________________________________________
void StntupleFilter::ReadV1(TBuffer &R__b) {
  // read version 1 of StntupleFilter: 
  // in that V1 we had list of object-level cuts and only one event-level cut

  TObject::Streamer(R__b);
  fName.Streamer(R__b);
  R__b >> fNInput;
  R__b >> fNPassed;
  R__b >> fListOfObjectCuts;
//-----------------------------------------------------------------------------
//  read "old good" cut and store in into array of event cuts
//-----------------------------------------------------------------------------
  if (NEventCuts() == 0) {
    fListOfEventCuts->Add(new StntupleCut());
  }
  StntupleCut* cut = (StntupleCut*) fListOfEventCuts->At(0);

  R__b >> cut;
}





//______________________________________________________________________________
void StntupleFilter::Streamer(TBuffer &R__b)
{
   // Stream an object of class StntupleFilter.

  UInt_t R__s, R__c;
  if (R__b.IsReading()) {
    Version_t R__v = R__b.ReadVersion(&R__s, &R__c); 
    if (R__v == 1) { 
      ReadV1(R__b);
    }
    else if (R__v == 2) {
      TObject::Streamer(R__b);
      fName.Streamer(R__b);
      R__b >> fNInput;
      R__b >> fNPassed;
      R__b >> fListOfObjectCuts;
      R__b >> fListOfEventCuts;
    }
    R__b.CheckByteCount(R__s, R__c, StntupleFilter::IsA());
  } 
  else {
    R__c = R__b.WriteVersion(StntupleFilter::IsA(), kTRUE);
    TObject::Streamer(R__b);
    fName.Streamer(R__b);
    R__b << fNInput;
    R__b << fNPassed;
    R__b << fListOfObjectCuts;
    R__b << fListOfEventCuts;
    R__b.SetByteCount(R__c, kTRUE);
  }
}

//_____________________________________________________________________________
StntupleFilter::StntupleFilter() {
  fListOfObjectCuts      = new TObjArray(10);
  fListOfObjectCuts->SetName("ObjectCuts");

  fListOfEventCuts = new TObjArray(10);
  fListOfEventCuts->SetName("EventCuts");

  fModule     = NULL;
  fPar        = 0;
  fPrintLevel = 0;
}

//_____________________________________________________________________________
StntupleFilter::StntupleFilter (const char*   Name, 
				TModule*      Module,
				bool          (*Fun)(TModule*, AbsEvent*)):
  fName(Name),
  fModule(Module),
  fPassed(0),
  fNInput(0),
  fNPassed(0),
  fFun(Fun)
{
  fListOfObjectCuts = new TObjArray(10);
  fListOfObjectCuts->SetName("ObjectCuts");

  fListOfEventCuts = new TObjArray(10);
  fListOfEventCuts->SetName("EventCuts");
  fPar             = 0;
  fPrintLevel      = 0;
}

//_____________________________________________________________________________
StntupleFilter::~StntupleFilter() {
  //

  if (fPar) delete [] fPar;
  fListOfObjectCuts->Delete();
  delete fListOfObjectCuts;

  fListOfEventCuts->Delete();
  delete fListOfEventCuts;
}

//_____________________________________________________________________________
Int_t StntupleFilter::Command(const char* CutName, Int_t Argc, char** Argv) {
  // this has to search both event and object level cuts...

  StntupleCut* cut = this->Cut(CutName);

  if (! cut) {
    Error("Command","cut %s not defined",CutName);
    return -1;
  }
  
  double pmin, pmax, nx, xmin, xmax;

  cut->GetParameters(pmin,pmax,nx,xmin,xmax);

  for (int i=2; i<Argc; i++) {
    if (i == 2) {
      pmin = atof(Argv[i]);
    }
    else if (i == 3) {
      pmax = atof(Argv[i]);
    }
    else if (i == 4) {
      nx = atoi(Argv[i]);
    }
    else if (i == 5) {
      xmin = atof(Argv[i]);
    }
    else if (i == 6) {
      xmax = atof(Argv[i]);
    }
    else {
      Error("Command"," too many parameters");
      return -1;
    }
  }

  cut->SetParameters(pmin,pmax,nx,xmin,xmax);
  return 0;
}

//_____________________________________________________________________________
Int_t StntupleFilter::ProcessEvent(AbsEvent* Event) {
  fNInput++;
  fPassed = fFun(fModule,Event);
  if (fPassed) fNPassed++;
  return fPassed;
}


//_____________________________________________________________________________
Int_t StntupleFilter::Init(TStnEvent* Event) {
  return 0;
}

//_____________________________________________________________________________
Int_t StntupleFilter::ApplyObjectCuts() {
  // apply cuts of a given type: 0=object type, 1=event type

  int rc = 1;

  int nc = NObjectCuts();
  for (int i=0; i<nc; i++) {
    StntupleCut* cut = ObjectCut(i);
    if (! cut->Passed(fPar)) {
      rc = 0;
      break;
    }
  }
  return rc;
}

//_____________________________________________________________________________
Int_t StntupleFilter::ApplyEventCuts() {
  // apply cuts of a given type: 0=object type, 1=event type

  int rc = 1;
  StntupleCut* cut;
  
  int nc = NEventCuts();
  for (int i=0; i<nc; i++) {
    cut = EventCut(i);
    if (! cut->Passed(fPar)) {
      rc = 0;
      break;
    }
  }
  return rc;
}

//______________________________________________________________________________
void StntupleFilter::Browse(TBrowser* b)
{
  if (fListOfObjectCuts) fListOfObjectCuts->Browse(b);
  if (fListOfEventCuts ) fListOfEventCuts->Browse(b);
}

//______________________________________________________________________________
void StntupleFilter::Clear(const char* Opt) {
}


//______________________________________________________________________________
void StntupleFilter::Print(const char* Opt) const {

  StntupleCut* cut;
  StntupleFilter* fil = (StntupleFilter*) this;
//-----------------------------------------------------------------------------
// first print object-level cuts
//-----------------------------------------------------------------------------
  int nc = NObjectCuts();
  for (int i=0; i<nc; i++) {
    cut = fil->ObjectCut(i);
    if (i == 0) cut->Print("banner+data");
    else        cut->Print("data");
  }
//-----------------------------------------------------------------------------
// then - event-level cuts
//-----------------------------------------------------------------------------
  nc = NEventCuts();
  for (int i=0; i<nc; i++) {
    cut = fil->EventCut(i);
    if (i == 0) cut->Print("banner+data");
    else        cut->Print("data");
  }
}


//_____________________________________________________________________________
StntupleCut* StntupleFilter::ObjectCut(const char* Name) {
  StntupleCut* cut = (StntupleCut*) fListOfObjectCuts->FindObject(Name);
  return cut;
}


//_____________________________________________________________________________
StntupleCut* StntupleFilter::EventCut(const char* Name) {
  StntupleCut* cut = (StntupleCut*) fListOfEventCuts->FindObject(Name);
  return cut;
}

//_____________________________________________________________________________
StntupleCut* StntupleFilter::Cut(const char* Name) {
  // looks for event cut first, object cut next

  StntupleCut* cut;

  cut = (StntupleCut*) fListOfEventCuts->FindObject(Name);
  if (! cut) {
    cut = (StntupleCut*) fListOfObjectCuts->FindObject(Name);
  }
  return cut;
}