#ifndef HFRPCTRB3LOOKUP_H
#define HFRPCTRB3LOOKUP_H

#include "hparset.h"
#include "htrbnetdef.h"

#include <TObjArray.h>

#define FRPC_TRB3_LOOKUP_SIZE 33

using namespace Trbnet;
using namespace std;

class HFRpcTrb3LookupChan : public TObject {
 protected:
    Char_t sector; // sector number 0..3
    Char_t column; // column number 0 or 2, RPC is double column (column)
    Char_t strip;  // strip number
    Char_t side;   // Near/Far side: N==0, F==1, Far is closer to beam center! and farer to RPC readout.

 public:
    HFRpcTrb3LookupChan() { clear(); }

    Char_t getSector() { return sector; }
    Char_t getColumn() { return column; }
    Char_t getStrip() { return strip; }
    Char_t getSide() { return side; }

    void getAddress(Char_t &m, Char_t &l, Char_t &s, Char_t &nf) const
    {
        m = sector;
        l = column;
        s = strip;
        nf = side;
    }

    void clear()
    {
        sector = -1;
        column = -1;
        strip = -1;
        side = 0;
    }

    void setSector(Char_t m) { sector = m; }
    void setColumn(Char_t l) { column = l; }
    void setStrip(Char_t s) { strip = s; }
    void setSide(Char_t nf) { side = nf; }

    void fill(Char_t m, Char_t l, Char_t s, Char_t nf)
    {
        sector = m;
        column = l;
        strip = s;
        side = nf;
    }

    void fill(HFRpcTrb3LookupChan &r)
    {
        sector = r.getSector();
        column = r.getColumn();
        strip = r.getStrip();
        side = r.getSide();
    }

    ClassDef(HFRpcTrb3LookupChan, 1) // Channel level of the lookup table for the FRpc TRB3 unpacker
};

class HFRpcTrb3LookupTdc : public TObject {
    friend class HFRpcTrb3Lookup;

 protected:
    TObjArray *array; // pointer array containing HFRpcTrb3LookupChan objects
 public:
    HFRpcTrb3LookupTdc();
    ~HFRpcTrb3LookupTdc();

    HFRpcTrb3LookupChan *getChannel(Int_t c)
    {
        if (c >= 0 && c < FRPC_TRB3_LOOKUP_SIZE)
            return &((*this)[c]);
        else
            return 0;
    }

    HFRpcTrb3LookupChan &operator[](Int_t i) { return *static_cast<HFRpcTrb3LookupChan *>((*array)[i]); }

    Int_t getSize() { return FRPC_TRB3_LOOKUP_SIZE; }
    void clear();
    ClassDef(HFRpcTrb3LookupTdc, 1) // Board level of the lookup table for the FRpc TRB3 unpacker
};

class HFRpcTrb3Lookup : public HParSet {
 protected:
    TObjArray *array;  // array of pointers of type HFRpcTrb3LookupTdc
    Int_t arrayOffset; // offset to calculate the index
 public:
    HFRpcTrb3Lookup(const Char_t *name = "FRpcTrb3Lookup",
                    const Char_t *title = "Lookup table for the TRB3 unpacker of the FRpc",
                    const Char_t *context = "FRpcTrb3LookupProduction",
                    Int_t minTrbnetAddress = Trbnet::kFRpcTrb3MinTrbnetAddress,
                    Int_t maxTrbnetAddress = Trbnet::kFRpcTrb3MaxTrbnetAddress);
    ~HFRpcTrb3Lookup();

    HFRpcTrb3LookupTdc *getTdc(Int_t trbnetAddress)
    {
        if ((arrayOffset <= trbnetAddress) && (trbnetAddress <= (array->GetSize() + arrayOffset)))
            return (HFRpcTrb3LookupTdc *)(array->At(trbnetAddress - arrayOffset));
        return 0;
    }
    HFRpcTrb3LookupTdc *operator[](Int_t i) { return static_cast<HFRpcTrb3LookupTdc *>((*array)[i]); }

    Int_t getSize() { return array->GetLast() + 1; }
    Int_t getArrayOffset() { return arrayOffset; }

    Bool_t init(HParIo *input, Int_t *set);
    Int_t write(HParIo *output);
    void clear();
    void printParams();
    Bool_t fill(Int_t, Int_t, Char_t, Char_t, Char_t, Char_t);
    Bool_t readline(const Char_t *);
    void putAsciiHeader(TString &);
    void write(fstream &);
    ClassDef(HFRpcTrb3Lookup, 1) // Lookup table for the TRB3 unpacker of the FRpc
};

#endif /*!HFRPCTRB3LOOKUP_H*/