#include <array>
#include <tuple>
#include <utility>
#include <iostream>

using namespace std ;

// 1. Base Case: Called when only one argument is left
template <typename T>
T print_all(T last) {
    cout << last << endl;
    return last;
}

// 2. Recursive Case: Unpacks the first item and passes the rest forward
template <typename First, typename... Rest>
void print_all(First first, Rest... rest) {
    cout << first << ", ";

    // Recursive call with the remaining parameter pack
    print_all(rest...);
}

// Helper to unpack the tuple
template<typename Tuple, size_t... Is>
void unpack_helper(const Tuple& t, index_sequence<Is...> object1 )
{
    print_all(   get<Is>(t)...  ) ;
}

template<typename Tuple>
void unpack_and_print( const Tuple& tupleObject )
{
    // Generate indices based on the size of the tuple
    constexpr auto size = tuple_size_v<Tuple>   ;
       //creates a sort of list of numbers up to the size of the tuple
	   //auto indexSequenceObject1 = make_index_sequence<sizeOfMyTuple>{}  ;
	   //index_sequence<Is...>

    unpack_helper( tupleObject, make_index_sequence<size>{}   )  ;
}




// Helper for the recursive step
template <typename T, std::size_t N, std::size_t Index = 0, typename... Ts>
constexpr auto array_to_tuple_impl(const std::array<T, N>& arr, Ts&&... args) {
    if constexpr (Index == N) {
        return std::make_tuple(std::forward<Ts>(args)...);
    } else {
        return array_to_tuple_impl<T, N, Index + 1>(
            arr, std::forward<Ts>(args)..., arr[Index]
        );
    }
}

// Entry point function
template <typename T, std::size_t N>
constexpr auto array2tuple(const std::array<T, N>& arr) {
    return array_to_tuple_impl(arr);
}

int main()
{

      std::array<int, 3> arr1 = { 10, 2, 5 }  ;
      auto tupleFromArray =  array2tuple( arr1 ) ;
      cout << get<0>(tupleFromArray)  << endl ;
      cout << get<1>(tupleFromArray)  << endl ;
      cout << "-----" << endl ;
      unpack_and_print( tupleFromArray ) ;


      return 0;
}