//_HADES_CLASS_DESCRIPTION
/////////////////////////////////////////////////////////////
//
//  HRpcTrb3Unpacker
//
//  Class for unpacking TRB3 data and filling
//    the Rpc Raw category
//
//  Basic subevent decoding and eventual TDC corrections are
//  performed by decode function in the base class
//  see: /base/datasource/htrb3unpacker.h
//
/////////////////////////////////////////////////////////////

#include "hades.h"
#include "hcategory.h"
#include "hdebug.h"
#include "hevent.h"
#include "heventheader.h"
#include "hldsource.h"
#include "hldsubevt.h"
#include "hruntimedb.h"
#include "hspectrometer.h"
#include "hrpcdetector.h"
#include "hrpcraw.h"
#include "hrpctrb3lookup.h"
#include "hrpctrb3unpacker.h"
#include "rpcdef.h"
#include "htrbnetunpacker.h"

#include <iostream>

using namespace std;

ClassImp(HRpcTrb3Unpacker)

// JAM: this little switch will enable that we also take single leading edges into account
//#define RPC_USE_LEADING_WITHOUT_TRAILING_EDGES 1

// JAM: this little switch will enable that we also take single trailing edges into account
//#define RPC_USE_TRAILING_WITHOUT_LEADING_EDGES 1

// switch on filtering of tdc messages with first time window as defined below
//#define RPC_USE_TIME_WINDOW 1

// first time window to filter out some unusable hits. units are nanoseconds relative to trigger (channel 0)
#define RPC_TIME_MIN -300.0
#define RPC_TIME_MAX  1500.0
// TODO: optionally put this into some parameter container.
Bool_t HRpcTrb3Unpacker::fHasPrintedTDC = kFALSE;

HRpcTrb3Unpacker::HRpcTrb3Unpacker(vector<UInt_t>& ids) : HTrb3TdcUnpacker(ids),
    fLookup(0), fTimeRef(kTRUE), bStoreSpareChanData(kFALSE), fTimeShift(0.) {
	// constructor
	pRawCat = NULL;
}

Bool_t HRpcTrb3Unpacker::init(void) {
    // creates the raw category and gets the pointer to the TRB3 lookup table

    HRpcDetector* det = (HRpcDetector*) gHades->getSetup()->getDetector("Rpc");
    if (!det) {
        Error("init", "No RPC Detector found.");
        return kFALSE;
    }
    pRawCat = det->buildCategory(catRpcRaw);
    if (!pRawCat) return kFALSE;
    else gHades->getCurrentEvent()->addCategory(catRpcRaw,pRawCat,"Rpc");

    fLoc.set(3, 0, 0, 0);

    fLookup = (HRpcTrb3Lookup*) (gHades->getRuntimeDb()->getContainer("RpcTrb3Lookup"));
    if (!fLookup) {
        Error("init", "No Pointer to parameter container RpcTrb3Lookup.");
        return kFALSE;
    }

    if (NULL == trbNetUnpacker) {
        if (gHades->getDataSource()) {
            HDataSource* source = gHades->getDataSource();
            if (source->InheritsFrom("HldSource")) {
                trbNetUnpacker =
                        ((HldSource *) gHades->getDataSource())->getTrbNetUnpacker();
            } else {
                Warning("init",
                        "DataSource not inherited from HldSource! trbNetUnpacker == 0 ");
            }
        } else {
            Warning("init",
                    "Could not retrieve DataSource! trbNetUnpacker == 0 ");
        }
    }

    if (!trbNetUnpacker->init()) {
        Error("init()", "Failed to initialize HTrbNetUnpacker!");
        return kFALSE;
    }

    return kTRUE;
}

Bool_t HRpcTrb3Unpacker::reinit(void)
{
    // Called in the beginning of each run, used here to initialize TDC unpacker
    // if TDCs processors are not yet created, use parameter to instantiate them
    // if auto register TDC feature is used in setup of unpackers (by setting
    // setMinAddress()+setMaxAddress() manually)

    if (numTDC() == 0 )  // configure the tdcs only the first time we come here (do not if autoregister is used):
    {
	if (fMinAddress == 0 && fMaxAddress == 0)
	{
	    // here evaluate which subevents are configured in lookup table:
	    Int_t numTDC = fLookup->getSize();
	    Int_t offset = fLookup->getArrayOffset() ;
	    for (Int_t slot = 0; slot < numTDC; ++slot) {

		Int_t trbnetaddress = offset+slot;

		HRpcTrb3LookupBoard* tdc = fLookup->getBoard(trbnetaddress);
		if(tdc){
		    Int_t nChan = tdc->getSize();
		    if (trbnetaddress) {
			Int_t tindex = addTDC(trbnetaddress,nChan);
			Info("reinit", "Added TDC 0x%04x with %d channels from HRpcTrb3Lookup to map index %d",
			     trbnetaddress, nChan,tindex);
		    }
		}
	    }

	    // set the expected range for the automatic adding of TDC structures:

	    setMinAddress(fLookup->getArrayOffset());
	    setMaxAddress(fLookup->getArrayOffset() + fLookup->getSize());
	    fUseTDCFromLookup = kTRUE; // do not use auto register if set in
	    fHasPrintedTDC = kTRUE;

	} else {
            Info("reinit", "TDCs will be added in auto register mode between min address 0x%04x and max address 0x%04x!",fMinAddress,fMaxAddress);
	}
    }
    // we do not call reinit of superclass, since we do not use tdc calibration parameters in hydra anymore!
    return kTRUE;
}

