#ifndef FRAMEWORK_CONTAINER_INDEXEDRINGMEMORY_H_
#define FRAMEWORK_CONTAINER_INDEXEDRINGMEMORY_H_

#include <cmath>

#include "../globalfunctions/CRC.h"
#include "../returnvalues/returnvalue.h"
#include "../serialize/SerialArrayListAdapter.h"
#include "../serviceinterface/ServiceInterfaceStream.h"
#include "ArrayList.h"

template <typename T>
class Index : public SerializeIF {
  /**
   * Index is the Type used for the list of indices. The template parameter is the type which
   * describes the index, it needs to be a child of SerializeIF to be able to make it persistent
   */
  static_assert(std::is_base_of<SerializeIF, T>::value,
                "Wrong Type for Index, Type must implement SerializeIF");

 public:
  Index() : blockStartAddress(0), size(0), storedPackets(0) {}

  Index(uint32_t startAddress) : blockStartAddress(startAddress), size(0), storedPackets(0) {}

  void setBlockStartAddress(uint32_t newAddress) { this->blockStartAddress = newAddress; }

  uint32_t getBlockStartAddress() const { return blockStartAddress; }

  const T* getIndexType() const { return &indexType; }

  T* modifyIndexType() { return &indexType; }
  /**
   * Updates the index Type. Uses = operator
   * @param indexType Type to copy from
   */
  void setIndexType(T* indexType) { this->indexType = *indexType; }

  uint32_t getSize() const { return size; }

  void setSize(uint32_t size) { this->size = size; }

  void addSize(uint32_t size) { this->size += size; }

  void setStoredPackets(uint32_t newStoredPackets) { this->storedPackets = newStoredPackets; }

  void addStoredPackets(uint32_t packets) { this->storedPackets += packets; }

  uint32_t getStoredPackets() const { return this->storedPackets; }

  ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
                          Endianness streamEndianness) const {
    ReturnValue_t result =
        SerializeAdapter::serialize(&blockStartAddress, buffer, size, maxSize, streamEndianness);
    if (result != returnvalue::OK) {
      return result;
    }
    result = indexType.serialize(buffer, size, maxSize, streamEndianness);
    if (result != returnvalue::OK) {
      return result;
    }
    result = SerializeAdapter::serialize(&this->size, buffer, size, maxSize, streamEndianness);
    if (result != returnvalue::OK) {
      return result;
    }
    result =
        SerializeAdapter::serialize(&this->storedPackets, buffer, size, maxSize, streamEndianness);
    return result;
  }

  ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size, Endianness streamEndianness) {
    ReturnValue_t result =
        SerializeAdapter::deSerialize(&blockStartAddress, buffer, size, streamEndianness);
    if (result != returnvalue::OK) {
      return result;
    }
    result = indexType.deSerialize(buffer, size, streamEndianness);
    if (result != returnvalue::OK) {
      return result;
    }
    result = SerializeAdapter::deSerialize(&this->size, buffer, size, streamEndianness);
    if (result != returnvalue::OK) {
      return result;
    }
    result = SerializeAdapter::deSerialize(&this->storedPackets, buffer, size, streamEndianness);
    if (result != returnvalue::OK) {
      return result;
    }
    return result;
  }

  size_t getSerializedSize() const {
    uint32_t size = SerializeAdapter::getSerializedSize(&blockStartAddress);
    size += indexType.getSerializedSize();
    size += SerializeAdapter::getSerializedSize(&this->size);
    size += SerializeAdapter::getSerializedSize(&this->storedPackets);
    return size;
  }

  bool operator==(const Index<T>& other) {
    return ((blockStartAddress == other.getBlockStartAddress()) && (size == other.getSize())) &&
           (indexType == *(other.getIndexType()));
  }

 private:
  uint32_t blockStartAddress;
  uint32_t size;
  uint32_t storedPackets;
  T indexType;
};

