// This file is distributed under the BSD License.
// See "license.txt" for details.
// Copyright 2009-2012, Jonathan Turner (jonathan@emptycrate.com)
// Copyright 2009-2018, Jason Turner (jason@emptycrate.com)
// http://www.chaiscript.com

#ifndef CHAISCRIPT_DEFINES_HPP_
#define CHAISCRIPT_DEFINES_HPP_

#ifdef _MSC_VER
#define CHAISCRIPT_STRINGIZE(x) "" #x
#define CHAISCRIPT_STRINGIZE_EXPANDED(x) CHAISCRIPT_STRINGIZE(x)
#define CHAISCRIPT_COMPILER_VERSION CHAISCRIPT_STRINGIZE_EXPANDED(_MSC_FULL_VER)
#define CHAISCRIPT_MSVC _MSC_VER
#define CHAISCRIPT_HAS_DECLSPEC

static_assert(_MSC_FULL_VER >= 190024210, "Visual C++ 2015 Update 3 or later required");

#else
#define CHAISCRIPT_COMPILER_VERSION __VERSION__
#endif

#include <string_view>
#include <vector>

#if defined(_LIBCPP_VERSION)
#define CHAISCRIPT_LIBCPP
#endif

#if defined(_WIN32) || defined(__CYGWIN__)
#define CHAISCRIPT_WINDOWS
#endif

#if defined(_WIN32)
#if defined(__llvm__)
#define CHAISCRIPT_COMPILER_NAME "clang(windows)"
#elif defined(__GNUC__)
#define CHAISCRIPT_COMPILER_NAME "gcc(mingw)"
#else
#define CHAISCRIPT_COMPILER_NAME "msvc"
#endif
#else
#if defined(__llvm__)
#define CHAISCRIPT_COMPILER_NAME "clang"
#elif defined(__GNUC__)
#define CHAISCRIPT_COMPILER_NAME "gcc"
#else
#define CHAISCRIPT_COMPILER_NAME "unknown"
#endif
#endif

#if defined(__llvm__)
#define CHAISCRIPT_CLANG
#endif

#ifdef CHAISCRIPT_HAS_DECLSPEC
#define CHAISCRIPT_MODULE_EXPORT extern "C" __declspec(dllexport)
#else
#define CHAISCRIPT_MODULE_EXPORT extern "C"
#endif

#if defined(CHAISCRIPT_MSVC) || (defined(__GNUC__) && __GNUC__ >= 5) || defined(CHAISCRIPT_CLANG)
#define CHAISCRIPT_UTF16_UTF32
#endif

#ifdef _DEBUG
#define CHAISCRIPT_DEBUG true
#else
#define CHAISCRIPT_DEBUG false
#endif

#include <charconv>
#include <memory>
#include <string>
#include <type_traits>

// libc++ (AppleClang, Emscripten) may not support floating-point std::from_chars
#if !defined(CHAISCRIPT_LIBCPP)
#define CHAISCRIPT_HAS_FLOAT_FROM_CHARS 1
#endif

#ifndef CHAISCRIPT_HAS_FLOAT_FROM_CHARS
#include <cstdlib>
#endif

namespace chaiscript {
  constexpr static const int version_major = 7;
  constexpr static const int version_minor = 0;
  constexpr static const int version_patch = 0;

  constexpr static const char *compiler_version = CHAISCRIPT_COMPILER_VERSION;
  constexpr static const char *compiler_name = CHAISCRIPT_COMPILER_NAME;
  constexpr static const bool debug_build = CHAISCRIPT_DEBUG;

  template<typename B, typename D, typename... Arg>
  inline std::shared_ptr<B> make_shared(Arg &&...arg) {
#ifdef CHAISCRIPT_USE_STD_MAKE_SHARED
    return std::make_shared<D>(std::forward<Arg>(arg)...);
#else
    return std::shared_ptr<B>(static_cast<B *>(new D(std::forward<Arg>(arg)...)));
#endif
  }

  template<typename B, typename D, typename... Arg>
  inline std::unique_ptr<B> make_unique(Arg &&...arg) {
#ifdef CHAISCRIPT_USE_STD_MAKE_SHARED
    return std::make_unique<D>(std::forward<Arg>(arg)...);
#else
    return std::unique_ptr<B>(static_cast<B *>(new D(std::forward<Arg>(arg)...)));
#endif
  }

