// File: hldremotevt.cc
// Authors: H.G & D.B & S.L
// Modified by D.B : 02-12-98
// Modified by D.B : 19-03-99
// Modified by S.L : 20-05-14

//_HADES_CLASS_DESCRIPTION
//////////////////////////////////////////////////////
//HldStreamEvent
//
//  Class used for reading HLD events from DABC stream source
//
/////////////////////////////////////////////////////

#include "hldstreamevt.h"

#ifdef WITH_DABC
#include "hadaq/api.h"
#endif

#include <stdlib.h>
#include "Riostream.h"

//ClassImp(HldStreamEvt)

HldStreamEvt::HldStreamEvt(const char* node, Double_t maxage)
{
   pcNode = "";
   fMaxage = maxage;
   fHandle = 0;

   pHdr = (UInt4*) &hdr;
   pData = 0;
   lastSubEvtIdx = 0;
   if ( !open(node)) exit(1);
}

HldStreamEvt::~HldStreamEvt()
{
#ifdef WITH_DABC
   if (fHandle!=0) {
      ((hadaq::ReadoutHandle*) fHandle)->Disconnect();
      delete (hadaq::ReadoutHandle*) fHandle;
      fHandle = 0;
   }
#endif
}


Bool_t  HldStreamEvt::open (const char* pcnode)
{
   //here the handle is set once.

#ifdef WITH_DABC

   fHandle = new hadaq::ReadoutHandle;

   TString conn = Form("mbs://%s/Stream?reconnect", pcnode);

   if ((strstr(pcnode,".hld")!=0) || (strstr(pcnode,".HLD")!=0)) conn = pcnode;

   *((hadaq::ReadoutHandle*) fHandle) = hadaq::ReadoutHandle::Connect(conn.Data());

   if (((hadaq::ReadoutHandle*) fHandle)->null()) {
      delete (hadaq::ReadoutHandle*) fHandle;
      fHandle = 0;
      return kFALSE;
   }

   return kTRUE;
#endif

   std::cout << "-E- connecting to server " << pcnode << std::endl;
   return kFALSE;
}

Bool_t HldStreamEvt::read()
{
   pHdr = 0;
   pData = 0;

#ifdef WITH_DABC

   if (fHandle==0) return kFALSE;

   hadaq::RawEvent* evnt = 0;

   int cnt = 100;
   while ((cnt-->0) && (evnt==0)) {
      double tmout = 100;
      if (fMaxage > 0) tmout = fMaxage/2.;
      if (tmout<0.2) tmout = 0.2;
      evnt = ((hadaq::ReadoutHandle*) fHandle)->NextEvent(tmout, fMaxage);
   }

   if (evnt==0) {
      printf("FAIL to get HLD event from DABC event source maxage = %f\n", fMaxage);
      return kFALSE;
   }

   pHdr = (UInt4*) evnt;

#endif

//   printf("pHdr = %p\n", pHdr);

   if (pHdr) {

      // swapping should be done in DABC event itself
      // if (isSwapped()) swapHdr();
      if (getSize() > getHdrSize()) {
         pData  = pHdr + getHdrLen();
         // printf("pData = %p  size %d  hdrsize %d \n", pData, getSize(), (int) getHdrSize());
         if (pData) return kTRUE;
      }
   }
   return kFALSE;
}

Bool_t HldStreamEvt::readSubEvt(size_t i)  {
   UInt4* p;
   if (i)
      p = subEvt[i-1].getPaddedEnd();
   else
      p = pData;
   if (p < getPaddedEnd())
      subEvt[i] = HldSubEvt(p);
   else
      return kFALSE;
   return kTRUE;
}



Bool_t HldStreamEvt::execute() {

   if (read()) {

      for (size_t idx = 0; idx < lastSubEvtIdx; idx++) *subEvtTable[idx].p = 0;
      for (size_t i = 0; i < maxSubEvts && readSubEvt(i); i++) { // loop subevts
         Bool_t unpacked=kFALSE;
         for (size_t idx = 0; idx < lastSubEvtIdx; idx++) { // loop unpackers
            if (subEvt[i].getId() == subEvtTable[idx].id) {
               subEvt[i].swapData();
               *subEvtTable[idx].p = subEvt + i;
               //   cout << "pass pointer to subevt to unpacker" << endl;
               unpacked=kTRUE;
            }
         }
         if (isWritable && !unpacked) subEvt[i].swapData();
      }
      return kTRUE;
   } else {
      return kFALSE;
   }
}


Bool_t HldStreamEvt::swap() {
   //Only test the swap byte order in the event
   if (read()) {
      return kTRUE;
   } else {
      return kFALSE;
   }
}