/*!
  \brief   Implementation of TATOFaction.
*/

#include "TH1.h"
#include "TATOFroot.h"
#include "TATOFaction.h"
#include "TClass.h"


/*!
  \class TATOFaction TATOFaction.hxx "TATOFaction.h"
  \brief Base class for actions. **
*/

ClassImp(TATOFaction);

//------------------------------------------+-----------------------------------
//! Default constructor.

TATOFaction::TATOFaction(const char* name, const char* title)
  : TATOFnamed(name, title),
    fpDataOutList(0),
    fpDataInList(0),
    fpParaList(0),
    fpHistList(0),
    fbHistValid(kFALSE)
{
    if (gTATOFaction) { // ALF
	Error("TATOFaction()", "only one instance of TATOFaction allowed");
	return;
    } 
    gTATOFaction = this; // ALF

  if (!gTATOFroot) Fatal("TATOFaction()", "TATOFroot not instantiated");
  SetBit(kMustCleanup);

  if (name==0 || name[0]==0) SetName(gTATOFroot->DefaultActionName());

  if (gTATOFroot->FindAction(GetName())) {
    Warning("TATOFaction()", "Action with name '%s' already exists", GetName());
  }

  gTATOFroot->ListOfAction()->Add(this);

}

//------------------------------------------+-----------------------------------
//! Destructor.

TATOFaction::~TATOFaction()
{
    gTATOFaction = 0; // ALF
    delete fpDataOutList;
    delete fpDataInList;
    delete fpParaList;
    delete fpHistList;
}

//------------------------------------------+-----------------------------------
//! Invalidate action object.

void TATOFaction::Clear(Option_t*)
{
  ResetBit(kValid|kEof|kFail);
  return;
}

//------------------------------------------+-----------------------------------
//! Process action.

Bool_t TATOFaction::Process(Int_t* p_se,Int_t i_nw)
{
    printf("here\n"); // test
  if (Valid()) return kTRUE;
  if (IsZombie()) {
    Error("Process()", "Action %s is Zombie because dependency was deleted",
	  GetName());
    return kFALSE;
  }
  
  Bool_t b_ok = CheckDependencies(p_se,i_nw);

  if (b_ok) b_ok = Action(p_se,i_nw);
  if (b_ok) SetBit(kValid);

  return b_ok;
}

//------------------------------------------+-----------------------------------
//! Execute action.

Bool_t TATOFaction::Action(Int_t*, Int_t)
{
  return kTRUE;
}

//------------------------------------------+-----------------------------------
//! Create histograms.

void TATOFaction::CreateHistogram()
{
  return;
}

//------------------------------------------+-----------------------------------
//! Delete all histograms.

void TATOFaction::DeleteHistogram()
{
  if (fpHistList) {
    TObjLink* lnk;
    while ( (lnk = fpHistList->FirstLink()) ) {
      TObject* p = fpHistList->Remove(lnk);
      delete p;
    }
  }
  SetValidHistogram(kFALSE);
  return;
}

//------------------------------------------+-----------------------------------
//! Clear histograms.

void TATOFaction::ClearHistogram()
{
  if (fpHistList) {
    for (TObjLink* lnk = fpHistList->FirstLink(); lnk; lnk=lnk->Next()) {
      lnk->GetObject()->Clear();
    }
  }
  return;
}

//------------------------------------------+-----------------------------------
//! Call the Write() method for all histograms.

void TATOFaction::WriteHistogram()
{
  if (fpHistList) {
    for (TObjLink* lnk = fpHistList->FirstLink(); lnk; lnk=lnk->Next()) {
      lnk->GetObject()->Write();
    }
  }
  return;
}

/*------------------------------------------+---------------------------------*/
//! ostream insertion.

void TATOFaction::ToStream(ostream& os, Option_t* option) const
{
  os << "TATOFaction:       " 
     << IsA()->GetName() 
     << " '" << GetName() 
     << "'" << endl;
  if (fpDataOutList) {
    const char* pref = "  data output:   ";
    for (TObjLink* lnk = fpDataOutList->FirstLink(); lnk; lnk=lnk->Next()) {
      TObject* p = lnk->GetObject();
      os << pref << "'" << p->GetName() << "'" << endl;
      pref = "                 ";
    }
  }

  if (fpDataInList) {
    const char* pref = "  data input:    ";
    for (TObjLink* lnk = fpDataInList->FirstLink(); lnk; lnk=lnk->Next()) {
      TObject* p = lnk->GetObject();
      os << pref << "'" << p->GetName() << "'" << endl;
      pref = "                 ";
    }
  }

  if (fpParaList) {
    const char* pref = "  parameter:     ";
    for (TObjLink* lnk = fpParaList->FirstLink(); lnk; lnk=lnk->Next()) {
      TObject* p = lnk->GetObject();
      os << pref << "'" << p->GetName() << "'" << endl;
      pref = "                 ";
    }
  }
  return;
}

//------------------------------------------+-----------------------------------
//! Check dangling object references to TObject \a p_obj . -> Zombie