template <typename T>
class IndexedRingMemoryArray : public SerializeIF, public ArrayList<Index<T>, uint32_t> {
  /**
   * Indexed Ring Memory Array is a class for a ring memory with indices. It assumes that the newest
   * data comes in last It uses the currentWriteBlock as pointer to the current writing position The
   * currentReadBlock must be set manually
   */
 public:
  IndexedRingMemoryArray(uint32_t startAddress, uint32_t size, uint32_t bytesPerBlock,
                         SerializeIF* additionalInfo, bool overwriteOld)
      : ArrayList<Index<T>, uint32_t>(NULL, (uint32_t)10, (uint32_t)0),
        totalSize(size),
        indexAddress(startAddress),
        currentReadSize(0),
        currentReadBlockSizeCached(0),
        lastBlockToReadSize(0),
        additionalInfo(additionalInfo),
        overwriteOld(overwriteOld) {
    // Calculate the maximum number of indices needed for this blocksize
    uint32_t maxNrOfIndices = floor(static_cast<double>(size) / static_cast<double>(bytesPerBlock));

    // Calculate the Size needeed for the index itself
    uint32_t serializedSize = 0;
    if (additionalInfo != NULL) {
      serializedSize += additionalInfo->getSerializedSize();
    }
    // Size of current iterator type
    Index<T> tempIndex;
    serializedSize += tempIndex.getSerializedSize();

    // Add Size of Array
    serializedSize += sizeof(uint32_t);                                  // size of array
    serializedSize += (tempIndex.getSerializedSize() * maxNrOfIndices);  // size of elements
    serializedSize += sizeof(uint16_t);                                  // size of crc

    // Calculate new size after index
    if (serializedSize > totalSize) {
      error << "IndexedRingMemory: Store is too small for index" << std::endl;
    }
    uint32_t useableSize = totalSize - serializedSize;
    // Update the totalSize for calculations
    totalSize = useableSize;

    // True StartAddress
    uint32_t trueStartAddress = indexAddress + serializedSize;

    // Calculate True number of Blocks and reset size of true Number of Blocks
    uint32_t trueNumberOfBlocks =
        floor(static_cast<double>(totalSize) / static_cast<double>(bytesPerBlock));

    // allocate memory now
    this->entries = new Index<T>[trueNumberOfBlocks];
    this->size = trueNumberOfBlocks;
    this->maxSize_ = trueNumberOfBlocks;
    this->allocated = true;

    // Check trueNumberOfBlocks
    if (trueNumberOfBlocks < 1) {
      error << "IndexedRingMemory: Invalid Number of Blocks: " << trueNumberOfBlocks;
    }

    // Fill address into index
    uint32_t address = trueStartAddress;
    for (typename IndexedRingMemoryArray<T>::Iterator it = this->begin(); it != this->end(); ++it) {
      it->setBlockStartAddress(address);
      it->setSize(0);
      it->setStoredPackets(0);
      address += bytesPerBlock;
    }

    // Initialize iterators
    currentWriteBlock = this->begin();
    currentReadBlock = this->begin();
    lastBlockToRead = this->begin();

    // Check last blockSize
    uint32_t lastBlockSize =
        (trueStartAddress + useableSize) - (this->back()->getBlockStartAddress());
    if ((lastBlockSize < bytesPerBlock) && (this->size > 1)) {
      // remove the last Block so the second last block has more size
      this->size -= 1;
      debug << "IndexedRingMemory: Last Block is smaller than bytesPerBlock, removed last block"
            << std::endl;
    }
  }

  /**
   * Resets the whole index, the iterators and executes the given reset function on every index type
   * @param typeResetFnc static reset function which accepts a pointer to the index Type
   */
  void reset(void (*typeResetFnc)(T*)) {
    currentReadBlock = this->begin();
    currentWriteBlock = this->begin();
    lastBlockToRead = this->begin();
    currentReadSize = 0;
    currentReadBlockSizeCached = 0;
    lastBlockToReadSize = 0;
    for (typename IndexedRingMemoryArray<T>::Iterator it = this->begin(); it != this->end(); ++it) {
      it->setSize(0);
      it->setStoredPackets(0);
      (*typeResetFnc)(it->modifyIndexType());
    }
  }

  void resetBlock(typename IndexedRingMemoryArray<T>::Iterator it, void (*typeResetFnc)(T*)) {
    it->setSize(0);
    it->setStoredPackets(0);
    (*typeResetFnc)(it->modifyIndexType());
  }

  /*
   * Reading
   */

  void setCurrentReadBlock(typename IndexedRingMemoryArray<T>::Iterator it) {
    currentReadBlock = it;
    currentReadBlockSizeCached = it->getSize();
  }

  void resetRead() {
    currentReadBlock = this->begin();
    currentReadSize = 0;
    currentReadBlockSizeCached = this->begin()->getSize();
    lastBlockToRead = currentWriteBlock;
    lastBlockToReadSize = currentWriteBlock->getSize();
  }
  /**
   * Sets the last block to read to this iterator.
   * Can be used to dump until block x
   * @param it The iterator for the last read block
   */
  void setLastBlockToRead(typename IndexedRingMemoryArray<T>::Iterator it) {
    lastBlockToRead = it;
    lastBlockToReadSize = it->getSize();
  }

