/***************************************************************************
 *   Copyright (C) 2004 by Olivier Stezowski                               *
 *   stezow(AT)ipnl.in2p3.fr                                               *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/

/** \file ReadMezzAFP.cpp compiled in libADF.so */

#ifndef ADF_ReadMezzAFP
#include "ReadMezzAFP.h"
#endif

#include <iostream>
#include <iomanip>
#include <fstream>
#include <sstream>
#include <cstdio>

ReadMezzAFP::ReadMezzAFP():
    NarvalProducer(),
    fSourceOfFrames(aMByte,ConfAgent::kRead),
    fPath("./"),
    fBaseForName("AFP_"),
    fCurrentFile(0x0),
    fCurrentFileNumber(0u),
    fMaxSize(kMaxInt_t),
    fConfMode(-1),
    fListOfFile(),
    fEndOfFrame("EndOfFrame"),
    fFrameCrystal_Out(NULL),
    fTrigger("data:crystal"),
    fdebug(false),
    fBashColor(new BashColor()),
    fUseKeyFilter(false),
    fLastKeyIsRead(false),
    fNEvts(0),
    fNIgnoredEvts(0)
{	
    if(fdebug) std::cout<<"\E[31;1m"<<"Construct in"<<"\E[m"<<std::endl;

    Log.GetProcessName() = "ReadMezzAFP"; GetFrameIO().SetName("ReadMezzAFP");

    // to be sure unknown frames are written in the ouput
    GetFrameIO().SetModel(ConfAgent::kSafe);
    // to protect writings in the source of frames
    fSourceOfFrames.SetModeIO(ConfAgent::kRead);

    // the input datablock is owned by BasicAFP
    GetFrameIO().Attach(&fSourceOfFrames,0x0);
    fListOfFile.clear();

    if(fdebug) std::cout<<"\E[31;1m"<<"Construct out"<<"\E[m"<<std::endl;
}

ReadMezzAFP::~ReadMezzAFP()
{  
    // in principle not needed ... just in case reset it has not been called by narval
    unsigned int error = 0u; process_reset(&error) ;

    for(int nn = 0; nn < kNSG; nn++ )
        delete [] SegmentTraces[nn];
    for(int nn = 0; nn < kNCC; nn++ )
        delete [] CoreTraces[nn];
} 

bool ReadMezzAFP::NewFile()
{	
    Log.SetProcessMethod("NewFile");
    bool ok = false;

    if ( fConfMode == -1 ) // not properly initialised
        return ok;

    // close the current file
    if ( fCurrentFile )
        ::fclose(fCurrentFile);
    fCurrentFile = 0x0;

    if ( fConfMode == 0 ) {
        // open the first file to be ready to be run
        std::string tmp = fPath;
        if ( tmp.size() > 0 && !(tmp.at(tmp.size()-1) == '/') )
            tmp += '/';

        // try to open the next file
        std::ostringstream filename;
        filename << tmp << fBaseForName
                 << std::setfill('0') << std::setw(4) << fCurrentFileNumber++;

        fCurrentFile = ::fopen(filename.str().data(),"rb");
        if ( fCurrentFile != 0x0 ) {
            Log << "A new input file has just been open "
                << filename.str() << nline;
            fSourceOfFrames.SetFile
                    (fCurrentFile,fMaxSize);
            GetFrameIO().SetStatus
                    (BaseFrameIO::kIdle);
            ok = true;
        }
        else {
            Log << warning << "Cannot open file "
                << filename.str()
                << nline;
            GetFrameIO().SetStatus(BaseFrameIO::kFinished);
        }
    }
    else {
        // try to open the next file
        while ( fCurrentFileNumber < fListOfFile.size() ) {

            fCurrentFile = ::fopen(fListOfFile[fCurrentFileNumber].data(),"rb");
            if ( fCurrentFile == 0x0 ) {
                Log << warning << "File "
                    << fListOfFile[fCurrentFileNumber]
                       << " is not a valid file "
                       << nline ;

                fCurrentFileNumber++;
                continue;
            }
            Log << info << "A new input file has just been open "
                << fListOfFile[fCurrentFileNumber]
                   << nline;
            fSourceOfFrames.SetFile(fCurrentFile,fMaxSize);
            GetFrameIO().SetStatus(BaseFrameIO::kIdle);
            ok = true;
            fCurrentFileNumber++;

            break;
        }
        if ( !ok )
            GetFrameIO().SetStatus(BaseFrameIO::kFinished);
    }
    // send the log collected in this method
    Log << dolog;

    return ok;
}

