// --------------------------------
// See LICENCE file at project root
// File : meta/utils.hpp
// --------------------------------
#ifndef SCALFMM_META_UTILS_HPP
#define SCALFMM_META_UTILS_HPP

#include <algorithm>
#include <any>
#include <array>
#include <bits/c++config.h>
#include <functional>
#include <iomanip>
#include <iostream>
#include <memory>
#include <tuple>
#include <type_traits>
#include <utility>
#include "scalfmm/meta/traits.hpp"
#include "scalfmm/meta/forward.hpp"

namespace scalfmm::meta
{
    struct noop_t
    {
        template<typename... Types>
        noop_t(const Types&... ts)
        {
        }
    };

    struct noop_f
    {
        template<typename... F>
        noop_f(F... fs)
        {
        }
    };

    template<typename, typename>
    struct cat;

    template<typename... L, typename... R>
    struct cat<std::tuple<L...>, std::tuple<R...>>
    {
        using type = std::tuple<L..., R...>;
    };

    // standart traits and forward declaration
    template<typename T>
    struct tuple_size : std::tuple_size<T>
    {
    };

    template<typename T>
    static constexpr std::size_t tuple_size_v = meta::tuple_size<T>::value;

    template<typename Derived, typename... Containers>
    struct tuple_size<container::variadic_adaptor<Derived, Containers...>>
      : tuple_size<typename container::variadic_adaptor<Derived, Containers...>::base_type>
    {
    };

    template<typename Derived, template<typename U, typename Allocator> class Container, typename... Types>
    struct tuple_size<container::unique_variadic_container<Derived, Container, Types...>>
      : tuple_size<typename container::unique_variadic_container<Derived, Container, Types...>::base_type>
    {
    };

    template<typename Derived, typename... Types>
    struct tuple_size<container::variadic_container<Derived, Types...>>
      : tuple_size<typename container::variadic_container<Derived, Types...>::base_type>
    {
    };

    template<typename Derived, typename Tuple>
    struct tuple_size<container::variadic_container_tuple<Derived, Tuple>>
      : tuple_size<typename container::variadic_container_tuple<Derived, Tuple>::base_type>
    {
    };

    template<typename ValueType, std::size_t Dimension>
    struct tuple_size<scalfmm::container::point_impl<ValueType, Dimension>>
      : tuple_size<typename scalfmm::container::point_impl<ValueType, Dimension>::base_type>
    {
    };

    template<typename ValueType, std::size_t Dimension>
    struct tuple_size<scalfmm::container::point_proxy<ValueType, Dimension>>
      : tuple_size<typename scalfmm::container::point_proxy<ValueType, Dimension>::base_type>
    {
    };

    template<typename ValueType, std::size_t Dimension, typename Enable>
    struct tuple_size<scalfmm::container::point<ValueType, Dimension, Enable>>
      : tuple_size<typename scalfmm::container::point<ValueType, Dimension, Enable>::base_type>
    {
    };

    template<typename PositionType, std::size_t PositionDim, typename InputsType, std::size_t NInputs,
             typename OutputsType, std::size_t MOutputs, typename... Variables>
    struct tuple_size<scalfmm::container::particle<PositionType,PositionDim,InputsType,NInputs,OutputsType,MOutputs,Variables...>>
      : std::integral_constant<std::size_t, PositionDim+NInputs+MOutputs+sizeof...(Variables)>
    {
    };

    template<std::size_t I, typename T>
    inline constexpr auto get(T&& t) noexcept -> auto&&
    {
        return std::get<I>(std::forward<T>(t));
    }

    template<std::size_t I, typename ValueType, std::size_t Dimension, typename Enable>
    inline constexpr auto get(container::point<ValueType, Dimension, Enable> const& p) noexcept -> ValueType const&
    {
        return p.at(I);
    }

    template<std::size_t I, typename ValueType, std::size_t Dimension, typename Enable>
    inline constexpr auto get(container::point<ValueType, Dimension, Enable>& p) noexcept -> ValueType&
    {
        return p.at(I);
    }

    //////////////////////////////////////////////
    template<std::size_t Added, std::size_t... Is>
    inline constexpr auto add_to_sequence(std::index_sequence<Is...> seq)
    {
        return std::index_sequence<(Added + Is)...>{};
    }

