/*
(c) Copyright, Real-Time Innovations, 2018.
All rights reserved.

No duplications, whole or partial, manual or electronic, may be made
without express written permission.  Any such copies, or
revisions thereof, must display this notice unaltered.
This code contains trade secrets of Real-Time Innovations, Inc.
*/

#ifndef RTI_DDS_FLAT_SEQUENCEOFFSETS_HPP_
#define RTI_DDS_FLAT_SEQUENCEOFFSETS_HPP_

#include "rti/flat/Offset.hpp"
#include "rti/flat/SequenceIterator.hpp"

namespace rti { namespace flat {

/**
 * @ingroup RTIFlatOffsetsModule
 * @brief Base class for Offsets to sequences and arrays of primitive types
 *
 * @tparam T The primitive type
 *
 */
template <typename T>
class AbstractPrimitiveList : public OffsetBase {
public:
    typedef T value_type;

protected:
    AbstractPrimitiveList()
    {
    }

    AbstractPrimitiveList(
            rti::flat::SampleBase *sample,
            offset_t offset,
            offset_t sequence_size)
        : OffsetBase(sample, offset, sequence_size)
    {
    }

public:

    bool is_cpp_compatible() const
    {
        RTI_FLAT_OFFSET_CHECK_NOT_NULL(return false);
        return sizeof(T) == 1 || !stream_.needs_byte_swap();
    }


    /*@private
     * @brief Gets direct access to the elements
     *
     * Returns a pointer to the elements of this sequence.
     *
     * @note If the Sample that contains this PrimitiveSequenceOffset has an endianess
     * different from the native one, the element bytes may be swapped. This can
     * happen if this Sample was published by a DataWriter running on a platform
     * with a different endianess and received by a DataReader running locally.
     *
     * This function is not for public use. See rti::flat::plain_cast() instead.
     */
    T * get_elements()
    {
        return reinterpret_cast<T*>(this->get_buffer());
    }

    /*@private
     * @brief Gets direct access to the array elements
     *
     * (Const overload)
     */
    const T * get_elements() const
    {
        return reinterpret_cast<const T*>(this->get_buffer());
    }

    /**
     * @brief Returns an element by index
     *
     * @param i The zero-based index of the element
     *
     * @see rti::flat::plain_cast() for a method to access all the elements at
     * once
     */
    T get_element(unsigned int i) const
    {
        // OffsetBase::serialize only checks this as a debug assertion; in
        // a sequence or array we need to do it in release mode too
        if (!stream_.check_size((i + 1) * ((unsigned int) sizeof(T)))) {
            return T();
        }

        return OffsetBase::template deserialize<T>(i * (unsigned int) sizeof(T));
    }

    /**
     * @brief Sets an element by index
     *
     * @param i The zero-based index of the element to set
     * @param value The value to set
     *
     * @return true if it was possible to set the element, or false if this
     * collection has less than i - 1 elements.
     *
     * @see rti::flat::plain_cast() for a method to access all the elements at
     * once
     */
    bool set_element(unsigned int i, T value)
    {
        // OffsetBase::serialize only checks this as a debug assertion; in
        // a sequence or array we need to do it in release mode too
        if (!stream_.check_size((i + 1) * static_cast<unsigned int>(sizeof(T)))) {
            return false;
        }

        return OffsetBase::serialize(i * static_cast<unsigned int>(sizeof(T)), value);
    }
};

namespace detail {

template <typename T>
struct PrimitiveSequenceOffsetHelper;

template <typename T, typename Enable = void>
struct primitive_sequence_header_length {
    static size_t value()
    {
        return sizeof(rti::xcdr::length_t);
    }
};

} // namespace detail

/**
 * @ingroup RTIFlatOffsetsModule
 * @brief Offset to a sequence of primitive elements
 *
 * @tparam T The primitive type
 *
 */
template <typename T>
class PrimitiveSequenceOffset : public AbstractPrimitiveList<T> {
public:
    typedef variable_size_type_tag_t offset_kind;
    typedef detail::PrimitiveSequenceOffsetHelper<T> Helper;

