/*!
  \brief   Implementation of TATOFroot.
*/

#include <string.h>

#include "TROOT.h"
#include "TSystem.h"
#include "TApplication.h"
#include "TClass.h"
#include "TSysEvtHandler.h"
#include "TMonitor.h"
#include "TString.h"
#include "TList.h"

#include "TATOFroot.h"
#include "TATOFaction.h"
#include "TATOFdataDsc.h"
#include "TATOFparaDsc.h"

/*!
  \class TATOFroot TATOFroot.h "TATOFroot.h"
  \brief TATOF top level object description. **
*/

//------------------------------------------+-----------------------------------

class TATOFrootInterruptHandler : public TSignalHandler {
  public:
                    TATOFrootInterruptHandler();
    Bool_t          Notify();
};

//------------------------------------------+-----------------------------------
TATOFrootInterruptHandler::TATOFrootInterruptHandler() 
  : TSignalHandler(kSigInterrupt, kFALSE)
{}

//------------------------------------------+-----------------------------------
Bool_t TATOFrootInterruptHandler::Notify()
{
  gTATOFroot->AbortEventLoop();
  return kTRUE;
}

//##############################################################################

ClassImp(TATOFroot);

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

TATOFroot::TATOFroot()
{
  if (gTATOFroot) {
     Error("TATOFroot()", "only one instance of TATOFroot allowed");
     return;
  }
  gTATOFroot = this;
  
  fpActionList          = new TList();
  fpDataDscList         = new TList();
  fpParaDscList         = new TList();
  fpRequiredActionList  = new TList();
  fpRequiredDataDscList = new TList();

  fiDefActionSeqNum  = 0;
  fiDefDataDscSeqNum = 0;
  fiDefParaDscSeqNum = 0;

  fpActionList->SetOwner(kTRUE);
  fpDataDscList->SetOwner(kTRUE);
  fpParaDscList->SetOwner(kTRUE);

  gROOT->GetListOfCleanups()->Add(fpActionList);
  gROOT->GetListOfCleanups()->Add(fpDataDscList);
  gROOT->GetListOfCleanups()->Add(fpParaDscList);
  gROOT->GetListOfCleanups()->Add(fpRequiredActionList);
  gROOT->GetListOfCleanups()->Add(fpRequiredDataDscList);

  fpTATOFrootInterruptHandler = new TATOFrootInterruptHandler();
  fbDefaultHandlerRemoved   = kFALSE;
  fbTATOFrootHandlerAdded     = kFALSE;
  fbAbortEventLoop          = kFALSE;
}

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

TATOFroot::~TATOFroot()
{
  gROOT->GetListOfCleanups()->Remove(fpRequiredActionList);
  delete fpRequiredActionList;

  gROOT->GetListOfCleanups()->Remove(fpRequiredDataDscList);
  delete fpRequiredDataDscList;

  gROOT->GetListOfCleanups()->Remove(fpParaDscList);
  delete fpParaDscList;

  gROOT->GetListOfCleanups()->Remove(fpDataDscList);
  delete fpDataDscList;

  gROOT->GetListOfCleanups()->Remove(fpActionList);
  delete fpActionList;

  gTATOFroot = 0;
}

/*------------------------------------------+---------------------------------*/
//! Add a \c TATOFaction or \c TATOFdataDsc to the list of required items

void TATOFroot::AddRequiredItem(TATOFnamed* p_item)
{
  if (p_item->InheritsFrom("TATOFaction")) {
    if (fpRequiredActionList->IndexOf(p_item) < 0)
      fpRequiredActionList->Add(p_item);

  } else if (p_item->InheritsFrom("TATOFdataDsc")) {
    if (fpRequiredDataDscList->IndexOf(p_item))
      fpRequiredDataDscList->Add(p_item);

  } else {
    Error("AddRequiredItem()",
	  "Object of type %s not based on TATOFaction or TATOFdataDsc",
	  p_item->IsA()->GetName());
  }
  return;
}

/*------------------------------------------+---------------------------------*/
//! Add a \c TATOFaction or \c TATOFdataDsc named \a name to list of required items

void TATOFroot::AddRequiredItem(const char* name)
{
  TATOFaction*  p_act = FindAction(name);
  TATOFdataDsc* p_dsc = FindDataDsc(name);

  if (p_act && !p_dsc) {
    AddRequiredItem(p_act);
  } else if (!p_act && p_dsc) {
    AddRequiredItem(p_dsc);
  } else if (p_act && p_dsc) {
    Warning("name '%s' ambiguous (action and data available)", name);
  } else {
    Warning("no object named '%s' found", name);
  }

  return;
}

/*------------------------------------------+---------------------------------*/
//! Clear list of required items

void TATOFroot::ClearRequiredList()
{
  fpRequiredActionList->Clear();
  fpRequiredDataDscList->Clear();
  return;
}