    template<typename T, size_t... I>
    inline constexpr auto reverse_impl(T&& t, std::index_sequence<I...> /*unused*/)
      -> std::tuple<typename std::tuple_element<sizeof...(I) - 1 - I, T>::type...>
    {
        return std::make_tuple(meta::get<sizeof...(I) - 1 - I>(std::forward<T>(t))...);
    }

    template<typename T>
    inline constexpr auto reverse(T&& t)
      -> decltype(reverse_impl(std::forward<T>(t), std::make_index_sequence<meta::tuple_size<std::decay_t<T>>::value>()))
    {
        return reverse_impl(std::forward<T>(t), std::make_index_sequence<meta::tuple_size<std::decay_t<T>>::value>());
    }

    // Genrate a tuple of Ts
    template<std::size_t, typename T>
    using type_id = T;

    template<typename T, std::size_t... Is>
    inline constexpr auto generate_tuple(std::index_sequence<Is...> s)
    {
        return std::tuple<type_id<Is, T>...>{};
    }

    template<typename T, std::size_t N>
    inline constexpr auto generate_tuple()
    {
        return generate_tuple<T>(std::make_index_sequence<N>{});
    }

    template<typename T, std::size_t N>
    using generate_tuple_t = decltype(generate_tuple<T, N>());

    template<template<class> class New, typename Tuple, std::size_t... Is>
    inline constexpr auto replace_inner_tuple_type(std::index_sequence<Is...> s)
    {
        return std::tuple<type_id<Is, New<typename std::tuple_element<Is, Tuple>::type>>...>{};
    }

    template<template<class> class New, typename Tuple>
    inline constexpr auto replace_inner_tuple_type()
    {
        return replace_inner_tuple_type<New, Tuple>(std::make_index_sequence<meta::tuple_size_v<Tuple>>{});
    }

    template<template<class> class New, typename Tuple>
    using replace_inner_tuple_type_t = decltype(replace_inner_tuple_type<New, Tuple>());

    template<class Tuple, class T = std::decay_t<std::tuple_element_t<0, std::decay_t<Tuple>>>>
    constexpr inline auto to_array(Tuple t)
    {
        return std::apply([](auto... elems) { return std::array<T, sizeof...(elems)>{elems...}; }, t);
    }

    template<class T, std::size_t N>
    constexpr inline auto to_tuple(std::array<T, N> a)
    {
        return std::apply([](auto... elems) { return std::make_tuple(elems...); }, a);
    }

    template<std::size_t Offset, typename Seq>
    struct offset_sequence;

    template<std::size_t Offset, std::size_t... Ints>
    struct offset_sequence<Offset, std::index_sequence<Ints...>>
    {
        using type = std::index_sequence<Offset + Ints...>;
    };

    template<std::size_t Offset, typename Seq>
    using offset_sequence_t = typename offset_sequence<Offset, Seq>::type;

    template<std::size_t Begin, std::size_t End>
    struct make_range_sequence : public offset_sequence_t<Begin, std::make_index_sequence<End - Begin>>
    {
    };

    template<typename T, std::size_t... Is>
    constexpr inline auto sub_tuple(T&& t, std::index_sequence<Is...> s)
    {
        return std::forward_as_tuple(meta::get<Is>(std::forward<decltype(t)>(t))...);
    }

    template<typename... Args>
    inline auto print(std::ostream& out, Args&&... args)
    {
        ((out << ' ' << std::forward<Args>(args)), ...);
    }

    template<typename... Args>
    inline constexpr auto multiply(Args&... args)
    {
        return (args * ...);
    }

    template<typename... Args>
    inline constexpr auto all(Args... args) -> bool
    {
        return (... && args);
    }

    namespace details
    {
        template<typename T, typename U, std::size_t... Is>
        inline constexpr auto tuple_sum_update(T&& lhs, U&& rhs, std::index_sequence<Is...> s) -> void
        {
            noop_t{((meta::get<Is>(std::forward<T>(lhs)) += meta::get<Is>(std::forward<U>(rhs))), 0)...};
        }

        template<typename T, typename U, std::size_t... Is>
        inline constexpr auto tuple_min_update(T&& lhs, U&& rhs, std::index_sequence<Is...> s) -> void
        {
            noop_t{((meta::get<Is>(std::forward<T>(lhs)) -= meta::get<Is>(std::forward<U>(rhs))), 0)...};
        }

