//
//  cast.h
//  string-utils
//
//  Created by Sam Jaffe on 2/13/21.
//  Copyright © 2021 Sam Jaffe. All rights reserved.
//

#pragma once

#include <cstdlib>
#include <optional>
#include <string>
#include <string_view>
#include <type_traits>
#include <utility>
#include <variant>
#include <vector>

#include "any_of.h"

#define SAFE_NUMBER_PARSE(func, ...) \
  [](char const *in, char **out) { return func(in, out, ##__VA_ARGS__); }

namespace string_utils {
// A helper object for providing partial specializations for casting
template <typename, typename = void> struct cast_helper {};

// The main parser
template <typename T, typename S> std::pair<T, bool> cast(S const &str) noexcept;
template <typename T> bool cast(std::string_view str, T & to) noexcept;
template <typename S, typename T> bool cast(std::vector<S> const &strs, T & to) noexcept;
}

namespace string_utils::detail {
template <typename, typename, typename = void> struct has_cast_helper : std::false_type {};
template <typename T, typename S>
struct has_cast_helper<T, S, std::void_t<std::result_of_t<cast_helper<T>(S, T)>>>
    : std::true_type {};

template <typename, typename = void> struct is_tuple : std::false_type {};
template <typename T>
struct is_tuple<T, std::void_t<typename std::tuple_size<T>::type>> : std::true_type {};

template <typename, typename = void> struct is_associative : std::false_type {};
template <typename T>
struct is_associative<T, std::void_t<typename T::mapped_type>> : std::true_type {};

template <typename, typename = void> struct is_container : std::false_type {};
template <typename T>
struct is_container<T, std::void_t<typename T::value_type>> : std::true_type {};
}

namespace string_utils::detail {
template <typename Tuple, size_t... Is>
bool cast_tuple(std::vector<std::string> const & str, Tuple & to,
                std::index_sequence<Is...>) noexcept;
template <typename T, typename F>
bool cast_number(std::string_view str, T & to, F func) noexcept;
template <typename S> std::vector<S> keyval(S const &input);
}

namespace string_utils {

template <typename T>
bool cast(std::string_view str, T & to) noexcept {
  if constexpr (detail::has_cast_helper<T, std::string>{}) {
    return cast_helper<T>{}(str, to);
  } else if constexpr (std::is_same_v<T, std::string>) {
    to = T(str);
  } else {
    static_assert(!detail::has_cast_helper<T, std::string>{}, "no cast available");
  }
  return true;
}

template <typename S, typename T>
bool cast(std::vector<S> const &strs, T & to) noexcept {
  if constexpr(detail::has_cast_helper<T, std::vector<S>>{}) {
    return cast_helper<T>{}(strs, to);
  } else if constexpr (detail::is_tuple<T>{}) {
    constexpr size_t N = std::tuple_size_v<T>;
    return strs.size() == N && detail::cast_tuple(strs, to, std::make_index_sequence<N>{});
  } else if constexpr (detail::is_associative<T>{}) {
    for (S const &elem : strs) {
      size_t const pos = elem.find('=');
      auto [key, sk] = cast<typename T::key_type>(elem.substr(0, pos));
      auto [value, sv] = cast<typename T::key_type>(elem.substr(pos + 1));
      if (pos == S::npos || !sk || !sv) { return false; }
      to.insert(std::move(key), std::move(value));
    }
  } else if constexpr (detail::is_container<T>{}) {
    for (S const &elem : strs) {
      auto [tmp, success] = cast<typename T::value_type>(elem);
      if (!success) { return false; }
      to.insert(to.end(), std::move(tmp));
    }
  } else {
    static_assert(!detail::has_cast_helper<T, std::vector<S>>{}, "no cast available");
  }
  return true;
}

template <typename V, typename T> bool maybe_cast(std::string const & str, T & to) noexcept {
  auto [rval, found] = cast<V>(str);
  if (found) { to = std::move(rval); }
  return found;
}

template <typename... Ts>
struct cast_helper<std::variant<Ts...>> {
  bool operator()(std::string const &str, std::variant<Ts...> & to) const noexcept {
    return (maybe_cast<Ts>(str, to) || ...);
  }
};

template <typename T>
struct cast_helper<std::optional<T>> {
  bool operator()(std::string const &str, std::optional<T> & to) const noexcept {
    return maybe_cast<T>(str, to) || true;
  }
};

}

namespace string_utils {

inline bool cast(std::string_view str, long & to) noexcept {
  return detail::cast_number(str, to, SAFE_NUMBER_PARSE(std::strtol, 10));
}

inline bool cast(std::string_view str, long long & to) noexcept {
  return detail::cast_number(str, to, SAFE_NUMBER_PARSE(std::strtoll, 10));
}

inline bool cast(std::string_view str, float & to) noexcept {
  return detail::cast_number(str, to, SAFE_NUMBER_PARSE(std::strtof));
}

inline bool cast(std::string_view str, double & to) noexcept {
  return detail::cast_number(str, to, SAFE_NUMBER_PARSE(std::strtod));
}

inline bool cast(std::string_view str, long double & to) noexcept {
  return detail::cast_number(str, to, SAFE_NUMBER_PARSE(std::strtold));
}

inline bool cast(std::string_view str, int & to) noexcept {
  long tmp;
  bool rval = cast(str, tmp);
  to = static_cast<int>(tmp);
  return rval && tmp == static_cast<long>(to);
}

inline bool cast(std::string_view str, bool & to) noexcept {
  if (any_of(str, "true", "TRUE", "YES", "1")) {
    to = true;
    return true;
  } else if (any_of(str, "false", "FALSE", "NO", "0")) {
    to = false;
    return true;
  }
  return false;
}

}

namespace string_utils::detail {
template <typename Tuple, size_t... Is>
bool cast_tuple(std::vector<std::string> const & str, Tuple & to,
                std::index_sequence<Is...>) noexcept {
  return ((cast(str[Is], std::get<Is>(to))) && ...);
}

template <typename T, typename F>
bool cast_number(std::string_view str, T & to, F func) noexcept {
  char *counter = nullptr;
  to = func(str.data(), &counter);
  return counter == str.end();
}
}

// This should be placed last in the file
namespace string_utils {
template <typename T, typename S> std::pair<T, bool> cast(S const & str) noexcept {
  using string_utils::cast;
  std::pair<std::decay_t<T>, bool> rval;
  rval.second = cast(str, rval.first);
  return rval;
}
}

#undef CAST_NUMBER_IMPL