    PrimitiveSequenceOffset() : element_count_(0)
    {
    }

    PrimitiveSequenceOffset(
            rti::flat::SampleBase *sample,
            offset_t offset,
            offset_t serialized_size)
        : AbstractPrimitiveList<T>(
                // passing NULL causes the base constructors to fail
                serialized_size >= static_cast<offset_t>(header_length()) ? sample : NULL,
                offset + static_cast<offset_t>(header_length()),
                serialized_size - static_cast<offset_t>(header_length())),
        element_count_(0)
    {
#ifdef RTI_FLAT_DATA_NO_EXCEPTIONS
        if (!this->is_null()) { // without exceptions, we need to check if the base ctor failed
#endif
        rti::xcdr::Stream::Memento stream_memento(this->stream_);
        this->stream_.skip_back(sizeof(rti::xcdr::length_t));
        element_count_ = this->stream_.template deserialize_fast<rti::xcdr::length_t>();
#ifdef RTI_FLAT_DATA_NO_EXCEPTIONS
        }
#endif

    }

    /**
     * @brief Returns the number of elements
     */
    unsigned int element_count() const
    {
        RTI_FLAT_OFFSET_CHECK_NOT_NULL(return 0);

        return element_count_;
    }

private:
    static size_t header_length()
    {
        return detail::primitive_sequence_header_length<T>::value();
    }

    unsigned int element_count_;

};

namespace detail {

template <typename T>
struct PrimitiveSequenceOffsetHelper {
    static offset_t calculate_serialized_size(
            rti::flat::SampleBase *sample,
            offset_t absolute_offset,
            offset_t max_size)
    {
        RTI_FLAT_ASSERT(sample != NULL, return 0);
        RTI_FLAT_ASSERT(max_size > sizeof(rti::xcdr::length_t), return 0);

        PrimitiveSequenceOffset<T> tmp(sample, absolute_offset, max_size);

        // elements + header
        if ((RTIXCdrUnsignedLong_MAX
                - static_cast<unsigned int>(sizeof(rti::xcdr::length_t)))
                / static_cast<unsigned int>(sizeof(T))
                < tmp.element_count()) {
            RTI_FLAT_OFFSET_PRECONDITION_ERROR(
                    "Serialized size of a sequence of primitive elements "
                    "exceeds maximum representable 32-bit unsigned integer.",
                    return 0);
        }
        return (tmp.element_count() * static_cast<unsigned int>(sizeof(T)))
                + static_cast<unsigned int>(sizeof(rti::xcdr::length_t));
    }
};

} // namespace detail

/**
 * @ingroup RTIFlatOffsetsModule
 * @brief Offset to an array of primitive elements
 *
 * @tparam T The primitive type
 * @tparam N The array bound. For multidimensional arrays, \p N is the product
 * of each dimension bound.
 *
 * A PrimitiveArrayOffset may meet the requirements to be cast to an array of
 * the equivalent plain C++ element type (see rti::flat::plain_cast()).
 */
template <typename T, unsigned int N>
class PrimitiveArrayOffset : public AbstractPrimitiveList<T> {
public:
    typedef fixed_size_type_tag_t offset_kind;

    PrimitiveArrayOffset()
    {
    }

    PrimitiveArrayOffset(rti::flat::SampleBase *sample, offset_t offset)
        : AbstractPrimitiveList<T>(
                sample,
                offset + static_cast<offset_t>(header_length()),
                serialized_size(0))
    {
    }

public:

    /**
     * @brief Returns the number of elements, \p N
     *
     */
    unsigned int element_count() const
    {
        return N;
    }

    static offset_t serialized_size(offset_t)
    {
        return sizeof(T) * N;
    }

private:
    static size_t header_length()
    {
        return detail::primitive_sequence_header_length<T>::value()
                - sizeof(rti::xcdr::length_t);
    }
};

// Note: the modern C++ API defines a PrimitiveArrayOffset specializations for
// safe_enum and wchar_t

struct StringOffsetHelper;

/**
 * @ingroup RTIFlatOffsetsModule
 * @brief Offset to a string
 *
 */
class StringOffset : public PrimitiveSequenceOffset<char> {
public:
    typedef variable_size_type_tag_t offset_kind;
    typedef StringOffsetHelper Helper;