        template<typename F, typename LHS, typename RHS1, typename RHS2, std::size_t... Is>
        inline constexpr auto for_each(std::index_sequence<Is...> s, F&& f, LHS&& lhs, RHS1&& rhs1, RHS2&& rhs2) -> void
        {
            noop_t{(((meta::get<Is>(std::forward<LHS>(lhs)) =
                        std::invoke(std::forward<F>(f), meta::get<Is>(std::forward<RHS1>(rhs1)),
                                    meta::get<Is>(std::forward<RHS2>(rhs2))))),
                    0)...};
        }

        template<typename T, typename U, typename F, std::size_t... Is>
        inline constexpr auto for_each(T&& lhs, U&& rhs, F&& f, std::index_sequence<Is...> s) -> void
        {
            noop_t{((meta::get<Is>(std::forward<T>(lhs)) =
                       std::invoke(std::forward<F>(f), meta::get<Is>(std::forward<U>(rhs)))),
                    0)...};
        }

        template<typename T, typename F, std::size_t... Is>
        inline constexpr auto for_each(T&& t, F&& f, std::index_sequence<Is...> s) -> void
        {
            noop_t{(std::invoke(std::forward<F>(f), meta::get<Is>(std::forward<T>(t))), 0)...};
        }

        template<typename F, typename T0, typename T1, typename T2, typename T3, std::size_t... Is>
        inline constexpr auto repeat(F&& f, T0&& t0, T1&& t1, T2&& t2, T3&& t3, std::index_sequence<Is...> s) -> void
        {
            noop_t{(
              (std::invoke(std::forward<F>(f), meta::get<Is>(std::forward<T0>(t0)), meta::get<Is>(std::forward<T1>(t1)),
                           meta::get<Is>(std::forward<T2>(t2)), meta::get<Is>(std::forward<T3>(t3)))),
              0)...};
        }

        template<typename F, typename T0, typename T1, typename T2, std::size_t... Is>
        inline constexpr auto repeat(F&& f, T0&& t0, T1&& t1, T2&& t2, std::index_sequence<Is...> s) -> void
        {
            noop_t{((std::invoke(std::forward<F>(f), meta::get<Is>(std::forward<T0>(t0)),
                                 meta::get<Is>(std::forward<T1>(t1)), meta::get<Is>(std::forward<T2>(t2)))),
                    0)...};
        }

        template<typename F, typename T0, typename T1, std::size_t... Is>
        inline constexpr auto repeat(F&& f, T0&& t0, T1&& t1, std::index_sequence<Is...> s) -> void
        {
            noop_t{((std::invoke(std::forward<F>(f), meta::get<Is>(std::forward<T0>(t0)),
                                 meta::get<Is>(std::forward<T1>(t1)))),
                    0)...};
        }

        template<typename F, typename T0, std::size_t... Is>
        inline constexpr auto repeat(F&& f, T0&& t0, std::index_sequence<Is...> s) -> void
        {
            noop_t{((std::invoke(std::forward<F>(f), meta::get<Is>(std::forward<T0>(t0)))), 0)...};
        }

        template<typename F, typename T0, typename T1, typename T2, typename T3, std::size_t... Is>
        inline constexpr auto repeat_indexed(F&& f, T0&& t0, T1&& t1, T2&& t2, T3&& t3, std::index_sequence<Is...> s)
          -> void
        {
            noop_t{((std::invoke(std::forward<F>(f), Is, meta::get<Is>(std::forward<T0>(t0)),
                                 meta::get<Is>(std::forward<T1>(t1)), meta::get<Is>(std::forward<T2>(t2)),
                                 meta::get<Is>(std::forward<T3>(t3)))),
                    0)...};
        }

        template<typename F, typename T0, typename T1, typename T2, std::size_t... Is>
        inline constexpr auto repeat_indexed(F&& f, T0&& t0, T1&& t1, T2&& t2, std::index_sequence<Is...> s) -> void
        {
            noop_t{((std::invoke(std::forward<F>(f), Is, meta::get<Is>(std::forward<T0>(t0)),
                                 meta::get<Is>(std::forward<T1>(t1)), meta::get<Is>(std::forward<T2>(t2)))),
                    0)...};
        }