void ReadMezzAFP::process_config (const char *directory_path, unsigned int *error_code)
{	
    // first init narval and ADF stuff (if required)
    NarvalInterface::process_config(directory_path,error_code);

    if ( (*error_code) == 0u ) { // now init your stuff
    }
}

unsigned int ReadMezzAFP::ProcessBlock(ADF::FrameBlock &out)
{ 
    if(fdebug) std::cout<<"\E[31;1m"<<"ProcessBlock in"<<"\E[m"<<std::endl;

    // attach the input/output buffer to the FrameIO system

    GetFrameIO().Attach(NULL, &out);

    // start the processing

    Frame *frame_out = fFrameCrystal_Out->GetFrame();
    CrystalInterface *cdata = GetDataPointer<CrystalInterface>(frame_out);

    frame_out->Write(); /// dummy test to obtain the frame length

    unsigned int EventLenght = frame_out->GetLength();

    while(out.Reserve(EventLenght,true))
    {
        frame_out->Reset();

        if(!ReadEvent())
        {
            if(NewFile()) continue;
            else
            {
                out.SetEoB(true);
                break;
            }
        }

        if(fLastKeyIsRead)
        {
            out.SetEoB(true);
            break;
        }

        fNEvts++;

        if( fUseKeyFilter)
        {
            if(evnumber == fNextEvtNbr)
            {
                //                fBashColor->SetInfoOut();
                //                std::cout<<"Evt Number = "<<evnumber<<" ; Ref Evt Nbr = "<<fNextEvtNbr<<std::endl;
                //                std::cout<<"TimeStamp = "<<timestamp<<" ; Ref TimeStamp = "<<fNextTS<<std::endl;
                //                fBashColor->ResetColor();
                NextKeyToFind();
            }
            else
            {
                //                fBashColor->SetWarningOut();
                //                std::cout<<"Evt Number = "<<evnumber<<" ignored, looking for Evt Nbr = "<<fNextEvtNbr<<std::endl;
                //                std::cout<<"TimeStamp = "<<timestamp<<" ignored, looking for TimeStamp = "<<fNextTS<<std::endl;
                //                fBashColor->ResetColor();
                fNIgnoredEvts++;
                continue;
            }
        }

        for(int i = 0; i < kNSG; i++) {
            segMezz = cdata->GetSegment(i);
            segMezz->GetSignal()->Set(SegmentTraces[i], fTraceLengthRaw);
            segMezz->SetE(SegE[i]);
            segMezz->SetStatus(SegStatus[i]);
            segMezz->SetID(SegID[i]);
        }
        for(int i = 0; i < kNCC; i++) {
            coreMezz = cdata->GetCore(i);
            coreMezz->GetSignal()->Set(CoreTraces[i], fTraceLengthRaw);
            coreMezz->SetE(CoreE[i]);
            coreMezz->SetStatus(CoreStatus[i]);
            coreMezz->SetID(CoreID[i]);
            coreMezz->SetT(0);
        }

        // Insert timestamp and event number
        ( ( AgataKey * ) frame_out->GetKey() )->SetTimeStamp( timestamp );
        ( ( AgataKey * ) frame_out->GetKey() )->SetEventNumber( evnumber );
        crystal_status = 0;       // all "normal" events are good

        frame_out->Write();

        fTrigger.Fired(true);
        GetFrameIO().Record();
    }

    GetFrameIO().Detach(NULL, &out);

    if(fdebug) std::cout<<"\E[31;1m"<<"ProcessBlock out"<<"\E[m"<<std::endl;

    if ( GetFrameIO().GetStatus() == BaseFrameIO::kFinished || fLastKeyIsRead) return 1u;
    else return 0u;
}	

