//
// Class AliMixEventInputHandler
//
// Mixing input handler prepare N events before UserExec
// TODO example
// author: 
//        Martin Vala (martin.vala@cern.ch)
//

#include <TFile.h>
#include <TChain.h>
#include <TEntryList.h>
#include "AliLog.h"
#include "AliMixEventPool.h"
#include "AliMixEventInputHandler.h"
#include "AliAnalysisManager.h"

#include "AliMixInputHandlerInfo.h"
#include <TChainElement.h>

ClassImp(AliMixEventInputHandler)

//_____________________________________________________________________________
AliMixEventInputHandler::AliMixEventInputHandler(const Int_t size) :
    AliInputEventHandler(),
    fBufferSize(size),
    fInputHandlers(),
    fMixTrees(),
    fTreeMap(size),
    fMixIntupHandlerInfoTmp(0),
    fEntryCounter(0),
    fEventPool(0),
    fMixEventNumber(0) {
//
// Default constructor.
//
  AliDebug(AliLog::kDebug + 10, "<-");
  AliDebug(AliLog::kDebug + 10, "->");
}

//_____________________________________________________________________________
AliInputEventHandler* AliMixEventInputHandler::InputEventHandler(const Int_t index) {
  //
  // Returns input handler
  //
  AliDebug(AliLog::kDebug, Form("<-"));
  if ((index >= 0) && (index < fBufferSize)) {
    AliDebug(AliLog::kDebug, Form("->"));
    return (AliInputEventHandler*) fInputHandlers.At(index);
  }
  AliDebug(AliLog::kDebug, Form("->"));
  return 0;
}
//_____________________________________________________________________________
void AliMixEventInputHandler::SetInputHandlerForMixing(const AliInputEventHandler*const inHandler) {
  //
  // Create N (fBufferSize) copies of input handler
  //
  AliDebug(AliLog::kDebug, Form("<-"));
  AliDebug(AliLog::kDebug, Form("Creating %d input event handlers ...", fBufferSize));
  for (Int_t i = 0;i < fBufferSize;i++) {
    AliDebug(AliLog::kDebug + 5, Form("Adding %d ...", i));
    fInputHandlers.Add((AliInputEventHandler*) inHandler->Clone());
  }
  AliDebug(AliLog::kDebug, Form("->"));
}
//_____________________________________________________________________________
Bool_t AliMixEventInputHandler::Init(Option_t*opt) {
  //
  // Init() is called for all mix input handlers.
  //
  AliDebug(AliLog::kDebug, Form("<- \"%s\"", opt));
  AliInputEventHandler *eh = 0;
  TObjArrayIter next(&fInputHandlers);
  while ((eh = (AliInputEventHandler *) next())) {
    eh->Init(opt);
  }
  AliDebug(AliLog::kDebug, Form("->"));
  return kTRUE;
}
//_____________________________________________________________________________
Bool_t AliMixEventInputHandler::Init(TTree* tree, Option_t*) {
  //
  // Init(const char*path) is called for all mix input handlers.
  // Create event pool if needed
  //
  AliDebug(AliLog::kDebug, Form("<- %p", tree));
  if (!tree) {
    AliDebug(AliLog::kDebug, Form("->"));
    return kFALSE;
  }
  AliDebug(AliLog::kDebug, Form("%s", tree->GetCurrentFile()->GetName()));

  // clears array of input handlers
  fMixTrees.SetOwner(kTRUE);
  fMixTrees.Clear();

  // create AliMixInputHandlerInfo
  if (!fMixIntupHandlerInfoTmp) fMixIntupHandlerInfoTmp = new AliMixInputHandlerInfo(tree->GetName());

  // adds current file
  fMixIntupHandlerInfoTmp->AddTreeToChain(tree);
  Int_t lastIndex = fMixIntupHandlerInfoTmp->GetChain()->GetListOfFiles()->GetEntries();
  TChainElement *che = (TChainElement *)fMixIntupHandlerInfoTmp->GetChain()->GetListOfFiles()->At(lastIndex - 1);
  AliMixInputHandlerInfo *mixIHI = 0;
  for (Int_t i = 0;i < fInputHandlers.GetEntries();i++) {

    AliDebug(AliLog::kDebug, Form("fInputHandlers[%d]", i));
    mixIHI = new AliMixInputHandlerInfo(fMixIntupHandlerInfoTmp->GetName(), fMixIntupHandlerInfoTmp->GetTitle());
    mixIHI->PrepareEntry(che, -1, InputEventHandler(i));
    AliDebug(AliLog::kDebug, Form("chain[%d]->GetEntries() = %lld", i, mixIHI->GetChain()->GetEntries()));
    fMixTrees.Add(mixIHI);
  }
  AliDebug(AliLog::kDebug, Form("fEntryCounter=%lld", fEntryCounter));

  if (fEventPool->NeedInit())
    fEventPool->Init();

  AliDebug(AliLog::kDebug, Form("->"));
  return kTRUE;
}
//_____________________________________________________________________________
Bool_t AliMixEventInputHandler::Notify() {
  //
  // Notify() is called for all mix input handlers
  //
  AliDebug(AliLog::kDebug, Form("<-"));
  AliInputEventHandler *eh = 0;
  TObjArrayIter next(&fInputHandlers);
  while ((eh = (AliInputEventHandler *) next())) {
    eh->Notify();
  }
  AliDebug(AliLog::kDebug, Form("->"));
  return kTRUE;
}