        template<typename F, typename T0, typename T1, std::size_t... Is>
        inline constexpr auto repeat_indexed(F&& f, T0&& t0, T1&& t1, std::index_sequence<Is...> s) -> void
        {
            noop_t{((std::invoke(std::forward<F>(f), Is, meta::get<Is>(std::forward<T0>(t0)),
                                 meta::get<Is>(std::forward<T1>(t1)))),
                    0)...};
        }

        template<typename F, typename T0, std::size_t... Is>
        inline constexpr auto repeat_indexed(F&& f, T0&& t0, std::index_sequence<Is...> s) -> void
        {
            noop_t{((std::invoke(std::forward<F>(f), Is, meta::get<Is>(std::forward<T0>(t0)))), 0)...};
        }

        template<typename T, typename F, std::size_t... Is>
        inline constexpr auto apply(T&& t, F&& f, std::index_sequence<Is...> s)
        {
            return std::make_tuple(std::invoke(std::forward<F>(f), meta::get<Is>(std::forward<T>(t)))...);
        }
    }   // namespace details

    template<typename T, typename U>
    inline constexpr auto tuple_sum_update(T&& lhs, U&& rhs) -> void
    {
        return details::tuple_sum_update(std::forward<T>(lhs), std::forward<U>(rhs),
                                         std::make_index_sequence<meta::tuple_size<std::decay_t<T>>::value>{});
    }

    template<typename T, typename U>
    inline constexpr auto tuple_min_update(T&& lhs, U&& rhs) -> void
    {
        return details::tuple_min_update(std::forward<T>(lhs), std::forward<U>(rhs),
                                         std::make_index_sequence<meta::tuple_size<std::decay_t<T>>::value>{});
    }

    template<typename F, typename LHS, typename RHS1, typename RHS2>
    inline constexpr auto for_each(LHS&& lhs, RHS1&& rhs1, RHS2&& rhs2, F&& f) -> void
    {
        return details::for_each(std::make_index_sequence<meta::tuple_size<std::decay_t<LHS>>::value>{},
                                 std::forward<F>(f), std::forward<LHS>(lhs), std::forward<RHS1>(rhs1),
                                 std::forward<RHS2>(rhs2));
    }

    template<typename T, typename U, typename F>
    inline constexpr auto for_each(T&& lhs, U&& rhs, F&& f) -> void
    {
        return details::for_each(std::forward<T>(lhs), std::forward<U>(rhs), std::forward<F>(f),
                                 std::make_index_sequence<meta::tuple_size<std::decay_t<T>>::value>{});
    }

    template<typename T, typename F>
    inline constexpr auto for_each(T&& tuple, F&& f) -> void
    {
        return details::for_each(std::forward<T>(tuple), std::forward<F>(f),
                                 std::make_index_sequence<meta::tuple_size<std::decay_t<T>>::value>{});
    }

    template<typename F, typename T0, typename T1, typename T2, typename T3>
    inline constexpr auto repeat(F&& f, T0&& t0, T1&& t1, T2&& t2, T3&& t3) -> void
    {
        details::repeat(std::forward<F>(f), std::forward<T0>(t0), std::forward<T1>(t1), std::forward<T2>(t2),
                        std::forward<T3>(t3), std::make_index_sequence<meta::tuple_size<std::decay_t<T0>>::value>{});
    }

    template<typename F, typename T0, typename T1, typename T2>
    inline constexpr auto repeat(F&& f, T0&& t0, T1&& t1, T2&& t2) -> void
    {
        details::repeat(std::forward<F>(f), std::forward<T0>(t0), std::forward<T1>(t1), std::forward<T2>(t2),
                        std::make_index_sequence<meta::tuple_size<std::decay_t<T0>>::value>{});
    }

    template<typename F, typename T0, typename T1>
    inline constexpr auto repeat(F&& f, T0&& t0, T1&& t1) -> void
    {
        details::repeat(std::forward<F>(f), std::forward<T0>(t0), std::forward<T1>(t1),
                        std::make_index_sequence<meta::tuple_size<std::decay_t<T0>>::value>{});
    }

    template<typename F, typename T0>
    inline constexpr auto repeat(F&& f, T0&& t0) -> void
    {
        details::repeat(std::forward<F>(f), std::forward<T0>(t0),
                        std::make_index_sequence<meta::tuple_size<std::decay_t<T0>>::value>{});
    }