void ReadMezzAFP::process_initialise (unsigned int *error_code)
{
    if(fdebug) std::cout<<"\E[31;1m"<<"process_initialise in"<<"\E[m"<<std::endl;

    std::string tmp, option;

    *error_code = 0u; Log.ClearMessage(); Log.SetProcessMethod("process_initialise");

    // read an input file to get the base filename and the path
    std::string conffile = GetConfPath();
    conffile += "ReadMezzAFP.conf";

    fCurrentFileNumber = 0u;

    std::ifstream filein(conffile.data());
    if ( filein.is_open() == true ) {
        getline(filein,tmp);
        tmp += " ";
        while ( filein.good() && !filein.eof() ) { // read input stream line by line
            if ( tmp[0] == '#' ) {
                getline(filein,tmp);
                tmp += " ";
                continue;
            } // this line is a comment

            std::istringstream decode(tmp);

            if( tmp[0] == 'b' ){ // to emulate a BasicAFP

                std::string pathforfiles, basename;
                unsigned int starting_number;
                decode >> option >> pathforfiles >> basename >> starting_number;

                if ( decode.good() ) {

                    fPath = pathforfiles;
                    fBaseForName = basename;
                    fCurrentFileNumber = starting_number;

                    fConfMode = 0;
                }
            }
            if( tmp[0] == 'l' ) { // the .conf file contains the list of file to be read

                std::string filename;
                decode >> option >> filename;
                if( decode.good() )
                {
                    std::vector<std::string> token = split(filename,'/');

                    fPath = filename;
                    replace(fPath,token[token.size()-1],"");

                    fListOfFile.push_back(filename);
                }

                fConfMode = 1;
            }
            if( tmp[0] == 'r' ) { // the .conf contains a range of files to be read
                unsigned int starting_number, ending_number;
                std::string pathforfiles, basename;
                decode >> option >> pathforfiles >> basename >> starting_number >> ending_number;
                if( decode.good() && starting_number < ending_number ){

                    fPath = pathforfiles;
                    fBaseForName = basename;

                    for( unsigned int number = starting_number; number <= ending_number; number++ ){
                        std::ostringstream osfilename;
                        osfilename  << pathforfiles << basename << std::setfill('0') << std::setw(4) << number;
                        fListOfFile.push_back(osfilename.str());
                    }
                }
                fConfMode = 2;
            }
            if( tmp[0] == 'f' ) { // the .conf contains a key filter
                std::string pathforfilter;
                decode >> option >> pathforfilter;
                if(decode.good()){
                    fKeyFilterFile = 0x0;
                    fKeyFilterFile = ::fopen(pathforfilter.data(),"rb");
                    if(fKeyFilterFile == 0x0)
                    {
                        fBashColor->SetErrorOut();
                        std::cout<<"Key filter file not found, key filter ignored !"<<std::endl;
                        fBashColor->ResetColor();
                    }
                    else
                    {
                        fBashColor->SetInfoOut();
                        std::cout<<"Key filter file : "<<pathforfilter<<" will be used !"<<std::endl;
                        fBashColor->ResetColor();

                        ::fseek(fKeyFilterFile, 0, SEEK_END);
                        long size = ::ftell(fKeyFilterFile);

                        ::rewind(fKeyFilterFile);

                        fKeyFilterBuffer = new BufferIO(size);

                        fKeyFilterBuffer->Import(fKeyFilterFile,size);
                        fKeyFilterBuffer->SetOffset();

                        const ADF::FactoryItem item("Agata","data:psa",ADF::Version(4,0));

                        fKeyToLink = (AgataKey*)MainKeyFactory::theMainFactory().New(item);

                        NextKeyToFind();

                        fUseKeyFilter = true;
                    }
                }
            }
            getline(filein,tmp);
            tmp += " ";
        }
    }
    else
    {
        std::cout<<"\E[31;1m"<<conffile.data()<<" not found !"<<"\E[m"<<std::endl;
    }
    filein.close();

    switch (fConfMode) {
    case -1:
        *error_code = 1u;
        Log << error << "Not properly initialised" << nline ;
        break;
    case 0:
        Log << info << "Init in BasicAFP mode" << nline ;
        break;
    case 1:
    case 2:
        Log << info << "List of file to be read is " << fListOfFile.size() << nline ;
        break;
    default:
        break;
    }

    // Read the crystal producer conf file

    std::string ConfFilePath = fPath;

    std::vector<std::string> token = split(ConfFilePath,'/');

    replace(ConfFilePath,(std::string)"/" + token[token.size()-3] + "/","/Conf/");

    ConfFilePath += "CrystalProducer.conf";

    std::ifstream ProdConfFile(ConfFilePath.data());
    if ( ProdConfFile.is_open() == true )
    {
        std::string Line;

        while(ProdConfFile)
        {
            getline(ProdConfFile,Line);

            std::vector<std::string> token = split(Line,' ');

            unsigned int val;
            std::istringstream ( token[token.size()-1] ) >> val;

            if(contains(Line,"TraceLength")) fTraceLengthRaw = (unsigned int) val;
            if(contains(Line,"CrystalID")) crystal_id = (unsigned int) val;
        }
    }
    else
    {
        std::cout<<"\E[31;1m"<<ConfFilePath.data()<<" not found !"<<"\E[m"<<std::endl;
        return;
    }

    ADF::CrystalInterface::kDefaultLength = fTraceLengthRaw;

    fFrameCrystal_Out = fTrigger.SetOutputFrame("Agata", "data:crystal");

    if(fFrameCrystal_Out) {
        // link named items with local variables.
        GObject *glob = GetDataPointer<CrystalInterface>(fFrameCrystal_Out)->Global();
        glob->LinkItem("CrystalID",     &crystal_id);
        glob->LinkItem("CrystalStatus", &crystal_status);
    }

    GetFrameIO().Register(&fTrigger);

    GetFrameIO().SetModel(ConfAgent::kSafe);

    // initialise the internal structures

    evnumber = 0;
    timestamp = 0;

    for(int atseg = 0; atseg < kNSG; atseg++) {
        SegmentTraces[atseg] = new unsigned short[fTraceLengthRaw];
        memset(SegmentTraces[atseg], 0, sizeof(unsigned short)*fTraceLengthRaw);
        SegE[atseg] = 0;
        SegID[atseg] = 0;
        SegStatus[atseg] = 0;
    }
    for(int atcore = 0; atcore < kNCC; atcore++) {
        CoreTraces[atcore] = new unsigned short[fTraceLengthRaw];
        memset(CoreTraces[atcore], 0, sizeof(unsigned short)*fTraceLengthRaw);
        CoreE[atcore] = 0;
        CoreID[atcore] = 0;
        CoreStatus[atcore] = 0;
    }

    // open the first file
    if ( *error_code == 0u )
        if ( !NewFile() )
            *error_code = 2u;

    Log << dolog;

    if(fdebug) std::cout<<"\E[31;1m"<<"process_initialise out"<<"\E[m"<<std::endl;
}