/*------------------------------------------+---------------------------------*/
//! Setup event loop.

void TATOFroot::BeginEventLoop()
{
  if (gApplication->GetSignalHandler() && !fbDefaultHandlerRemoved) {
    gApplication->GetSignalHandler()->Remove();
    fbDefaultHandlerRemoved = kTRUE;
  }

  if (!fbTATOFrootHandlerAdded) {
    fpTATOFrootInterruptHandler->Add();
    fbTATOFrootHandlerAdded = kTRUE;
  }

  fbAbortEventLoop = kFALSE;

  return;
}

/*------------------------------------------+---------------------------------*/
//! end event loop.

void TATOFroot::EndEventLoop()
{
  if (fbTATOFrootHandlerAdded) {
    fpTATOFrootInterruptHandler->Remove();
    fbTATOFrootHandlerAdded = kFALSE;
  }

  if (gApplication->GetSignalHandler() && fbDefaultHandlerRemoved) {
    gApplication->GetSignalHandler()->Add();
    fbDefaultHandlerRemoved = kFALSE;
  }

  return;
}

/*------------------------------------------+---------------------------------*/
//! abort event loop.

void TATOFroot::AbortEventLoop()
{
  fbAbortEventLoop = kTRUE;
  return;
}

/*------------------------------------------+---------------------------------*/
//! Process required items of next event

Bool_t TATOFroot::NextEvent(Int_t* p_se,Int_t i_nw)
{
  Bool_t b_ok = kFALSE;

  if (fbAbortEventLoop) {
    Warning("NextEvent()","Aborting event loop");
    return kFALSE;
  }
  
  gSystem->ProcessEvents();

  ClearAllAction();
  ClearAllData();

  fEventId.SetEventNumber(1+fEventId.EventNumber()); // increment event number
  /*
    for (TObjLink* lnk = fpRequiredActionList->FirstLink(); 
    lnk; lnk=lnk->Next()) {
    TATOFaction* p = (TATOFaction*) lnk->GetObject();
    if (!p->Process(p_se,i_nw)) return kFALSE;
    b_ok = kTRUE;
    }
  */

  if (!gTATOFaction->Process(p_se,i_nw)) return kFALSE;
  b_ok = kTRUE;

  /* a tester ensuite  
  for (TObjLink* lnk = fpRequiredDataDscList->FirstLink(); 
       lnk; lnk=lnk->Next()) {
    TATOFdataDsc* p = (TATOFdataDsc*) lnk->GetObject();
    if (!p->Generate(p_se,i_nw)) return kFALSE;
    b_ok = kTRUE;
  }
  */
  if (!b_ok) Error("NextEvent()", "No required Items registered");

  return b_ok;
}

/*------------------------------------------+---------------------------------*/
//! Clear all action objects

void TATOFroot::ClearAllAction()
{
  for (TObjLink* lnk = fpActionList->FirstLink(); lnk; lnk=lnk->Next()) {
    lnk->GetObject()->Clear();
  }
  return;
}

/*------------------------------------------+---------------------------------*/
//! Wait for \a i_msec msec.

void TATOFroot::Wait(Int_t i_msec)
{
  TMonitor monitor;
  monitor.Select(i_msec);
  return;
}

/*------------------------------------------+---------------------------------*/
//! Clear all data objects

void TATOFroot::ClearAllData()
{
  for (TObjLink* lnk = fpDataDscList->FirstLink(); lnk; lnk=lnk->Next()) {
    lnk->GetObject()->Clear();
  }
  return;
}

/*------------------------------------------+---------------------------------*/
//! Clear all parameter objects

void TATOFroot::ClearAllPara()
{
  for (TObjLink* lnk = fpParaDscList->FirstLink(); lnk; lnk=lnk->Next()) {
    lnk->GetObject()->Clear();
  }
  return;
}

/*------------------------------------------+---------------------------------*/
//! Returns next default action name.

const char* TATOFroot::DefaultActionName()
{
  return Form("A%03d", fiDefActionSeqNum++);
}

/*------------------------------------------+---------------------------------*/
//! Returns next default data descriptor name.

const char* TATOFroot::DefaultDataDscName()
{
  return Form("D%03d", fiDefDataDscSeqNum++);
}

/*------------------------------------------+---------------------------------*/
//! Returns next default data descriptor name.

const char* TATOFroot::DefaultParaDscName()
{
  return Form("P%03d", fiDefParaDscSeqNum++);
}

/*------------------------------------------+---------------------------------*/
//! Return pointer to action with name \a name and type \a type (or 0).
/*!
  Scans the list of actions for an action with the name \a name. 
  If \a type is non-nil and non-empty, the type of the action object is 
  checked against \a type. If no match is found a 0 is returned.
 */