    StringOffset()
    {
    }

    StringOffset(
            SampleBase *sample,
            offset_t absolute_offset,
            offset_t serialized_size)
        : PrimitiveSequenceOffset<char>(
                sample,
                absolute_offset,
                serialized_size)
    {
    }

    /**
     * @brief Gets the string
     *
     * The string returned can be modified as long as its size doesn't change.
     */
    char * get_string()
    {
        return reinterpret_cast<char*>(this->get_buffer());
    }

    /**
     * @brief Gets the string (const)
     *
     */
    const char * get_string() const
    {
        return reinterpret_cast<const char*>(this->get_buffer());
    }

    /**
     * @brief Returns the number of characters
     *
     * This number doesn't include the null terminating character.
     */
    unsigned int element_count() const
    {
        RTI_FLAT_CHECK_PRECONDITION(
                PrimitiveSequenceOffset<char>::element_count() > 0,
                return 0);

        return PrimitiveSequenceOffset<char>::element_count() - 1;
    }
};

struct StringOffsetHelper {
    static offset_t calculate_serialized_size(
            rti::flat::SampleBase *sample,
            offset_t absolute_offset,
            offset_t max_size)
    {
        StringOffset tmp(sample, absolute_offset, max_size);
        return tmp.element_count()
            + 1 // null terminator
            + (unsigned int) sizeof(rti::xcdr::length_t); // length header
    }
};

// Wide strings are treated as a sequence of octets
typedef PrimitiveSequenceOffset<unsigned char> WStringOffset;

// The base class of SequenceOffset, and FinalAlignedArrayOffset
//
// This encapsulates the functionality that allows iterating through a list
// of elements (a sequence or an array). The list must be always aligned to 4
// (that excludes FinalArrayOffset)
//
/**
 * @ingroup RTIFlatOffsetsModule
 * @brief Base class of Offsets to sequences and arrays of non-primitive members
 *
 * @tparam ElementOffset The Offset type of the elements
 */
template <typename ElementOffset>
class AbstractAlignedList : public OffsetBase {
public:

    /**
     * @brief The iterator type, SequenceIterator
     */
    typedef SequenceIterator<ElementOffset, typename ElementOffset::offset_kind>
            iterator;

protected:
    AbstractAlignedList()
    {
    }

    AbstractAlignedList(
            rti::flat::SampleBase *sample,
            offset_t offset,
            offset_t sequence_size)
        : OffsetBase(
                sample,
                offset,
                sequence_size)
    {
    }

public:
    bool is_cpp_compatible() const // override
    {
        RTI_FLAT_OFFSET_CHECK_NOT_NULL(return false);
        return !stream_.needs_byte_swap()
                && rti::xcdr::has_cpp_friendly_cdr_layout_collection<
                        typename rti::flat::flat_type_traits<ElementOffset>::flat_type>();
    }

    ElementOffset get_element(unsigned int i)
    {
        RTI_FLAT_OFFSET_CHECK_NOT_NULL(return ElementOffset());

        return get_element_impl<ElementOffset>(
                i,
                typename ElementOffset::offset_kind());
    }

    /**
     * @brief Gets an iterator to the first Offset
     *
     * begin() and end() enable the use of range-for loops, for example:
     * \code
     * SequenceOffset<MyFlatMutableOffset> sequence_offset = my_type_offset.my_sequence();
     * for (auto element : sequence_offset) {
     *     std::cout << element.x() << std::endl;
     * }
     * \endcode
     *
     */
    iterator begin()
    {
        RTI_FLAT_OFFSET_CHECK_NOT_NULL(return iterator(NULL, 0, 0));

        return iterator(
                sample_,
                absolute_offset_,
                absolute_offset_ + get_buffer_size());
    }

