#pragma once

#include <string>
#include <type_traits>
#include <vector>

namespace program {
inline std::string join(std::string const & tok,
                        std::vector<std::string> const & data) {
  std::string accum = data.empty() ? "" : data.front();
  for (size_t i = 1; i < data.size(); ++i) {
    accum += tok;
    accum += data[i];
  }
  return accum;
}

template <typename T, typename = void> struct conversion_helper;

template <typename T, typename D> T convert(D const & data) {
  return conversion_helper<T>{}(data);
}

template <typename T>
struct conversion_helper<
    T, std::enable_if_t<std::is_convertible_v<std::string, T>>> {
  T operator()(std::string const & str) const { return T(str); }
  T operator()(std::vector<std::string> const & data) const {
    return operator()(data.front());
  }
};

template <> struct conversion_helper<int> {
  int operator()(std::string const & str) const { return std::stoi(str); }
  int operator()(std::vector<std::string> const & data) const {
    return operator()(data.front());
  }
};

template <typename T>
struct conversion_helper<std::vector<T>> : conversion_helper<T> {
  std::vector<T> operator()(std::vector<std::string> const & data) const {
    std::vector<T> rval;
    for (auto & str : data) {
      rval.emplace_back((*this)(str));
    }
    return rval;
  }
};
}