void TATOFaction::RecursiveRemove(TObject* p_obj)
{
  Bool_t b_zombie = kFALSE;

  if (fpDataOutList) {
    while (fpDataOutList->Remove(p_obj)) b_zombie = kTRUE;
  }
  if (fpDataInList) {
    while (fpDataInList->Remove(p_obj)) b_zombie = kTRUE;
  }
  if (fpParaList) {
    while (fpParaList->Remove(p_obj)) b_zombie = kTRUE;
  }
  if (fpHistList) {
    while (fpHistList->Remove(p_obj)) SetValidHistogram(kFALSE);
  }

  if (b_zombie) MakeZombie();

  return;
}

//------------------------------------------+-----------------------------------
//! Add output data descriptor.

void TATOFaction::AddDataOut(TATOFdataDsc* p_data, const char* baseclass)
{
  if (!p_data) {
    Error("AddDataOut()", "descriptor object pointer is nil");
    MakeZombie();
    return;
  }
  if (!p_data->Object()) {
    Error("AddDataOut()", "data object pointer is nil");
    MakeZombie();
    return;
  }
  if (!p_data->Object()->InheritsFrom(baseclass)) {
    Error("AddDataOut()", "data object type '%s' not based on '%s'", 
	  p_data->Object()->GetName(), baseclass);
    MakeZombie();
    return;
  }
  
  if (!fpDataOutList) fpDataOutList = new TList();
  fpDataOutList->Add(p_data);

  if (p_data->Producer()) {
    Error("AddDataOut()", "data object '%s' already produced by action '%s'",
	  p_data->GetName(), p_data->Producer()->GetName());
    MakeZombie();
    return;
  }

  p_data->SetProducer(this);
  return;
}

//------------------------------------------+-----------------------------------
//! Add input data descriptor.

void TATOFaction::AddDataIn(TATOFdataDsc* p_data, const char* baseclass)
{
  if (!p_data) {
    Error("AddDataIn()", "descriptor object pointer is nil");
    MakeZombie();
    return;
  }
  if (!p_data->Object()) {
    Error("AddDataIn()", "data object pointer is nil");
    MakeZombie();
    return;
  }
  if (!p_data->Object()->InheritsFrom(baseclass)) {
    Error("AddDataIn()", "data object type '%s' not based on '%s'", 
	  p_data->Object()->GetName(), baseclass);
    MakeZombie();
    return;
  }
  
  if (!fpDataInList) fpDataInList = new TList();
  fpDataInList->Add(p_data);
  p_data->SetConsumer(this);
  return;
}

//------------------------------------------+-----------------------------------
//! Add parameter descriptor.

void TATOFaction::AddPara(TATOFparaDsc* p_para, const char* baseclass)
{
  if (!p_para) {
    Error("AddPara()", "descriptor object pointer is nil");
    MakeZombie();
    return;
  }
  if (!p_para->Object()) {
    Error("AddPara()", "para object pointer is nil");
    MakeZombie();
    return;
  }
  if (!p_para->Object()->InheritsFrom(baseclass)) {
    Error("AddPara()", "para object type '%s' not based on '%s'", 
	  p_para->Object()->GetName(), baseclass);
    MakeZombie();
    return;
  }
  
  if (!fpParaList) fpParaList = new TList();
  fpParaList->Add(p_para);
  p_para->SetConsumer(this);
  return;
}

//------------------------------------------+-----------------------------------
//! Add histogram.

void TATOFaction::AddHistogram(TH1* p_hist)
{
  if (!p_hist) {
    Error("AddPara()", "histgram pointer is nil");
    MakeZombie();
    return;
  }
  
  if (!fpHistList) {
    fpHistList = new TList();
    fpHistList->SetOwner(kTRUE);
  }

  fpHistList->Add(p_hist);
  p_hist->SetBit(kMustCleanup);
  return;
}

//------------------------------------------+-----------------------------------
//! Check all dependdencies.

Bool_t TATOFaction::CheckDependencies(Int_t* p_se,Int_t i_nw)
{
  Bool_t b_allvalid = kTRUE;
  
  if (IsZombie()) return kFALSE;

  if (fpDataInList) {
    Bool_t b_noeof  = kTRUE;
    Bool_t b_nofail = kTRUE;

    for (TObjLink* lnk = fpDataInList->FirstLink(); lnk; lnk=lnk->Next()) {
      TATOFdataDsc* p = (TATOFdataDsc*) lnk->GetObject();
      if (!p->Valid()) p->Generate(p_se,i_nw);
      if (!p->Valid()) {
	if (p->Eof())  b_noeof  = kFALSE;
	if (p->Fail()) b_nofail = kFALSE;
	b_allvalid = kFALSE;
      }
    }

    if (!b_noeof)  SetBit(kEof);
    if (!b_nofail) SetBit(kFail);

  }
  return b_allvalid;
}

//------------------------------------------+-----------------------------------
//! Set a status bit in all output data descriptors.

void TATOFaction::SetBitAllDataOut(UInt_t i_bits)
{
  if (fpDataOutList) {
    for (TObjLink* lnk = fpDataOutList->FirstLink(); lnk; lnk=lnk->Next()) {
      lnk->GetObject()->SetBit(i_bits);
    }
  }
  return;
}

/*------------------------------------------+---------------------------------*/
TATOFaction* gTATOFaction=0; // ALF