    /**
     * @brief Gets an iterator to the past-the-end element
     */
    iterator end()
    {
        RTI_FLAT_OFFSET_CHECK_NOT_NULL(return iterator(NULL, 0, 0));

        return iterator(
                sample_,
                absolute_offset_ + get_buffer_size(),
                absolute_offset_ + get_buffer_size());
    }

private:
    // for variable size types we skip element by element
    template <typename E>
    E get_element_impl(unsigned int i, variable_size_type_tag_t)
    {
        iterator it = begin();
        while (it != end() && i > 0) {
            if (!it.advance()) {
                return E();
            }
            i--;
        }

        return *it;
    }

    // for fixed-size types we support random access
    template <typename E>
    E get_element_impl(unsigned int i, fixed_size_type_tag_t)
    {
        offset_t size = i * E::serialized_size_w_padding();

        // Ensure that the stream has space for i + 1 elements
        if (!stream_.check_size(size + E::serialized_size(0))) {
            return E();
        }

        return E(this->sample_, this->absolute_offset_ + size);
    }
};

template <typename ElementOffset>
struct SequenceOffsetHelper;

/**
 * @ingroup RTIFlatOffsetsModule
 * @brief Offset to a sequence of non-primitive elements
 *
 * @tparam ElementOffset The Offset type, for example MyFlatMutableOffset,
 * MyFlatFinalOffset, or StringOffset.
 *
 * Represents an Offset to a sequence member and allows getting an Offset to
 * each of its elements.
 *
 * A SequenceOffset may meet the requirements to be cast to an array of
 * the equivalent plain C++ element type (see rti::flat::plain_cast), if the
 * \p ElementOffset is a final type.
 */
template <typename ElementOffset>
class SequenceOffset : public AbstractAlignedList<ElementOffset> {
public:
    typedef variable_size_type_tag_t offset_kind;
    typedef SequenceOffsetHelper<ElementOffset> Helper;

    SequenceOffset() : element_count_(0)
    {
    }

    SequenceOffset(
            rti::flat::SampleBase *sample,
            offset_t offset,
            offset_t sequence_size)
            : AbstractAlignedList<ElementOffset>(
                    // Member size in bytes must be > 4, otherwise let base ctor
                    // fail
                    sequence_size >= header_length() ? sample : NULL,
                    // The offset begins after any padding to align to 4;
                    // padding may be needed for example for an array of
                    // sequence of final types; the end position of the previous
                    // sequence may not be aligned
                    RTIXCdrAlignment_alignSizeUp(
                            offset,
                            RTI_XCDR_SEQ_LENGTH_ALIGNMENT)
                            + header_length(),
                    sequence_size - header_length()),
              element_count_(0)
    {
#ifdef RTI_FLAT_DATA_NO_EXCEPTIONS
        if (!this->is_null()) { // without exceptions, we need to check if the base ctor failed
#endif
        rti::xcdr::Stream::Memento stream_memento(this->stream_);
        this->stream_.skip_back(sizeof(rti::xcdr::length_t));
        element_count_ = this->stream_.template deserialize_fast<rti::xcdr::length_t>();
#ifdef RTI_FLAT_DATA_NO_EXCEPTIONS
        }
#endif
    }

    /**
     * @brief Gets the Offset to an element
     *
     * @param i The zero-based index to the element
     * @return The Offset to the element in the i-th position
     */
    ElementOffset get_element(unsigned int i)
    {
        RTI_FLAT_OFFSET_CHECK_NOT_NULL(return ElementOffset());

        if (i >= element_count_) {
            return ElementOffset();
        }
        return AbstractAlignedList<ElementOffset>::get_element(i);
    }

    /**
     * @brief The number of elements
     */
    unsigned int element_count() const
    {
        RTI_FLAT_OFFSET_CHECK_NOT_NULL(return 0);

        return element_count_;
    }

private:
    static offset_t header_length()
    {
        return static_cast<offset_t>(
                detail::collection_dheader_traits<false>::dheader_size()
                + sizeof(rti::xcdr::length_t));
    }


