#ifndef FBASIC_PARTICLE_HPP
#define FBASIC_PARTICLE_HPP

#include "Utils/FIntegerSequence.hpp"
#include "Utils/FPoint.hpp"
#include "Utils/FTypePack.hpp"


template<typename _FReal, std::size_t _Dim = 3, typename... Types>
class FBasicParticle : public scalfmm::pack_expand_tuple< scalfmm::pack<_Dim, _FReal>, Types... >{

public:
    /// Storage class : std::tuple<FReal,...(Dim times), Types...>
    using data_t = scalfmm::
        pack_expand_tuple< scalfmm::pack<_Dim, _FReal>, Types... >;

    using types_tuple_t = scalfmm::
        pack_expand_tuple< Types... >;

    /// Space dimensions
    constexpr static std::size_t Dim = _Dim;
    /// Size of #data_t tuple
    constexpr static std::size_t NbAttributes = std::tuple_size<data_t>::value - Dim;

    /// Floating point type
    using FReal = _FReal;
    /// #data_t alias, required by the FVariadicParticleContainer
    using attribute_tuple_t = data_t;
    /// Position type, required by the FVariadicParticleContainer
    using position_t = FPoint<FReal, Dim>;

    /// Default constructor
    FBasicParticle() = default;
    /// Default copy constructor
    FBasicParticle(const FBasicParticle&) = default;
    /// Default copy operator
    FBasicParticle& operator=(const FBasicParticle&) = default;
    /// Default move constructor
    FBasicParticle(FBasicParticle&&) = default;
    /// Default move operator
    FBasicParticle& operator=(FBasicParticle&&) = default;

    /// Constructor from position and types
    template<typename... Ts>
    FBasicParticle(const position_t& pos, Ts&&... ts) :
        FBasicParticle(std::make_index_sequence<Dim>(),
                       std::make_index_sequence<std::tuple_size<data_t>::value-sizeof...(ts)-Dim>(),
                       pos,
                       std::forward<Ts>(ts)...
            )
    {}

    /// Constructor from tuple equivalent to #data_t
    template<typename... Ts>
    FBasicParticle(const std::tuple<Ts...>& ts) :
        data_t(ts)
    {}

    /** \brief Position getter
     *
     * The position is stored in the #_data tuple, to extract it we need to
     * recreate a position_t object. This is done by the position_impl() method.
     *
     * \return A new position_t object
     */
    position_t position() const {
        return position_impl(std::make_index_sequence<Dim>());
    }

    void setPosition(const position_t& pos) {
        return setPosition_impl(pos, std::make_index_sequence<Dim>());
    }

    types_tuple_t attributes() const {
        return attributes_impl(
            std::make_index_sequence<std::tuple_size<types_tuple_t>::value>(),
            types_tuple_t()
            );
    }

    data_t& data() {
        return *this;
    }

    const data_t& data() const {
        return *this;
    }

    template<std::size_t I>
    auto get() -> decltype(std::get<I>(this->data())) {
        return std::get<I>(this->data());
    }


    template<std::size_t I>
    auto get() const -> decltype(std::get<I>(this->data())) {
        return std::get<I>(this->data());
    }

    friend bool operator==(const FBasicParticle& lhs, const FBasicParticle& rhs) {
        return lhs.data() == rhs.data();
    }

private:
    template<typename... Ts, std::size_t... Is, std::size_t... Js>
    FBasicParticle(std::index_sequence<Is...>, std::index_sequence<Js...>,
                   const FPoint<FReal, Dim>& pos, Ts&&... ts) :
        data_t(pos[Is]..., std::forward<Ts>(ts)...,
               typename std::tuple_element<Dim+Js+sizeof...(ts), data_t>::type(0)...)
    {
        //static_assert(sizeof...(Ts) == NbAttributes, "Parameter count is incorrect");
    }

    template<std::size_t... Is>
    position_t position_impl(std::index_sequence<Is...>) const{
        return position_t(std::get<Is>(this->data())...);
    }

    template<std::size_t... Is>
    void setPosition_impl(const position_t& pos, std::index_sequence<Is...>) {
        auto l = {std::get<Is>(this->data()) = pos[Is] ...};
        (void)l;
    }


    template<std::size_t... Is, typename... Attributes>
    std::tuple<Attributes...> attributes_impl(std::index_sequence<Is...>,
                                         std::tuple<Attributes...>)
        const
    {
        return std::tuple<Attributes...>(std::get<Is+Dim>(this->data())...);
    }

};

template<std::size_t I, typename FReal, std::size_t Dim , typename... Types>
auto get(FBasicParticle<FReal, Dim, Types...>& particle)
    -> decltype(particle.template get<I>())
{
    auto& res = particle.template get<I>();
    return res;
}


template<std::size_t I, typename FReal, std::size_t Dim , typename... Types>
auto get(const FBasicParticle<FReal, Dim, Types...>& particle)
    -> decltype(particle.template get<I>())
{
    return particle.template get<I>();
}


#endif /* FBASIC_PARTICLE_HPP */