#include <iostream>
#include <tuple>

using namespace std ;
/*

print any tuple
array 2 tuple

*/



// 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...);
}

template<typename Array, size_t... I>
decltype(auto) array2tuple_impl( const Array& a, integer_sequence<size_t, I...>) {
  return make_tuple(a[I]...);
}

template<typename T, size_t N, typename Indices = make_index_sequence<N>>
decltype(auto) array2tuple(const array<T, N>& a) {
  return array2tuple_impl(a, Indices());
}


// 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>{}   )  ;
}




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;
}