  /**
   * Set the read pointer to the first written Block, which is the first non empty block in front of
   * the write block Can be the currentWriteBlock as well
   */
  void readOldest() {
    resetRead();
    currentReadBlock = getNextNonEmptyBlock();
    currentReadBlockSizeCached = currentReadBlock->getSize();
  }

  /**
   * Sets the current read iterator to the next Block and resets the current read size
   * The current size of the block will be cached to avoid race condition between write and read
   * If the end of the ring is reached the read pointer will be set to the begin
   */
  void readNext() {
    currentReadSize = 0;
    if ((this->size != 0) && (currentReadBlock.value == this->back())) {
      currentReadBlock = this->begin();
    } else {
      currentReadBlock++;
    }

    currentReadBlockSizeCached = currentReadBlock->getSize();
  }

  /**
   * Returns the address which is currently read from
   * @return Address to read from
   */
  uint32_t getCurrentReadAddress() const {
    return getAddressOfCurrentReadBlock() + currentReadSize;
  }
  /**
   * Adds readSize to the current size and checks if the read has no more data left and advances the
   * read block
   * @param readSize The size that was read
   * @return Returns true if the read can go on
   */
  bool addReadSize(uint32_t readSize) {
    if (currentReadBlock == lastBlockToRead) {
      // The current read block is the last to read
      if ((currentReadSize + readSize) < lastBlockToReadSize) {
        // the block has more data -> return true
        currentReadSize += readSize;
        return true;
      } else {
        // Reached end of read -> return false
        currentReadSize = lastBlockToReadSize;
        return false;
      }
    } else {
      // We are not in the last Block
      if ((currentReadSize + readSize) < currentReadBlockSizeCached) {
        // The current Block has more data
        currentReadSize += readSize;
        return true;
      } else {
        // The current block is written completely
        readNext();
        if (currentReadBlockSizeCached == 0) {
          // Next block is empty
          typename IndexedRingMemoryArray<T>::Iterator it(currentReadBlock);
          // Search if any block between this and the last block is not empty
          for (; it != lastBlockToRead; ++it) {
            if (it == this->end()) {
              // This is the end, next block is the begin
              it = this->begin();
              if (it == lastBlockToRead) {
                // Break if the begin is the lastBlockToRead
                break;
              }
            }
            if (it->getSize() != 0) {
              // This is a non empty block. Go on reading with this block
              currentReadBlock = it;
              currentReadBlockSizeCached = it->getSize();
              return true;
            }
          }
          // reached lastBlockToRead and every block was empty, check if the last block is also
          // empty
          if (lastBlockToReadSize != 0) {
            // go on with last Block
            currentReadBlock = lastBlockToRead;
            currentReadBlockSizeCached = lastBlockToReadSize;
            return true;
          }
          // There is no non empty block left
          return false;
        }
        // Size is larger than 0
        return true;
      }
    }
  }
  uint32_t getRemainigSizeOfCurrentReadBlock() const {
    if (currentReadBlock == lastBlockToRead) {
      return (lastBlockToReadSize - currentReadSize);
    } else {
      return (currentReadBlockSizeCached - currentReadSize);
    }
  }

  uint32_t getAddressOfCurrentReadBlock() const { return currentReadBlock->getBlockStartAddress(); }

  /**
   * Gets the next non empty Block after the current write block,
   * @return Returns the iterator to the block. If there is non, the current write block is returned
   */
  typename IndexedRingMemoryArray<T>::Iterator getNextNonEmptyBlock() const {
    for (typename IndexedRingMemoryArray<T>::Iterator it = getNextWrite(); it != currentWriteBlock;
         ++it) {
      if (it == this->end()) {
        it = this->begin();
        if (it == currentWriteBlock) {
          break;
        }
      }
      if (it->getSize() != 0) {
        return it;
      }
    }
    return currentWriteBlock;
  }

  /**
   * Returns a copy of the oldest Index type
   * @return Type of Index
   */
  T* getOldest() { return (getNextNonEmptyBlock()->modifyIndexType()); }

  /*
   * Writing
   */
  uint32_t getAddressOfCurrentWriteBlock() const {
    return currentWriteBlock->getBlockStartAddress();
  }

  uint32_t getSizeOfCurrentWriteBlock() const { return currentWriteBlock->getSize(); }

  uint32_t getCurrentWriteAddress() const {
    return getAddressOfCurrentWriteBlock() + getSizeOfCurrentWriteBlock();
  }

