//#include <boost/cstdint.hpp>
#include <stdint.h>
#include <iostream>
#include <memory>
#include <vector>
#include <cstring>


typedef struct {
  uint8_t firstBit;
  uint32_t timeStamp;
  uint16_t widthPat;
  uint8_t id;
}Hitv2;

class Hit
{
 public:
  static const size_t SIZE_BYTES = 6u;
  Hit(uint8_t* data) : data(data) {}
  uint16_t channel();
  uint16_t type();
  uint32_t timeStamp();
  uint16_t pattern();
  void hexDump();
  void dump();
  uint8_t* data;
};

class Frame
{
 public:
  static const size_t PREAMBLE_SIZE_BYTES = 32u;
  Frame() : rawPreamble(0), rawData(0), fFrameTime(0) {}
    Frame(const Frame& frame) : rawPreamble(0), rawData(0), fFrameTime(0) 
    {
      rawPreamble = new uint8_t[PREAMBLE_SIZE_BYTES];

      memcpy(rawPreamble, frame.rawPreamble, PREAMBLE_SIZE_BYTES);

      rawData = new uint8_t[frame.dataSize_bytes()];
      
      memcpy(rawData, frame.rawData, frame.dataSize_bytes());

      fFrameTime = frame.fFrameTime;
    }
  ~Frame() { if (rawPreamble != 0) delete [] rawPreamble;  if (rawData != 0) delete [] rawData; }
  Frame(std::istream& input) : rawPreamble(0), rawData(0) { read(input); }
  bool read(std::istream& input);
  uint32_t frameSize()    const { return getNumber<uint32_t>( 0u); }
  uint16_t frameType()    const { return getNumber<uint16_t>( 4u); }
  uint16_t frameTarget()  const { return getNumber<uint16_t>( 6u); }
  uint64_t frameTime();//    const { return getNumber<uint64_t>( 8u); }
  uint32_t frameIndex();//   const { return getNumber<uint32_t>(16u); }
  uint16_t frameError()   const { return getNumber<uint16_t>(20u); }
  uint32_t nbItems();
  uint16_t omId()         const { return getNumber<uint16_t>(24u); }
  uint16_t streamId()     const { return getNumber<uint16_t>(26u); }
  uint32_t runNumber()    const { return getNumber<uint32_t>(28u); }
  Hit hit(size_t iHit);
  size_t dataSize_bytes() const { return frameSize() * 4u - PREAMBLE_SIZE_BYTES; }

 private:
  template < typename T >
    T getNumber(size_t iFirstByte) const;
  
  uint8_t* rawPreamble;
  uint8_t* rawData;
  uint64_t fFrameTime;
};

int getFirstBit(size_t pattern, int firstBit);
int getLastBit(size_t pattern, int firstBit);

template<typename WordType>
static inline void swap(WordType& w) {
  WordType x = w;
  char* ptrx = reinterpret_cast<char*>(&x);
  char* ptrw = reinterpret_cast<char*>(&w) + (sizeof(w) - 1);
  for (WordType i=0; i < sizeof(w); ++i) {
    *ptrw-- = *ptrx++;
  }
}

template<unsigned NBYTES>
static inline void* swap(void* data) {
  char bridge;
  char* ptrx = reinterpret_cast<char*>(data);
  char* ptrw = reinterpret_cast<char*>(data) + (NBYTES - 1);
  for (unsigned i=0; i < NBYTES / 2; ++i) {
    bridge = *ptrw;
    *ptrw-- = *ptrx;
    *ptrx++ = bridge;
  }
  return data;
}

static inline void*
swap(void* data, unsigned nBytes) {
  char bridge;
  char* ptrx = static_cast<char*>(data);
  char* ptrw = static_cast<char*>(data) + (nBytes - 1);
  for (unsigned i=0; i < nBytes / 2; ++i) {
    bridge = *ptrw;
    *ptrw-- = *ptrx;
    *ptrx++ = bridge;
  }
  return data;
}

template < typename T >
T Frame::getNumber(size_t iFirstByte) const
{
  T n = reinterpret_cast<T*>(rawPreamble + iFirstByte)[0];
  swap(n);
  return n;
}