void ReadMezzAFP::process_reset (unsigned int *error_code)
{
    *error_code = 0u;
    Log.ClearMessage(); Log.SetProcessMethod("process_reset");

    if ( fCurrentFile )
        ::fclose(fCurrentFile);
    fCurrentFileNumber = 0u;
    fConfMode = -1;

    GetFrameIO().Print( Log() );

    Log << dolog;
}

std::vector<std::string> ReadMezzAFP::split(std::string s, char c)
{
    const char* str = s.c_str();

    std::vector<std::string> result;

    do
    {
        const char *begin = str;

        while(*str != c && *str)
            str++;

        result.push_back(std::string(begin,str));
    }
    while (0 != *str++);

    return result;
}

bool ReadMezzAFP::replace(std::string& str, const std::string& from, const std::string& to)
{
    size_t start_pos = str.find(from);
    if(start_pos == std::string::npos) return false;
    str.replace(start_pos,from.length(), to);
    return true;
}


bool ReadMezzAFP::contains(std::string s1, std::string s2)
{
    if(s1.find(s2) != std::string::npos) return true;
    else return false;
}

unsigned int ReadMezzAFP::uncompress_single_trace_AB(unsigned char* compr, unsigned int csize, unsigned short* trace)
{
    unsigned char* compressed = compr;
    unsigned char* c_end = compr + csize;

    // first trace point is verbatim (little endian)
    unsigned char p1 = *compressed++, p2 = *compressed++;
    unsigned short ref = p2<<8 | p1;
    trace[0] = ref^0x2000;

    unsigned int midx;
    for(midx=1; compressed<c_end && midx<fTraceLengthRaw; ++midx) {
        const unsigned char packed = *compressed++;
        if( (packed & 0x80) == 0 ) {
            // three trace points as two differences
            const unsigned char p2 = *compressed++;
            const unsigned short packed2 = packed<<8 | p2;
            const int diff1 = ((packed2>>10) & 0x1F) - 15;
            const int diff2 = ((packed2>> 5) & 0x1F) - 15;
            const int diff3 = ( packed2      & 0x1F) - 15;
            ref += diff1;
            trace[midx++] = ref^0x2000;
            ref += diff2;
            trace[midx++] = ref^0x2000;
            ref += diff3;
        } else if( (packed & 0xC0) == 0xC0 ) {
            if( compressed>=c_end )
                return false;
            // one trace point as copy
            ref = (packed&0x3F)<<8 | *compressed++;
        } else {
            // one trace point as difference to previous
            const int diff1 = (packed & 0x3F) + MIN_1x6;
            ref += diff1;
        }
        trace[midx] = ref^0x2000;
    }
    return midx;
}

