// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
// All rights not expressly granted are reserved.
//
// This software is distributed under the terms of the GNU General Public
// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
//
// In applying this license CERN does not waive the privileges and immunities
// granted to it by virtue of its status as an Intergovernmental Organization
// or submit itself to any jurisdiction.

/// @file   StaticSequenceAllocator.h
/// @author Matthias Richter, based on work by Mikolaj Krzewicki
/// @since  2017-09-21
/// @brief  An allocator for static sequences of object types

namespace o2
{
namespace algorithm
{

/**
 * Helper struct to define a composite element from a header, some payload
 * and a trailer
 */
template <typename HeaderT, typename TrailerT = void>
struct Composite {
  using HeaderType = HeaderT;
  using TrailerType = TrailerT;
  size_t compositeLength = 0;
  size_t trailerLength = 0;
  size_t dataLength = 0;

  template <size_t N,
            typename U = TrailerType>
  constexpr Composite(const HeaderType h, const char (&d)[N],
                      typename std::conditional<!std::is_void<U>::value, const TrailerType, int>::type t,
                      typename std::enable_if<!std::is_void<U>::value>::type* = nullptr)
    : header(h), data(d), trailer(t)
  {
    dataLength = N;
    trailerLength = sizeof(TrailerType);
    compositeLength = sizeof(HeaderType) + dataLength + trailerLength;
  }

  template <size_t N,
            typename U = TrailerType>
  constexpr Composite(const HeaderType& h, const char (&d)[N],
                      typename std::enable_if<std::is_void<U>::value>::type* = nullptr)
    : header(h), data(d)
  {
    dataLength = N;
    trailerLength = 0;
    compositeLength = sizeof(HeaderType) + dataLength + trailerLength;
  }

  constexpr size_t getLength() const noexcept
  {
    return compositeLength;
  }

  constexpr size_t getDataLength() const noexcept
  {
    return dataLength;
  }

  template <typename BufferT>
  constexpr size_t insert(BufferT* buffer) const noexcept
  {
    static_assert(sizeof(BufferT) == 1, "buffer required to be of byte-type");
    size_t length = 0;
    memcpy(buffer + length, &header, sizeof(HeaderType));
    length += sizeof(HeaderType);
    memcpy(buffer + length, data, dataLength);
    length += dataLength;
    if (trailerLength > 0) {
      memcpy(buffer + length, &trailer, trailerLength);
      length += trailerLength;
    }
    return length;
  }

  const HeaderType header;
  const char* data = nullptr;
  typename std::conditional<!std::is_void<TrailerType>::value, const TrailerType, int>::type trailer;
};

/// recursively calculate the length of the sequence
/// object types are fixed at compile time and so is the total length of the
/// sequence. The function is recursively invoked for all arguments of the
// variable list
template <typename T, typename... TArgs>
constexpr size_t sequenceLength(const T& first, const TArgs... args) noexcept
{
  return sequenceLength(first) + sequenceLength(args...);
}

/// template secialization of sequence length calculation for one argument,
/// this is also the terminating instance for the last argument of the recursive
/// invocation of the function template.
template <typename T>
constexpr size_t sequenceLength(const T& first) noexcept
{
  return first.getLength();
}

/// recursive insert of variable number of objects
template <typename BufferT, typename T, typename... TArgs>
constexpr size_t sequenceInsert(BufferT* buffer, const T& first, const TArgs... args) noexcept
{
  static_assert(sizeof(BufferT) == 1, "buffer required to be of byte-type");
  auto length = sequenceInsert(buffer, first);
  length += sequenceInsert(buffer + length, args...);
  return length;
}

/// terminating template specialization, i.e. for the last element
template <typename BufferT, typename T>
constexpr size_t sequenceInsert(BufferT* buffer, const T& element) noexcept
{
  // TODO: make a general algorithm, at the moment this serves the
  // Composite class as a special case
  return element.insert(buffer);
}

/**
 * Allocator for a buffer of a static sequence of multiple objects.
 *
 * The sequence of object types is fixed at compile time and given as
 * a variable list of arguments to the constructor. The data of the objects
 * is runtime dependent.
 *
 * TODO: probably the Composite struct needs to be reworked to allow this
 * allocator to be more general
 */
struct StaticSequenceAllocator {
  using value_type = unsigned char;
  using BufferType = std::unique_ptr<value_type[]>;

  BufferType buffer;
  size_t bufferSize;

  size_t size() const { return bufferSize; }

  StaticSequenceAllocator() = delete;

  template <typename... Targs>
  StaticSequenceAllocator(Targs... args)
  {
    bufferSize = sequenceLength(args...);
    buffer = std::make_unique<value_type[]>(bufferSize);
    sequenceInsert(buffer.get(), args...);
  }
};

} // namespace algorithm
} // namespace o2