  void clearCurrentWriteBlock() {
    currentWriteBlock->setSize(0);
    currentWriteBlock->setStoredPackets(0);
  }

  void addCurrentWriteBlock(uint32_t size, uint32_t storedPackets) {
    currentWriteBlock->addSize(size);
    currentWriteBlock->addStoredPackets(storedPackets);
  }

  T* modifyCurrentWriteBlockIndexType() { return currentWriteBlock->modifyIndexType(); }
  void updatePreviousWriteSize(uint32_t size, uint32_t storedPackets) {
    typename IndexedRingMemoryArray<T>::Iterator it = getPreviousBlock(currentWriteBlock);
    it->addSize(size);
    it->addStoredPackets(storedPackets);
  }

  /**
   * Checks if the block has enough space for sizeToWrite
   * @param sizeToWrite The data to be written in the Block
   * @return Returns true if size to write is smaller the remaining size of the block
   */
  bool hasCurrentWriteBlockEnoughSpace(uint32_t sizeToWrite) {
    typename IndexedRingMemoryArray<T>::Iterator next = getNextWrite();
    uint32_t addressOfNextBlock = next->getBlockStartAddress();
    uint32_t availableSize = ((addressOfNextBlock + totalSize) -
                              (getAddressOfCurrentWriteBlock() + getSizeOfCurrentWriteBlock())) %
                             totalSize;
    return (sizeToWrite < availableSize);
  }

  /**
   * Checks if the store is full if overwrite old is false
   * @return Returns true if it is writeable and false if not
   */
  bool isNextBlockWritable() {
    // First check if this is the end of the list
    typename IndexedRingMemoryArray<T>::Iterator next;
    next = getNextWrite();
    if ((next->getSize() != 0) && (!overwriteOld)) {
      return false;
    }
    return true;
  }

  /**
   * Updates current write Block Index Type
   * @param infoOfNewBlock
   */
  void updateCurrentBlock(T* infoOfNewBlock) { currentWriteBlock->setIndexType(infoOfNewBlock); }

  /**
   * Succeed to next block, returns FAILED if overwrite is false and the store is full
   * @return
   */
  ReturnValue_t writeNext() {
    // Check Next Block
    if (!isNextBlockWritable()) {
      // The Index is full and does not overwrite old
      return returnvalue::FAILED;
    }
    // Next block can be written, update Metadata
    currentWriteBlock = getNextWrite();
    currentWriteBlock->setSize(0);
    currentWriteBlock->setStoredPackets(0);
    return returnvalue::OK;
  }