bool ReadMezzAFP::ReadEvent()
{
    int lenChanData;      // MAX number of samples
    int lenChanTotal;     // lenChanHeader + lenChanData
    int lenMezzTotal;     // lenMezzHeader + lenChanTotaln*Chan
    int NChan = 6;

    lenChanData   = fTraceLengthRaw;
    lenChanTotal  = mezzanineChanHeader + lenChanData;
    lenMezzTotal  = mezzanineMezzHeader + lenChanTotal*NChan;

    unsigned short* dbuffer = new unsigned short[lenMezzTotal];

    for(int mezz=0 ; mezz<7 ; mezz++)
    {
        memset(dbuffer, 0, sizeof(unsigned short)*lenMezzTotal);

        fread((void *)dbuffer, sizeof(unsigned short), mezzanineMezzHeader, fCurrentFile);

        unsigned short SlotId = dbuffer[0] & 0x0F ;
        evnumber = (unsigned int) dbuffer[1] | (unsigned int) dbuffer[2] << 16;
        timestamp = (unsigned long long)dbuffer[3] | (unsigned long long)dbuffer[4] << 16 | (unsigned long long)dbuffer[5] << 32;
        unsigned short TraceLen = dbuffer[6];
        unsigned short MezzLen= dbuffer[7];
        //        unsigned short DomainId = dbuffer[8] & 0xFF;
        unsigned int ActMezzLen = dbuffer[15];

        if(::feof(fCurrentFile))
        {
            if(SlotId != 0)
            {
                fBashColor->SetWarningOut();
                std::cout<<"File stoped after reading the header of mezzanine ID : "<<SlotId<<std::endl;
                std::cout<<"Timestamp = "<<timestamp<<std::endl;
                std::cout<<"Event number = "<<evnumber<<std::endl;
                fBashColor->ResetColor();
            }
            delete [] dbuffer;
            return false;
        }

        if(SlotId<1 || SlotId>7)
        {
            std::cout<<"\E[31;1m"<<"Bad Header"<<"\E[m"<<std::endl;
        }

        //        std::cout<<"Mezzanine Header :"<<std::endl;
        //        std::cout<<"SlotId = "<<SlotId<<std::endl;
        //        std::cout<<"EvNumb = "<<evnumber<<std::endl;
        //        std::cout<<"Tstamp = "<<timestamp<<std::endl;
        //        std::cout<<"TraceLen = "<<TraceLen<<std::endl;
        //        std::cout<<"MezzLen = "<<MezzLen<<std::endl;
        //        std::cout<<"DomainId = "<<DomainId<<std::endl;
        //        std::cout<<"ActMezzLen = "<<ActMezzLen<<std::endl<<std::endl;
        //        std::cout<<std::endl;

        if(TraceLen!=fTraceLengthRaw) std::cout<<"\E[31;1m"<<"Number of samples different from configuration file"<<"\E[m"<<std::endl;
        unsigned short nSamp = TraceLen;

        // read and decompress
        int toread = ActMezzLen;

        unsigned short *compBuffer = new unsigned short[toread];
        memset(compBuffer, 0, sizeof(unsigned short)*toread);

        toread -= mezzanineMezzHeader;

        fread(compBuffer, sizeof(unsigned short), toread, fCurrentFile);
        if(::feof(fCurrentFile))
        {
            if(SlotId != 7)
            {
                fBashColor->SetWarningOut();
                std::cout<<"File stoped after reading the traces of mezzanine ID : "<<SlotId<<std::endl;
                std::cout<<"Timestamp = "<<timestamp<<std::endl;
                std::cout<<"Event number = "<<evnumber<<std::endl;
                fBashColor->ResetColor();
            }
            delete [] compBuffer;
            delete [] dbuffer;
            return false;
        }

        int numchan = (MezzLen-mezzanineMezzHeader)/(TraceLen+mezzanineChanHeader);

        if(numchan!=NChan)
        {
            std::cout<<"\E[31;1m"<<"Number of channels non equal to 6"<<"\E[m"<<std::endl;
            lenMezzTotal  = mezzanineMezzHeader + lenChanTotal*numchan;
            unsigned short* newdbuffer = new unsigned short[lenMezzTotal];
            unsigned short* oldbuffer = dbuffer;
            memcpy(dbuffer, newdbuffer, sizeof(unsigned short)*lenMezzTotal);
            delete [] oldbuffer;
            dbuffer =  newdbuffer;
        }

        unsigned short *pD = dbuffer + mezzanineMezzHeader;
        unsigned short *pC = compBuffer;

        for(int nn = 0; nn < numchan; nn++) {
            memcpy(pD, pC, sizeof(unsigned short)*mezzanineChanHeader);
            pC += mezzanineChanHeader;
            pD += mezzanineChanHeader;
            unsigned int csize = pD[-1];
            unsigned int ctype = pD[-2] & 0xF;
            int ll = 0;
            if(ctype!=1)
            {
                std::cout<<"WARNING : Compression type unkown !"<<std::endl;
                break;
            }
            else
            {
                ll = uncompress_single_trace_AB((unsigned char *)pC, 2*csize, pD);
            }
            pD[-1] = 0; // remove compression tags
            pD[-2] = 0;
            pC += csize;;
            pD += ll;
        }

        dbuffer += mezzanineMezzHeader;

        for(int i=0 ; i<numchan ; i++)
        {
            int ID = dbuffer[0];

            int ener32 = dbuffer[2];
            ener32 = (ener32 << 16) | dbuffer[1];

            float Ener = float(ener32)/(1<<16);
            int Status = dbuffer[3];
            //            int CompType = dbuffer[6];
            //            int CompTraceLen = dbuffer[7];

            if(SlotId==1 && (ID==0 || ID==1))
            {
                CoreE[ID] = Ener;
                CoreStatus[ID] = Status;
                CoreID[ID] = ID;
            }
            else if(SlotId==1) {;}
            else
            {
                SegE[(SlotId-2)*6+(5-ID)] = Ener;
                SegStatus[(SlotId-2)*6+(5-ID)] = Status;
                SegID[(SlotId-2)*6+(5-ID)] = (SlotId-2)*6+(5-ID);

                //                fBashColor->SetColor(BashColor::kGreen);
                //                std::cout<<"ID          = "<<ID<<std::endl;
                //                fBashColor->SetColor(BashColor::kYellow);
                //                std::cout<<"5-ID          = "<<5-ID<<std::endl;
                //                fBashColor->SetColor(BashColor::kBlue);
                //                std::cout<<"SlotId          = "<<SlotId<<std::endl;
                //                fBashColor->SetColor(BashColor::kRed);
                //                std::cout<<"(SlotId-2)*6+ID = "<<(SlotId-2)*6+ID<<std::endl;
                //                fBashColor->ResetColor();
            }

            //            std::cout<<"trace ID = "<<ID<<std::endl;
            //            std::cout<<"Ener = "<<Ener<<std::endl;
            //            std::cout<<"Status = "<<Status<<std::endl;
            //            std::cout<<"CompType = "<<CompType<<std::endl;
            //            std::cout<<"CompTraceLen = "<<CompTraceLen<<std::endl;

            dbuffer += mezzanineChanHeader;

            unsigned short tmp16;

            for(int j=0 ; j<nSamp ; j++)
            {
                tmp16  = dbuffer[j];
                tmp16 &= 0x3FFF;                        // keep 14 bits
                tmp16 ^= 0x2000;                        // reverse highest ADC bit
                //            tmp16  = 0x3FFF - tmp16;                // change sign

                //                std::cout<<"samp "<<j<<" : "<<tmp16<<std::endl;

                if(SlotId==1 && (ID==0 || ID==1)) CoreTraces[ID][j] = tmp16;
                else if(SlotId==1) break;
                else SegmentTraces[(SlotId-2)*6+(5-ID)][j] = tmp16;
            }

            dbuffer += nSamp;

            //            std::cout<<std::endl;
        }

        delete [] compBuffer;
        dbuffer -= lenMezzTotal;
    }

    delete [] dbuffer;

    return true;
}

