#include <iostream>
#include <string>
#include <memory>

/*template < class ... args >
std::size_t find_size();

template < class arg1, args ... >
std::size
*/

template < class ... Types >
class Tuple;


template< class Type1, class ... Types >
class Tuple<Type1, Types...>
{
public:
    Type1 element;
    using TypeNext = Tuple < Types...>;
    TypeNext next_elements;
    Tuple() : element(Type1()), next_elements(Type_next()) {};
    Tuple(const Type1& other_element, const Types&... other_elements) : element(other_element),
        next_elements(other_elements...) {};
    template < typename ... U>
    Tuple(Type1&& other_element, U&&... other_elements) : element(std::forward<Type1>(other_element)),
        next_elements(std::forward<U>(other_elements)...)) {};
    Tuple(const Tuple<Type1, Types...>& tuple1) : element(tuple1.element),
        next_elements(tuple1.next_elements) {};
    Tuple(Tuple<Type1, Types...>&& tuple1) : element(std::move(tuple1.element)),
        next_elements(std::move(tuple1.next_elements)) {};
    Tuple& operator=(const Tuple<Type1, Types...>& tuple1)
    {
        element = tuple1.element;
        next_elements = tuple1.next_elements;
    }
    Tuple& operator=(Tuple<Type1, Types...>&& tuple1)
    {
        element = std::move(tuple1.element);
        next_elements = std::move(tuple1.next_elements);
    }
    ~Tuple<Type1, Types...>()
    {
        element.~();
        next_elements.~();
    }
    void swap(Tuple<Type1, Types...>& tuple1)
    {
        Tuple<Type1, Types...> swap_tuple = std::move(this);
        this = std::move(tuple1);
        tuple1 = std::move(swap_tuple);
    }
    bool operator==(Tuple tuple1, Tuple tuple2);
};

template < class Type1, class ... Types >
Tuple<Type1, Types...> makeTuple(Type1&& arg, Types&&...  args)
{
    return Tuple(std::forward(arg), std::forward(args...));
}

template < std::size_t element_number >
auto get(Tuple<auto... types>& tuple1)->decltype(tuple)
{
    if (element_number == 1)
    {
        return tuple1.element;
    }
    else
    {
        return get<element_number - 1>(next_elements);
    }
}

template < std::size_t element_number >
const auto& get(const Tuple<auto... types>& tuple1)->decltype(tuple)
{
    if (element_number == 1)
    {
        return tuple1.element;
    }
    else
    {
        return get<element_number - 1>(next_elements);
    }
}

template < std::size_t element_number >
auto&& get(Tuple<auto... types>&& tuple1)
{
    if (element_number == 1)
    {
        return std::move(tuple1.element);
    }
    else
    {
        return std::move(get<element_number - 1>(next_elements));
    }
}

//auto&& get<1>(Tuple<auto... Types>&& tuple1)
//{
//  return std::move(tuple1.element);
//}

template < typename T >
T& get(Tuple& tuple1)
{
    if (decltype(T) == decltype(tuple1.element))
    {
        return tuple1.element;
    }
    else
    {
        return get<T>(tuple1.next_elements);
    }
}

template < typename T >
const T& get(const Tuple& tuple1)
{
    if (decltype(T) == decltype(tuple1.element))
    {
        return tuple1.element;
    }
    else
    {
        return get<T>(tuple1.next_elements);
    }
}

template < typename T >
T&& get(Tuple&& tuple1)
{
    if (decltype(T) == decltype(tuple1.element))
    {
        return tuple1.element;
    }
    else
    {
        return get<T>(std::move(tuple1.next_elements));
    }
}

bool Tuple::operator==(Tuple tuple1, Tuple tuple2)
{

}

auto tupleCat(Tuple tuple1, )
{

}









template <>
class Tuple<>
{
public:
    Tuple()
    {

    }
};

template < class Type1, class... Types>
bool operator==(Tuple<Type1, Types...>& tuple1, Tuple<Type1.Types...>& tuple2)
{
    return (tuple1.element == tuple2.element && tuple1.tuple == tuple2.tuple);
}

//template < typename T >
//void get()