  struct Build_Info {
    [[nodiscard]] constexpr static int version_major() noexcept { return chaiscript::version_major; }

    [[nodiscard]] constexpr static int version_minor() noexcept { return chaiscript::version_minor; }

    [[nodiscard]] constexpr static int version_patch() noexcept { return chaiscript::version_patch; }

    [[nodiscard]] static std::string version() {
      return std::to_string(version_major()) + '.' + std::to_string(version_minor()) + '.' + std::to_string(version_patch());
    }

    [[nodiscard]] static std::string compiler_id() { return compiler_name() + '-' + compiler_version(); }

    [[nodiscard]] static std::string build_id() { return compiler_id() + (debug_build() ? "-Debug" : "-Release"); }

    [[nodiscard]] static std::string compiler_version() { return chaiscript::compiler_version; }

    [[nodiscard]] static std::string compiler_name() { return chaiscript::compiler_name; }

    [[nodiscard]] constexpr static bool debug_build() noexcept { return chaiscript::debug_build; }
  };

  template<typename T>
  [[nodiscard]] auto parse_num(const std::string_view t_str) {
    T t{};
    if constexpr (std::is_floating_point_v<T>) {
#ifdef CHAISCRIPT_HAS_FLOAT_FROM_CHARS
      std::from_chars(t_str.data(), t_str.data() + t_str.size(), t);
#else
      const std::string tmp(t_str);
      if constexpr (std::is_same_v<T, float>) {
        t = std::strtof(tmp.c_str(), nullptr);
      } else if constexpr (std::is_same_v<T, long double>) {
        t = std::strtold(tmp.c_str(), nullptr);
      } else {
        t = std::strtod(tmp.c_str(), nullptr);
      }
#endif
    } else {
      std::from_chars(t_str.data(), t_str.data() + t_str.size(), t);
    }
    return t;
  }

  struct str_equal {
    [[nodiscard]] bool operator()(const std::string &t_lhs, const std::string &t_rhs) const noexcept { return t_lhs == t_rhs; }
    template<typename LHS, typename RHS>
    [[nodiscard]] constexpr bool operator()(const LHS &t_lhs, const RHS &t_rhs) const noexcept {
      return std::equal(t_lhs.begin(), t_lhs.end(), t_rhs.begin(), t_rhs.end());
    }
    struct is_transparent {
    };
  };

  struct str_less {
    [[nodiscard]] bool operator()(const std::string &t_lhs, const std::string &t_rhs) const noexcept { return t_lhs < t_rhs; }
    template<typename LHS, typename RHS>
    [[nodiscard]] constexpr bool operator()(const LHS &t_lhs, const RHS &t_rhs) const noexcept {
      return std::lexicographical_compare(t_lhs.begin(), t_lhs.end(), t_rhs.begin(), t_rhs.end());
    }
    struct is_transparent {
    };
  };

  enum class Options {
    No_Load_Modules,
    Load_Modules,
    No_External_Scripts,
    External_Scripts
  };

  enum class Library_Options {
    No_Stdlib,
    No_IO,
    No_Prelude,
    No_JSON
  };

  template<typename From, typename To>
  struct is_nothrow_forward_constructible : std::bool_constant<noexcept(To{std::declval<From>()})> {
  };

  template<class From, class To>
  static inline constexpr bool is_nothrow_forward_constructible_v = is_nothrow_forward_constructible<From, To>::value;

  template<typename Container, typename... T>
  [[nodiscard]] constexpr auto make_container(T &&...t) {
    Container c;
    c.reserve(sizeof...(t));
    (c.push_back(std::forward<T>(t)), ...);
    return c;
  }

  template<typename... T>
  [[nodiscard]] auto make_vector(T &&...t) -> std::vector<std::common_type_t<std::decay_t<T>...>> {
    using container_type = std::vector<std::common_type_t<std::decay_t<T>...>>;

    return make_container<container_type>(std::forward<T>(t)...);
  }

  [[nodiscard]] inline std::vector<Options> default_options() {
#ifdef CHAISCRIPT_NO_DYNLOAD
    return {Options::No_Load_Modules, Options::External_Scripts};
#else
    return {Options::Load_Modules, Options::External_Scripts};
#endif
  }
} // namespace chaiscript
#endif