void ReadMezzAFP::NextKeyToFind()
{
    if(fKeyFilterBuffer->FreeSize()==0)
    {
        fBashColor->SetInfoOut();
        std::cout<<"The last key of the key filter file has been read."<<std::endl;
        fBashColor->ResetColor();
        fLastKeyIsRead = true;
        return;
    }

    fKeyToLink->Link((*fKeyFilterBuffer),fKeyFilterBuffer->Offset(),fKeyToLink->GetKeyLength());

    fKeyFilterBuffer->SetOffset(fKeyFilterBuffer->Offset()+fKeyToLink->GetKeyLength());

    fNextTS = fKeyToLink->GetTimeStamp();
    fNextEvtNbr = fKeyToLink->GetEventNumber();

    //        fBashColor->SetColor(BashColor::kRed);
    //        std::cout<<"timestamp = "<<fNextTS<<std::endl;
    //        std::cout<<"EventNumber = "<<fNextEvtNbr<<std::endl;
    //        std::cout<<AgataKeyFactory::theFactory()->GetMessage(fKeyToLink->GetMessage());
    //        fBashColor->ResetColor();
}

void ReadMezzAFP::PrintStats()
{
    fBashColor->SetInfoOut();

    std::cout<<"********  MezzAFP producer stats:  ********"<<std::endl<<std::endl;

    std::cout<<"Number of imput events    : "<<fNEvts<<std::endl;
    std::cout<<"Number of filtered events : "<<fNEvts-fNIgnoredEvts<<" ( "<<((float)(fNEvts-fNIgnoredEvts))/((float)fNEvts)*100.<<"\% )"<<std::endl;
    std::cout<<"Number of ignored events  : "<<fNIgnoredEvts<<" ( "<<((float)fNIgnoredEvts)/((float)fNEvts)*100.<<"% )"<<std::endl;

    std::cout<<std::endl<<"*******************************************"<<std::endl;

    fBashColor->ResetColor();
    return;
}