Int_t HRpcTrb3Unpacker::execute(void) {



    if (gHades->isCalibration()) {
        //calibration event
        return 1;
    }

    if (gHades->getCurrentEvent()->getHeader()->getId() == 0xe) {
        //scaler event
        return 1;
    }

    // if there is no data, do not try to analyze it
    // pSubEvt - make sure that there is something for decoding
    if (!pSubEvt)
        return 1;

    Int_t nEvt = gHades->getCurrentEvent()->getHeader()->getEventSeqNumber();

    // decodes the subevent and fill arrays, see: htrb3unpacker.h
    if (!decode()) {
        Error("decode",
                "subsubevent decoding failed!!! Evt Nr : %i SubEvtId: %x", nEvt,
                getSubEvtId());
        return -1;
    }

    // correct for reference time here!
    // we don't check for proper time reference correction
    // to avoid event skipping
    // this must be done better in future but now is a good workaround

    if (fTimeRef) {
	correctRefTimeCh(REFCHAN);
    }

    const Double_t timeUnit=1e9;


    for (UInt_t ntdc = 0; ntdc < numActiveTDC(); ntdc++) {
        HTrb3TdcUnpacker::TDC* tdc = getActiveTDC(ntdc);

        // check the lookup table
        HRpcTrb3LookupBoard *board = fLookup->getBoard(tdc->getTrbAddr());
        if (!board) {
            if (debugFlag > 0)
                Warning("execute",
                        "Evt Nr : %i  SubEvId: %x (%i) unpacked but TDC Board 0x%x not in lookup table",
                        nEvt, getSubEvtId(), getSubEvtId(), tdc->getTrbAddr());
            continue;
        }

	// fill the raw category for RPC detector
        for (UInt_t i = 0; i < tdc->numChannels(); i++) {
            if(REFCHAN == i) continue;

	    HTrb3TdcUnpacker::ChannelRec& theRecord = tdc->getCh(i);

// ignore channels without rising hits already here
#ifndef RPC_USE_TRAILING_WITHOUT_LEADING_EDGES
            if (theRecord.rising_mult < 1)
                continue;
#endif
            HRpcTrb3LookupChan *chan = board->getChannel(i);
            if (chan == 0) {
                Warning("execute", "Missing channel %u in lookup table", i);
                continue;
            }
            chan->getAddress(fLoc[0], fLoc[1], fLoc[2]);

	    // if channel not connected in lookup-table, ignore it
	    if (fLoc[0] < 0)  { // empty slot default is -1
		continue;
	    }
            /*
	    // exclude all not defined and broken channels
            if (!chan->isDefinedChannel() || chan->isBrokenChannel())
		continue;
            */
            if(!bStoreSpareChanData && fLoc[2]>31) continue;

            if (chan->getSide() == 'n' ) continue; // not connected

#ifdef RPC_USE_TIME_WINDOW
            // later we may get this from parameter container or other setup file. For the moment  fix it
            Double_t tmin = RPC_TIME_MIN;
            Double_t tmax = RPC_TIME_MAX;
#endif
            UInt_t lix = 0;
            for (lix = 0; lix < theRecord.rising_mult; ++lix) {
                Double_t tm0 = theRecord.rising_tm[lix] * timeUnit;
                if (debugFlag > 0)
                    Warning("execute", "JJJJ current hit leading: tm0:%e, apply time shift:%e", tm0, fTimeShift);
                tm0 +=fTimeShift;

#ifdef RPC_USE_TIME_WINDOW
                if ((tm0 < tmin) || (tm0 > tmax)) {
                    if (debugFlag > 0)
                        Warning("execute",
                                "JJJJ Rejecting leading hit outside tmin:%e or tmax:%e",
                                tmin, tmax);
                    continue; // leading edge outside the time window
                }

#endif
                // now look for corresponding trailing edge:
                if (lix < theRecord.falling_mult) {
                    Double_t tm1 = theRecord.falling_tm[lix] * timeUnit;
                    if (debugFlag > 0)
                        Warning("execute", "JJJJ current hit falling: tm1:%e, apply time shift:%e",
                                tm1, fTimeShift);
                    tm1 +=fTimeShift;


#ifdef RPC_USE_TIME_WINDOW
                    if ((tm1 < tmin) || (tm1 > tmax)) {
                        if (debugFlag > 0)
                            Warning("execute",
                                    "JJJJ Rejecting trailing hit outside tmin:%e or tmax:%e",
                                    tmin, tmax);

#ifdef RPC_USE_LEADING_WITHOUT_TRAILING_EDGES
                        tm1=0.0; // still we take incomplete leading edge
#else
                        continue; // skip both leading and trailing
#endif
                    } // if ((tm1 < tmin) || (tm1 > tmax))


#endif
                    //
                    // TODO: optional filter out hits that do not fulfill the time threshold parameter
                    //Double_t tot=tm1-tm0;
                    // however, this can be also done in subsequent calibrator object

/////// ACCEPTED HITS ARE HERE //////////////////////////////////
                    // regular case with leading/trailing edges of ChannelRec in order
                    if (addRawHit(tm0, tm1, chan) != 0)
                        continue; // we will skip this if this channel is not mapped to detector cell

////////// END ACCEPTED HITS/////////////////////////////////////
                } // if lix<theRecord.falling_mul
                else {
#ifdef RPC_USE_LEADING_WITHOUT_TRAILING_EDGES
                    // here we treat hist with only leading edges, no corresponding trailing edge
                    // such hit will deliver tot width of -1
                    if(addRawHit(tm0, 0.0, chan)!=0)
                    continue;
#endif
                }
            } // for lix

////////////// optional now check for single trailing edges?
#ifdef RPC_USE_TRAILING_WITHOUT_LEADING_EDGES

            for (UInt_t tix=lix; tix< theRecord.falling_mult; ++tix)
            {
                Double_t tm1=theRecord.falling_tm[tix] * timeUnit;

#ifdef RPC_USE_TIME_WINDOW
                    if ((tm1 < tmin) || (tm1 > tmax)) {

                        if (debugFlag > 0)
                            Warning("execute",
                                    "JJJJ Rejecting trailing hit outside tmin:%e or tmax:%e",
                                    tmin, tmax);
			continue;
#endif

                if(addRawHit(0.0, tm1, chan)!=0)
		    continue;
            }
             ////////////////////
#endif
/////////////// end single trailing edges


        } // loop over TDC channels
    } // loop over TDC
    return 1;
}

Int_t HRpcTrb3Unpacker::addRawHit(Double_t t_leading, Double_t t_trailing,HRpcTrb3LookupChan *chan)
{

    // from here we got access to TDC channel and should map it to RPC channel
    HRpcRaw* raw = (HRpcRaw*) pRawCat->getObject(fLoc);

    if (!raw) {
	raw = (HRpcRaw *) pRawCat->getSlot(fLoc);
	raw = new (raw) HRpcRaw;
	if(raw){
	    raw->setAddress(fLoc[0], fLoc[1], fLoc[2]);
	} else {
	    if (debugFlag > 0)
		Warning("addRawHit()", "Can't get slot sec=%i, column=%i, cell=%i",
			fLoc[0], fLoc[1],fLoc[2]);
	    return -1;
	}
    }

    Char_t side     = chan->getSide();
    //Int_t feAddress = chan->getFeAddress();

    if(side=='r') {
	raw->setRightTime(t_leading);
	raw->setRightTot(t_trailing - t_leading);
	//raw->setRightTime2(t_trailing);
	//raw->setRightTot2(t_trailing - t_leading);
	//raw->setRightTotLast(t_trailing - t_leading);
	//raw->setRightLogBit(xxx);
	//raw->setRightFeeAddress(feAddress);
    } else if (side=='l') {
	raw->setLeftTime(t_leading);
	raw->setLeftTot(t_trailing - t_leading);
	//raw->setLeftTime2(t_trailing);
	//raw->setLeftTot2(t_trailing - t_leading);
	//raw->setLeftTotLast(t_trailing - t_leading);
	//raw->setLeftLogBit(xxx);
	//raw->setLeftFeeAddress(feAddress);
    }



    if (debugFlag > 1)
        Warning("addRawHit",
		"ADDING hit for sec:%d column:%d cell:%d tm0:%e tm1:%e",
		fLoc[0], fLoc[1], fLoc[2], t_leading, t_trailing);
    return 0;
}