#include <iostream>
#include <string>
#include <cstdio>
#include <cstring>

namespace ss {

  template < typename T >
  struct ListElement {
    T value;
    ListElement<T> * next = nullptr;
  };

  template < typename T >
  class List {
   private:
    unsigned int count = 0;
    ListElement<T> * head = nullptr;
    ListElement<T> * tail = nullptr;

    template < typename U >
    friend std::ostream & operator<< (std::ostream &, const List<U> &);

   public:
    List();
    List(const T &);
    //List(const T &, const T & ...);
    ~List();
    void push_back(const T &);
    /*template < typename ... Ts >*/ void push_back(const T &, const /*Ts*/ T & ...);
  };

  template < typename T >
  List<T>::List() {
    std::cerr << "\033[0;33m# ctor\033[0m" << std::endl;
    //count = 0;
    //head = nullptr;
    //tail = nullptr;
  }

  template < typename T >
  List<T>::List(const T & x) {
    push_back(x);
  }

  /*
  template < typename T >
  List<T>::List(const T & x, const T & ... args) {
    push_back(x);
    push_back(args...);
  }
  */

  template < typename T >
  List<T>::~List() {
    std::cerr << "\033[0;35m# dtor\033[0m" << std::endl;
    ListElement<T> * t = nullptr;
    while (head != nullptr) {
      t = head->next;
      delete head;
      head = t;
    }
    tail = nullptr;
    count = 0;
  }

  template < typename T >
  std::ostream & operator<<(std::ostream & os, const List<T> & l) {
    os << "[";
    auto t = l.head;
    while (t != nullptr) {
      os << t->value;
      if (t != l.tail) {
        os << ", ";
      }
      t = t->next;
    }
    os << "]";
    return os;
  }

  template < typename T >
  void List<T>::push_back(const T & x) {
    if (head == nullptr) {
      head = new ListElement<T>;
      head->value = x;
      //head->next = nullptr;
      tail = head;
    } else {
      auto old_tail = tail;
      tail = new ListElement<T>;
      tail->value = x;
      //tail->next = nullptr;
      old_tail->next = tail;
    }
    count++;
  }

  template < typename T /*, typename ... Ts*/ >
  void List<T>::push_back(const T & x, const /*Ts*/ T & ... args) {
    push_back(x);
    pusk_back(args...);
  }

/* End of ss namespace */
}

int main() {
  ss::List<int> l1;
  l1.push_back(13);
  l1.push_back(666);
  std::cout << l1 << std::endl;

  ss::List<std::string> l2 ("lol");
  std::cout << l2 << std::endl;

  //ss::List<int> l3 (13, 666);
  //std::cout << l3 << std::endl;

  return 0;
}