    template<typename F, typename T0, typename T1, typename T2, typename T3>
    inline constexpr auto repeat_indexed(F&& f, T0&& t0, T1&& t1, T2&& t2, T3&& t3) -> void
    {
        details::repeat_indexed(std::forward<F>(f), std::forward<T0>(t0), std::forward<T1>(t1), std::forward<T2>(t2),
                                std::forward<T3>(t3),
                                std::make_index_sequence<meta::tuple_size<std::decay_t<T0>>::value>{});
    }

    template<typename F, typename T0, typename T1, typename T2>
    inline constexpr auto repeat_indexed(F&& f, T0&& t0, T1&& t1, T2&& t2) -> void
    {
        details::repeat_indexed(std::forward<F>(f), std::forward<T0>(t0), std::forward<T1>(t1), std::forward<T2>(t2),
                                std::make_index_sequence<meta::tuple_size<std::decay_t<T0>>::value>{});
    }
    template<typename F, typename T0, typename T1>
    inline constexpr auto repeat_indexed(F&& f, T0&& t0, T1&& t1) -> void
    {
        details::repeat_indexed(std::forward<F>(f), std::forward<T0>(t0), std::forward<T1>(t1),
                                std::make_index_sequence<meta::tuple_size<std::decay_t<T0>>::value>{});
    }

    template<typename F, typename T0>
    inline constexpr auto repeat_indexed(F&& f, T0&& t0) -> void
    {
        details::repeat_indexed(std::forward<F>(f), std::forward<T0>(t0),
                                std::make_index_sequence<meta::tuple_size<std::decay_t<T0>>::value>{});
    }

    template<typename T, typename F>
    inline constexpr auto apply(T&& t, F&& f)
    {
        return details::apply(std::forward<T>(t), std::forward<F>(f),
                              std::make_index_sequence<meta::tuple_size<std::decay_t<T>>::value>{});
    }

    template<std::size_t N>
    struct looper
    {
        template<typename F, std::size_t Dimension, typename... Is>
        constexpr inline auto operator()(F&& f, std::array<std::size_t, Dimension> const& stops, Is&... is)
        {
            for(std::size_t i = 0; i < meta::get<N - 1>(stops); ++i)
            {
                looper<N - 1>()(std::forward<F>(f), stops, is..., i);
            }
        }
    };

    template<>
    struct looper<1>
    {
        template<typename F, std::size_t Dimension, typename... Is>
        constexpr inline auto operator()(F&& f, std::array<std::size_t, Dimension> const& stops, Is&... is)
        {
            for(std::size_t i = 0; i < meta::get<0>(stops); ++i)
            {
                f(is..., i);
            }
        }
    };

    template<std::size_t N>
    struct looper_range
    {
        template<typename F, std::size_t Dimension, typename... Is>
        constexpr inline auto operator()(F&& f, std::array<int, Dimension> const& starts,
                                         std::array<int, Dimension> const& stops, Is&... is)
        {
            for(int i = meta::get<N - 1>(starts); i < meta::get<N - 1>(stops); ++i)
            {
                looper_range<N - 1>()(std::forward<F>(f), starts, stops, is..., i);
            }
        }
    };

    template<>
    struct looper_range<1>
    {
        template<typename F, std::size_t Dimension, typename... Is>
        constexpr inline auto operator()(F&& f, std::array<int, Dimension> const& starts,
                                         std::array<int, Dimension> const& stops, Is&... is)
        {
            for(int i = meta::get<0>(starts); i < meta::get<0>(stops); ++i)
            {
                std::invoke(std::forward<F>(f), is..., i);
            }
        }
    };

    template<typename ParticleOrTuple>
    auto inline as_tuple(ParticleOrTuple&& p)
    {
        if constexpr(is_particle_v<std::decay_t<ParticleOrTuple>>)
        {
            return std::forward<ParticleOrTuple>(p).as_tuple();
        }
        else if constexpr(is_tuple_v<std::decay_t<ParticleOrTuple>>)
        {
            return std::forward<ParticleOrTuple>(p);
        }
    }
}   // namespace scalfmm::meta
#endif   // SCALFMM_META_UTILS_HPP