    unsigned int element_count_;
};

template <typename E>
struct SequenceOffsetHelper {
    // Calculates the serialized size of a Sequence by skipping each element
    static offset_t calculate_serialized_size(
            rti::flat::SampleBase *sample,
            offset_t absolute_offset,
            offset_t max_offset)
    {
        // Create a SequenceOffset beginning at sample + absolute_offset,
        // with a size we don't know, but no greater than
        // max_offset - absolute_offset
        SequenceOffset<E> tmp(
                sample,
                absolute_offset,
                max_offset - absolute_offset);
        unsigned int count = tmp.element_count();
        typename SequenceOffset<E>::iterator it = tmp.begin();
        for (unsigned int i = 0; i < count; i++) {
            if (!it.advance()) {
                return 0; // error
            }
        }

        return detail::ptrdiff(it.get_position(), sample->get_buffer())
                - absolute_offset;
    }
};

/**
 * @ingroup RTIFlatOffsetsModule
 * @brief Offset to an array of variable-size elements
 *
 * @tparam ElementOffset An Offset for a type of variable size, such as a
 * mutable struct (MyFlatMutableOffset), union, or StringOffset.
 * @tparam N The array bound. For multidimensional arrays, \p N is the product
 * of each dimension bound.
 *
 * Represents an Offset to an array member and allows getting an Offset to
 * each of its elements.
 *
 * @see FinalArrayOffset encapsulates arrays of fixed-size elements
 */
template <typename ElementOffset, unsigned int N>
class MutableArrayOffset : public AbstractAlignedList<ElementOffset> {
public:
    typedef variable_size_type_tag_t offset_kind;

    MutableArrayOffset()
    {
    }

    MutableArrayOffset(
            rti::flat::SampleBase *sample,
            offset_t offset,
            offset_t sequence_size)
            : AbstractAlignedList<ElementOffset>(
                    sequence_size >= header_length() ? sample : NULL,
                    offset + header_length(),
                    sequence_size - header_length())
    {
    }

    /**
     * @brief Gets the Offset to an element
     *
     * @param i The zero-based index to the element
     * @return The Offset to the element in the i-th position
     */
    ElementOffset get_element(unsigned int i)
    {
        if (i >= N) {
            return ElementOffset();
        }

        return AbstractAlignedList<ElementOffset>::get_element(i);
    }

private:
    static offset_t header_length()
    {
        return static_cast<offset_t>(
                detail::collection_dheader_traits<false>::dheader_size());
    }
};

/**
 * @ingroup RTIFlatOffsetsModule
 * @brief Offset to an array of final elements
 *
 * @tparam ElementOffset A final struct Offset, such as MyFlatFinalOffset.
 * @tparam N The array bound. For multidimensional arrays, \p N is the product
 * of each dimension bound.
 *
 * Represents an Offset to an array member and allows getting an Offset to
 * each of its elements.
 *
 * FinalArrayOffset and FinalAlignedArrayOffset provide the same
 * interface, but have different implementation details. FinalArrayOffset is
 * used when the array member is part of a final type too, whereas
 * FinalAlignedArrayOffset corresponds to an array inside a mutable type.
 *
 * A FinalArrayOffset may meet the requirements to be cast to an array of
 * the equivalent plain C++ element type (see rti::flat::plain_cast()).
 */
template <typename ElementOffset, unsigned int N>
class FinalArrayOffset : public OffsetBase {
public:
    typedef fixed_size_type_tag_t offset_kind;

    FinalArrayOffset()
    {
    }

    // Constructor used when this array is part of a fixed-size type, and
    // therefore it's initial alignment is not known ahead of time
    FinalArrayOffset(
        rti::flat::SampleBase *sample,
        offset_t absolute_offset,
        offset_t first_element_size,
        offset_t element_size)
        : OffsetBase(
                sample,
                absolute_offset,
                first_element_size + element_size * (N - 1)),
          first_element_size_(first_element_size),
          element_size_(element_size)
    {
    }