TATOFaction* TATOFroot::FindAction(const char* name, const char* type) const
{
  TATOFaction* p = (TATOFaction*) fpActionList->FindObject(name);
  if (p && type && type[0]) {
    if (strcmp(p->ClassName(), type) != 0) p = 0;
  }
  return p;
}

/*------------------------------------------+---------------------------------*/
//! Return pointer to data descriptor with name \a name (or 0).
/*!
  Scans the list of data descriptors for a discriptor with the name
  \a name. If \a type is non-nil and non-empty, the type of the data
  object is checked against \a type. If no match is found a 0 is returned.
 */

TATOFdataDsc* TATOFroot::FindDataDsc(const char* name, const char* type) const
{
  TATOFdataDsc* p = (TATOFdataDsc*) fpDataDscList->FindObject(name);
  if (p && type && type[0]) {
    if (strcmp(p->Object()->ClassName(), type) != 0) p = 0;
  }
  return p;
}

/*------------------------------------------+---------------------------------*/
//! Return pointer to data descriptor with name \a name (or 0).
/*!
  Scans the list of parameter descriptors for a discriptor with the name
  \a name. If \a type is non-nil and non-empty, the type of the parameter
  object is checked against \a type. If no match is found a 0 is returned.
 */

TATOFparaDsc* TATOFroot::FindParaDsc(const char* name, const char* type) const
{
  TATOFparaDsc* p = (TATOFparaDsc*) fpParaDscList->FindObject(name);
  if (p && type && type[0]) {
    if (strcmp(p->Object()->ClassName(), type) != 0) p = 0;
  }
  return p;
}

/*------------------------------------------+---------------------------------*/
//! Set campaign and run number from TATOFrunInfo \a info .

void TATOFroot::SetRunInfo(const TATOFrunInfo& info)
{
  fRunInfo.SetCampaignNumber(info.CampaignNumber());
  fRunInfo.SetRunNumber(info.RunNumber());
  fEventId.SetCampaignNumber(info.CampaignNumber());
  fEventId.SetRunNumber(info.RunNumber());
  return;
}

/*------------------------------------------+---------------------------------*/
//! Set campaign, run , and event number from TATOFeventId \a info .

void TATOFroot::SetEventId(const TATOFeventId& info)
{
  fRunInfo.SetCampaignNumber(info.CampaignNumber());
  fRunInfo.SetRunNumber(info.RunNumber());
  fEventId.SetCampaignNumber(info.CampaignNumber());
  fEventId.SetRunNumber(info.RunNumber());
  fEventId.SetEventNumber(info.EventNumber());
  return;
}

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

void TATOFroot::ToStream(ostream& os, Option_t* option) const
{
  os << "TATOFroot: " << endl;
  os << "Known Actions:" << endl;
  os << "  name              type" << endl;
  for (TObjLink* lnk = fpActionList->FirstLink(); lnk; lnk=lnk->Next()) {
    TATOFaction* p = (TATOFaction*) lnk->GetObject();
    os << "  " << Form("%-16s", p->GetName())
       << "  " << Form("%-24s", p->IsA()->GetName()) << endl;
  }
  
  os << "Known ParaDsc's:" << endl;
  os << "  name              type" << endl;
  for (TObjLink* lnk = fpParaDscList->FirstLink(); lnk; lnk=lnk->Next()) {
    TATOFparaDsc* p = (TATOFparaDsc*) lnk->GetObject();
    os << "  " << Form("%-16s", p->GetName())
       << "  " << Form("%-24s", p->Object()->IsA()->GetName()) << endl;
  }

  os << "Known DataDsc's:" << endl;
  os << "  name              type                      produced by" << endl;
  for (TObjLink* lnk = fpDataDscList->FirstLink(); lnk; lnk=lnk->Next()) {
    TATOFdataDsc* p = (TATOFdataDsc*) lnk->GetObject();
    os << "  " << Form("%-16s", p->GetName())
       << "  " << Form("%-24s", p->Object()->IsA()->GetName());
    if (p->Producer()) os << "  " << p->Producer()->GetName();
    os << endl;
  }

  os << "Required Actions:" << endl;
  for (TObjLink* lnk = fpRequiredActionList->FirstLink(); 
       lnk; lnk=lnk->Next()) {
    TATOFaction* p = (TATOFaction*) lnk->GetObject();
    os << "  " << Form("%-16s", p->GetName())
       << "  " << Form("%-24s", p->IsA()->GetName()) << endl;
  }
  
  os << "Required DataDsc's:" << endl;
  for (TObjLink* lnk = fpRequiredDataDscList->FirstLink(); 
       lnk; lnk=lnk->Next()) {
    TATOFdataDsc* p = (TATOFdataDsc*) lnk->GetObject();
    os << "  " << Form("%-16s", p->GetName())
       << "  " << Form("%-24s", p->Object()->IsA()->GetName()) << endl;
  }

  return;
}

/*------------------------------------------+---------------------------------*/

TATOFroot* gTATOFroot=0;