path: root/src/openvic-simulation/utility/StringUtils.hpp

#pragma once

#include <algorithm>
#include <cctype>
#include <cstdint>
#include <cstring>
#include <limits>
#include <string>
#include <string_view>
#include <type_traits>

namespace OpenVic::StringUtils {
   /* The constexpr function 'string_to_uint64' will convert a string into a uint64_t integer value.
    * The function takes four parameters: the input string (as a pair of pointers marking the start and
    * end of the string), a bool pointer for reporting success, and the base for numerical conversion.
    * The base parameter defaults to 10 (decimal), but it can be any value between 2 and 36. If the base
    * given is 0, it will be set to 16 if the string starts with "0x" or "0X", otherwise 8 if the string
    * still starts with "0", otherwise 10. The success bool pointer parameter is used to report whether
    * or not conversion was successful. It can be nullptr if this information is not needed.
    */
   constexpr uint64_t string_to_uint64(char const* str, char const* const end, bool* successful = nullptr, int base = 10) {
      if (successful != nullptr) {
         *successful = false;
      }

      // Base value should be between 2 and 36. If it's not, return 0 as an invalid case.
      if (str == nullptr || end <= str || base < 0 || base == 1 || base > 36) {
         return 0;
      }

      // The result of the conversion will be stored in this variable.
      uint64_t result = 0;

      // If base is zero, base is determined by the string prefix.
      if (base == 0) {
         if (*str == '0') {
            if (str + 1 != end && (str[1] == 'x' || str[1] == 'X')) {
               base = 16; // Hexadecimal.
               str += 2; // Skip '0x' or '0X'
               if (str == end) {
                  return 0;
               }
            } else {
               base = 8; // Octal.
            }
         } else {
            base = 10; // Decimal.
         }
      } else if (base == 16) {
         // If base is 16 and string starts with '0x' or '0X', skip these characters.
         if (*str == '0' && str + 1 != end && (str[1] == 'x' || str[1] == 'X')) {
            str += 2;
            if (str == end) {
               return 0;
            }
         }
      }

      // Convert the number in the string.
      for (; str != end; ++str) {
         int digit;
         if (*str >= '0' && *str <= '9') {
            digit = *str - '0'; // Calculate digit value for '0'-'9'.
         } else if (*str >= 'a' && *str <= 'z') {
            digit = *str - 'a' + 10; // Calculate digit value for 'a'-'z'.
         } else if (*str >= 'A' && *str <= 'Z') {
            digit = *str - 'A' + 10; // Calculate digit value for 'A'-'Z'.
         } else {
            break; // Stop conversion if current character is not a digit.
         }

         if (digit >= base) {
            break; // Stop conversion if current digit is greater than or equal to the base.
         }

         // Check for overflow on multiplication
         if (result > std::numeric_limits<uint64_t>::max() / base) {
            return std::numeric_limits<uint64_t>::max();
         }

         result *= base;

         // Check for overflow on addition
         if (result > std::numeric_limits<uint64_t>::max() - digit) {
            return std::numeric_limits<uint64_t>::max();
         }

         result += digit;
      }

      // If successful is not null and the entire string was parsed,
      // set *successful to true (if not it is already false).
      if (successful != nullptr && str == end) {
         *successful = true;
      }

      return result;
   }

   inline constexpr uint64_t string_to_uint64(char const* str, size_t length, bool* successful = nullptr, int base = 10) {
      return string_to_uint64(str, str + length, successful, base);
   }

   inline constexpr uint64_t string_to_uint64(std::string_view str, bool* successful = nullptr, int base = 10) {
      return string_to_uint64(str.data(), str.length(), successful, base);
   }