//_____________________________________________________________________________
Bool_t AliMixEventInputHandler::Notify(const char*path) {
  //
  // Notify(const char*path) is called for all mix input handlers
  //
  AliDebug(AliLog::kDebug, Form("<- %s", path));
  AliInputEventHandler *eh = 0;
  TObjArrayIter next(&fInputHandlers);
  while ((eh = (AliInputEventHandler *) next())) {
    eh->Notify(path);
  }
  AliDebug(AliLog::kDebug, Form("->"));
  return kTRUE;
}
//_____________________________________________________________________________
Bool_t AliMixEventInputHandler::BeginEvent(Long64_t entry) {
  //
  // BeginEvent(Long64_t entry) is called for all mix input handlers
  //
  
  AliDebug(AliLog::kDebug, Form("-> %lld", entry));
  AliInputEventHandler *eh = 0;
  TObjArrayIter next(&fInputHandlers);
  while ((eh = (AliInputEventHandler *) next())) {
    eh->BeginEvent(entry);
  }
  AliDebug(AliLog::kDebug, Form("->"));
  return kTRUE;
}


//_____________________________________________________________________________
Bool_t AliMixEventInputHandler::GetEntry() {
  //
  // Sets correct events to every mix events
  //
  AliDebug(AliLog::kDebug, Form("<-"));

  AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
  AliInputEventHandler *inEvHMain = dynamic_cast<AliInputEventHandler *>(mgr->GetInputEventHandler());

  Long64_t zeroChainEntries = fMixIntupHandlerInfoTmp->GetChain()->GetEntries() - inEvHMain->GetTree()->GetEntries();
  
  // if fEntryCounter is 0 just add entry
  if (!fEntryCounter) {
    if (inEvHMain) {

      fEventPool->AddEntry(inEvHMain->GetTree()->GetReadEntry() + zeroChainEntries, inEvHMain->GetEvent());
    }
    return kTRUE;
  }

  AliDebug(AliLog::kDebug, Form("++++++++++++++ BEGIN SETUP EVENT %lld +++++++++++++++++++", fEntryCounter));

  fMixEventNumber = 0;
  TEntryList *el = fEventPool->FindEntryList(inEvHMain->GetEvent());
  Long64_t elNum = 0;
  if (el)
    elNum = el->GetN();
  else
    AliDebug(AliLog::kDebug, "el is null");

  AliInputEventHandler *eh = 0;
  AliMixInputHandlerInfo *mihi = 0;
  TObjArrayIter next(&fInputHandlers);
  Int_t counter = 0;
  Long64_t entryMix = 0;
  while ((eh = (AliInputEventHandler *) next())) {
    if (fEventPool->GetListOfEventCuts()->GetEntries() > 0) {
      entryMix = -1;
      if (el && el->GetN() >= fBufferSize) {
        Long64_t entryInEntryList =  elNum - 1 - counter;
        if (entryInEntryList < 0) break;
        entryMix = el->GetEntry(entryInEntryList);
      }
    } else {
      entryMix = fEntryCounter - 1 - counter ;
    }

    AliDebug(AliLog::kDebug, Form("Handler[%d] entryMix %lld ", counter, entryMix));
    if (entryMix < 0) break;

    mihi = (AliMixInputHandlerInfo*) fMixTrees.At(counter);
    TChainElement *te = fMixIntupHandlerInfoTmp->GetEntryInTree(entryMix);
    mihi->PrepareEntry(te, entryMix, InputEventHandler(counter));
    fMixEventNumber++;
    counter++;
  }

  if (inEvHMain) {
    fEventPool->AddEntry(inEvHMain->GetTree()->GetReadEntry() + zeroChainEntries, inEvHMain->GetEvent());
  }

  AliDebug(AliLog::kDebug, Form("fEntryCounter=%lld fMixEventNumber=%d", fEntryCounter, fMixEventNumber));
  AliDebug(AliLog::kDebug, Form("++++++++++++++ END SETUP EVENT %lld +++++++++++++++++++", fEntryCounter));
  AliDebug(AliLog::kDebug, Form("->"));
  return kTRUE;
}
//_____________________________________________________________________________
Bool_t AliMixEventInputHandler::FinishEvent() {
  //
  // FinishEvent() is called for all mix input handlers
  //
  AliDebug(AliLog::kDebug, Form("<-"));
  AliInputEventHandler *eh = 0;
  TObjArrayIter next(&fInputHandlers);
  while ((eh = (AliInputEventHandler *) next())) {
    eh->FinishEvent();
  }
  fEntryCounter++;
  AliDebug(AliLog::kDebug, Form("->"));
  return kTRUE;
}