  /**
   * Serializes the Index and calculates the CRC.
   * Parameters according to HasSerializeIF
   * @param buffer
   * @param size
   * @param maxSize
   * @param streamEndianness
   * @return
   */
  ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
                          Endianness streamEndianness) const {
    uint8_t* crcBuffer = *buffer;
    uint32_t oldSize = *size;
    if (additionalInfo != NULL) {
      additionalInfo->serialize(buffer, size, maxSize, streamEndianness);
    }
    ReturnValue_t result = currentWriteBlock->serialize(buffer, size, maxSize, streamEndianness);
    if (result != returnvalue::OK) {
      return result;
    }
    result = SerializeAdapter::serialize(&this->size, buffer, size, maxSize, streamEndianness);
    if (result != returnvalue::OK) {
      return result;
    }

    uint32_t i = 0;
    while ((result == returnvalue::OK) && (i < this->size)) {
      result =
          SerializeAdapter::serialize(&this->entries[i], buffer, size, maxSize, streamEndianness);
      ++i;
    }
    if (result != returnvalue::OK) {
      return result;
    }
    uint16_t crc = Calculate_CRC(crcBuffer, (*size - oldSize));
    result = SerializeAdapter::serialize(&crc, buffer, size, maxSize, streamEndianness);
    return result;
  }

  /**
   * Get the serialized Size of the index
   * @return The serialized size of the index
   */
  size_t getSerializedSize() const {
    uint32_t size = 0;
    if (additionalInfo != NULL) {
      size += additionalInfo->getSerializedSize();
    }
    size += currentWriteBlock->getSerializedSize();
    size += SerializeAdapter::getSerializedSize(&this->size);
    size += (this->entries[0].getSerializedSize()) * this->size;
    uint16_t crc = 0;
    size += SerializeAdapter::getSerializedSize(&crc);
    return size;
  }
  /**
   * DeSerialize the Indexed Ring from a buffer, deSerializes the current write iterator
   * CRC Has to be checked before!
   * @param buffer
   * @param size
   * @param streamEndianness
   * @return
   */

  ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size, Endianness streamEndianness) {
    ReturnValue_t result = returnvalue::OK;
    if (additionalInfo != NULL) {
      result = additionalInfo->deSerialize(buffer, size, streamEndianness);
    }
    if (result != returnvalue::OK) {
      return result;
    }

    Index<T> tempIndex;
    result = tempIndex.deSerialize(buffer, size, streamEndianness);
    if (result != returnvalue::OK) {
      return result;
    }
    uint32_t tempSize = 0;
    result = SerializeAdapter::deSerialize(&tempSize, buffer, size, streamEndianness);
    if (result != returnvalue::OK) {
      return result;
    }
    if (this->size != tempSize) {
      return returnvalue::FAILED;
    }
    uint32_t i = 0;
    while ((result == returnvalue::OK) && (i < this->size)) {
      result = SerializeAdapter::deSerialize(&this->entries[i], buffer, size, streamEndianness);
      ++i;
    }
    if (result != returnvalue::OK) {
      return result;
    }
    typename IndexedRingMemoryArray<T>::Iterator cmp(&tempIndex);
    for (typename IndexedRingMemoryArray<T>::Iterator it = this->begin(); it != this->end(); ++it) {
      if (*(cmp.value) == *(it.value)) {
        currentWriteBlock = it;
        return returnvalue::OK;
      }
    }
    // Reached if current write block iterator is not found
    return returnvalue::FAILED;
  }

  uint32_t getIndexAddress() const { return indexAddress; }

  /*
   * Statistics
   */
  uint32_t getStoredPackets() const {
    uint32_t size = 0;
    for (typename IndexedRingMemoryArray<T>::Iterator it = this->begin(); it != this->end(); ++it) {
      size += it->getStoredPackets();
    }
    return size;
  }

  uint32_t getTotalSize() const { return totalSize; }

  uint32_t getCurrentSize() const {
    uint32_t size = 0;
    for (typename IndexedRingMemoryArray<T>::Iterator it = this->begin(); it != this->end(); ++it) {
      size += it->getSize();
    }
    return size;
  }

  bool isEmpty() const { return getCurrentSize() == 0; }

  double getPercentageFilled() const {
    uint32_t filledSize = 0;
    for (typename IndexedRingMemoryArray<T>::Iterator it = this->begin(); it != this->end(); ++it) {
      filledSize += it->getSize();
    }

    return (double)filledSize / (double)this->totalSize;
  }

  typename IndexedRingMemoryArray<T>::Iterator getCurrentWriteBlock() const {
    return currentWriteBlock;
  }
  /**
   * Get the next block of the currentWriteBlock.
   * Returns the first one if currentWriteBlock is the last one
   * @return Iterator pointing to the next block after currentWriteBlock
   */
  typename IndexedRingMemoryArray<T>::Iterator getNextWrite() const {
    typename IndexedRingMemoryArray<T>::Iterator next(currentWriteBlock);
    if ((this->size != 0) && (currentWriteBlock.value == this->back())) {
      next = this->begin();
    } else {
      ++next;
    }
    return next;
  }
  /**
   * Get the block in front of the Iterator
   * Returns the last block if it is the first block
   * @param it iterator which you want the previous block from
   * @return pointing to the block before it
   */
  typename IndexedRingMemoryArray<T>::Iterator getPreviousBlock(
      typename IndexedRingMemoryArray<T>::Iterator it) {
    if (this->begin() == it) {
      typename IndexedRingMemoryArray<T>::Iterator next((this->back()));
      return next;
    }
    typename IndexedRingMemoryArray<T>::Iterator next(it);
    --next;
    return next;
  }

 private:
  // The total size used by the blocks (without index)
  uint32_t totalSize;

  // The address of the index
  const uint32_t indexAddress;

  // The iterators for writing and reading
  typename IndexedRingMemoryArray<T>::Iterator currentWriteBlock;
  typename IndexedRingMemoryArray<T>::Iterator currentReadBlock;

  // How much of the current read block is read already
  uint32_t currentReadSize;

  // Cached Size of current read block
  uint32_t currentReadBlockSizeCached;

  // Last block of current write (should be write block)
  typename IndexedRingMemoryArray<T>::Iterator lastBlockToRead;
  // current size of last Block to read
  uint32_t lastBlockToReadSize;

  // Additional Info to be serialized with the index
  SerializeIF* additionalInfo;

  // Does it overwrite old blocks?
  const bool overwriteOld;
};

#endif /* FRAMEWORK_CONTAINER_INDEXEDRINGMEMORY_H_ */