   constexpr int64_t string_to_int64(char const* str, char const* const end, bool* successful = nullptr, int base = 10) {
      if (successful != nullptr) {
         *successful = false;
      }

      if (str == nullptr || end <= str) {
         return 0;
      }

      // This flag will be set if the number is negative.
      bool is_negative = false;

      // Check if there is a sign character.
      if (*str == '+' || *str == '-') {
         if (*str == '-') {
            is_negative = true;
         }
         ++str;
         if (str == end) {
            return 0;
         }
      }

      const uint64_t result = string_to_uint64(str, end, successful, base);
      if (!is_negative) {
         if (result >= std::numeric_limits<int64_t>::max()) {
            return std::numeric_limits<int64_t>::max();
         }
         return result;
      } else {
         if (result > std::numeric_limits<int64_t>::max()) {
            return std::numeric_limits<int64_t>::min();
         }
         return -result;
      }
   }

   inline constexpr int64_t string_to_int64(char const* str, size_t length, bool* successful = nullptr, int base = 10) {
      return string_to_int64(str, str + length, successful, base);
   }

   inline constexpr int64_t string_to_int64(std::string_view str, bool* successful = nullptr, int base = 10) {
      return string_to_int64(str.data(), str.length(), successful, base);
   }

   inline constexpr bool strings_equal_case_insensitive(std::string_view const& lhs, std::string_view const& rhs) {
      if (lhs.size() != rhs.size()) {
         return false;
      }
      constexpr auto ichar_equals = [](unsigned char l, unsigned char r) {
         return std::tolower(l) == std::tolower(r);
      };
      return std::equal(lhs.begin(), lhs.end(), rhs.begin(), rhs.end(), ichar_equals);
   }

   inline constexpr std::string string_tolower(std::string_view str) {
      std::string result { str };
      std::transform(result.begin(), result.end(), result.begin(),
         [](unsigned char c) -> unsigned char { return std::tolower(c); }
      );
      return result;
   }

   inline constexpr std::string string_toupper(std::string_view str) {
      std::string result { str };
      std::transform(result.begin(), result.end(), result.begin(),
         [](unsigned char c) -> unsigned char { return std::toupper(c); }
      );
      return result;
   }

   inline constexpr std::string_view get_filename(std::string_view path) {
      size_t pos = path.size();
      while (pos > 0 && path[pos - 1] != '/' && path[pos - 1] != '\\') {
         --pos;
      }
      path.remove_prefix(pos);
      return path;
   }

   inline constexpr char const* get_filename(char const* filepath, char const* default_path = nullptr) {
      const std::string_view filename { get_filename(std::string_view { filepath }) };
      if (!filename.empty()) {
         return filename.data();
      }
      return default_path;
   }

   inline std::string make_forward_slash_path(std::string_view path) {
      std::string ret { path };
      std::replace(ret.begin(), ret.end(), '\\', '/');
      for (char& c : ret) {
         if (c == '\\') {
            c = '/';
         }
      }
      return ret;
   }

   inline constexpr std::string_view remove_leading_slashes(std::string_view path) {
      size_t count = 0;
      while (count < path.size() && (path[count] == '/' || path[count] == '\\')) {
         ++count;
      }
      path.remove_prefix(count);
      return path;
   }

   template<typename... Args>
   requires(std::is_same_v<std::string_view, Args> && ...)
   inline std::string _append_string_views(Args... args) {
      std::string ret;
      ret.reserve((args.size() + ...));
      (ret.append(args), ...);
      return ret;
   }

   template<typename... Args>
   requires(std::is_convertible_v<Args, std::string_view> && ...)
   inline std::string append_string_views(Args... args) {
      return _append_string_views(std::string_view { args }...);
   }

   inline constexpr size_t get_extension_pos(std::string_view const& path) {
      size_t pos = path.size();
      while (pos > 0 && path[--pos] != '.') {}
      return pos;
   }

   inline constexpr std::string_view get_extension(std::string_view path) {
      if (!path.empty()) {
         const size_t pos = get_extension_pos(path);
         if (path[pos] == '.') {
            path.remove_prefix(pos);
            return path;
         }
      }
      return {};
   }

   inline constexpr std::string_view remove_extension(std::string_view path) {
      if (!path.empty()) {
         const size_t pos = get_extension_pos(path);
         if (path[pos] == '.') {
            path.remove_suffix(path.size() - pos);
         }
      }
      return path;
   }
}