    /**
     * @brief Gets the Offset to an element
     *
     * @param i The zero-based index to the element
     * @return The Offset to the element in the i-th position
     */
    ElementOffset get_element(unsigned int i)
    {
        RTI_FLAT_OFFSET_CHECK_NOT_NULL(return ElementOffset());

        if (i >= N) {
            return ElementOffset(); // null offset
        }

        offset_t element_offset = this->absolute_offset_;
        if (i > 0) {
            element_offset += this->first_element_size_
                + (i - 1) * this->element_size_;
        }

        return ElementOffset(this->sample_, element_offset);
    }

private:
    offset_t first_element_size_;
    offset_t element_size_;
};

/**
 * @ingroup RTIFlatOffsetsModule
 * @brief Offset to an array of final elements
 *
 * @tparam ElementOffset A final struct Offset, such as MyFlatFinalOffset.
 * @tparam N The array bound. For multidimensional arrays, \p N is the product
 * of each dimension bound.
 *
 * Represents an Offset to an array member and allows getting an Offset to
 * each of its elements.
 *
 * The following code shows how to use a FinalAlignedArrayOffset to initialize
 * an array member with MyFlatMutableBuilder:
 *
 * \code
 *  MyFlatMutableBuilder builder = rti::flat::build_data(writer);
 *  auto array_offset = builder.add_my_final_array();
 *  for (MyFlatFinalOffset element_offset : array_offset) {
 *      element_offset.my_primitive(3);
 *      // ...
 *  }
 *
 *  // Or access an element directly:
 *  auto element_offset = array_offset.get_element(3);
 *  element_offset.my_primitive(3);
 * \endcode
 *
 * A more efficient way to access a final array, provided it complies with
 * the required preconditions, is through rti::flat::plain_cast().
 *
 * FinalArrayOffset and FinalAlignedArrayOffset provide the same
 * interface, but have different implementation details. FinalArrayOffset is
 * used when the array member is part of a final type too, whereas
 * FinalAlignedArrayOffset corresponds to an array inside a mutable type.
 *
 * A FinalAlignedArrayOffset may meet the requirements to be cast to an array of
 * the equivalent plain C++ element type (see rti::flat::plain_cast()).
 *
 * @see MutableArrayOffset encapsulates arrays of variable-size elements
 */
template <typename ElementOffset, unsigned int N>
class FinalAlignedArrayOffset : public AbstractAlignedList<ElementOffset> {
public:
    typedef fixed_size_type_tag_t offset_kind;

    FinalAlignedArrayOffset()
    {
    }

    // Constructor used when this array is part of a mutable type, and
    // therefore it's aligned to 4 always
    FinalAlignedArrayOffset(
            rti::flat::SampleBase *sample,
            offset_t absolute_offset)
            : AbstractAlignedList<ElementOffset>(
                    sample,
                    absolute_offset
                            + detail::collection_dheader_traits<
                                    false>::dheader_size(),
                    serialized_size(0))
    { }

    // serialized_size() only works when this array is part of a mutable type
    // and we know it's aligned to 4
    static offset_t serialized_size(offset_t)
    {
        // [element1][pad][element2][pad]...[elementN]
        return ElementOffset::serialized_size_w_padding() * (N - 1)
                + ElementOffset::serialized_size(0);
    }

    /**
     * @brief Gets the Offset to an element
     *
     * @param i The zero-based index to the element
     * @return The Offset to the element in the i-th position
     *
     * @see rti::flat::plain_cast() for a method to access all the elements at
     * once
     */
    ElementOffset get_element(unsigned int i)
    {
        RTI_FLAT_OFFSET_CHECK_NOT_NULL(return ElementOffset());

        if (i >= N) {
            return ElementOffset();
        }

        return AbstractAlignedList<ElementOffset>::get_element(i);
    }
};

namespace detail {

// Arrays of complex elements may need a DHEADER
template <typename T, unsigned int N>
struct is_fixed_type_w_dheader<FinalAlignedArrayOffset<T, N> > {
    static bool value()
    {
        return is_dheader_required_in_non_primitive_collections();
    }
};


} // namespace detail

}}  // namespace rti::flat

#endif // RTI_DDS_FLAT_SEQUENCEOFFSETS_HPP_