// Copyright 2014 The Chromium OS Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifndef LIBBRILLO_BRILLO_STRINGS_STRING_UTILS_H_
#define LIBBRILLO_BRILLO_STRINGS_STRING_UTILS_H_

#include <string>
#include <utility>
#include <vector>

#include <brillo/brillo_export.h>

namespace brillo {
namespace string_utils {

// Treats the string as a delimited list of substrings and returns the array
// of original elements of the list.
// |trim_whitespaces| causes each element to have all whitespaces trimmed off.
// |purge_empty_strings| specifies whether empty elements from the original
// string should be omitted.
BRILLO_EXPORT std::vector<std::string> Split(const std::string& str,
                                             const std::string& delimiter,
                                             bool trim_whitespaces,
                                             bool purge_empty_strings);
// Splits the string, trims all whitespaces, omits empty string parts.
inline std::vector<std::string> Split(const std::string& str,
                                      const std::string& delimiter) {
  return Split(str, delimiter, true, true);
}
// Splits the string, omits empty string parts.
inline std::vector<std::string> Split(const std::string& str,
                                      const std::string& delimiter,
                                      bool trim_whitespaces) {
  return Split(str, delimiter, trim_whitespaces, true);
}

// Splits the string into two pieces at the first position of the specified
// delimiter.
BRILLO_EXPORT std::pair<std::string, std::string> SplitAtFirst(
    const std::string& str,
    const std::string& delimiter,
    bool trim_whitespaces);
// Splits the string into two pieces at the first position of the specified
// delimiter. Both parts have all whitespaces trimmed off.
inline std::pair<std::string, std::string> SplitAtFirst(
    const std::string& str,
    const std::string& delimiter) {
  return SplitAtFirst(str, delimiter, true);
}

// The following overload returns false if the delimiter was not found in the
// source string. In this case, |left_part| will be set to |str| and
// |right_part| will be empty.
BRILLO_EXPORT bool SplitAtFirst(const std::string& str,
                                const std::string& delimiter,
                                std::string* left_part,
                                std::string* right_part,
                                bool trim_whitespaces);
// Always trims the white spaces in the split parts.
inline bool SplitAtFirst(const std::string& str,
                         const std::string& delimiter,
                         std::string* left_part,
                         std::string* right_part) {
  return SplitAtFirst(str, delimiter, left_part, right_part, true);
}

// Joins strings into a single string separated by |delimiter|.
template <class InputIterator>
std::string JoinRange(const std::string& delimiter,
                      InputIterator first,
                      InputIterator last) {
  std::string result;
  if (first == last)
    return result;
  result = *first;
  for (++first; first != last; ++first) {
    result += delimiter;
    result += *first;
  }
  return result;
}

template <class Container>
std::string Join(const std::string& delimiter, const Container& strings) {
  using std::begin;
  using std::end;
  return JoinRange(delimiter, begin(strings), end(strings));
}

inline std::string Join(const std::string& delimiter,
                        std::initializer_list<std::string> strings) {
  return JoinRange(delimiter, strings.begin(), strings.end());
}

inline std::string Join(const std::string& delimiter,
                        const std::string& str1,
                        const std::string& str2) {
  return str1 + delimiter + str2;
}

// string_utils::ToString() is a helper function to convert any scalar type
// to a string. In most cases, it redirects the call to std::to_string with
// two exceptions: for std::string itself and for double and bool.
template <typename T>
inline std::string ToString(T value) {
  return std::to_string(value);
}
// Having the following overload is handy for templates where the type
// of template parameter isn't known and could be a string itself.
inline std::string ToString(std::string value) {
  return value;
}
// We overload this for double because std::to_string(double) uses %f to
// format the value and I would like to use a shorter %g format instead.
BRILLO_EXPORT std::string ToString(double value);
// And the bool to be converted as true/false instead of 1/0.
BRILLO_EXPORT std::string ToString(bool value);

// Converts a byte-array into a string. This method doesn't perform any
// data re-encoding. It just takes every byte from the buffer and appends it
// to the string as a character.
BRILLO_EXPORT std::string GetBytesAsString(const std::vector<uint8_t>& buf);

// Converts a string into a byte-array. Opposite of GetBytesAsString().
BRILLO_EXPORT std::vector<uint8_t> GetStringAsBytes(const std::string& str);

}  // namespace string_utils
}  // namespace brillo

#endif  // LIBBRILLO_BRILLO_STRINGS_STRING_UTILS_H_