#pragma once

#include <algorithm>
#include <cctype>
#include <concepts>
#include <sstream>
#include <string>
#include <vector>

namespace cpp20 {

template <std::integral T>
[[nodiscard]] auto double_value(T value) -> T {
    return value * 2;
}

template <std::floating_point T>
[[nodiscard]] auto clamp01(T value) -> T {
    // Converts the 0 and 1 to the right type, which fulfills the std::floating_point concept
    return std::clamp(value, T{0}, T{1});
}

template <typename T>
concept StringLike = requires(T value) {
    { value.size() } -> std::convertible_to<std::size_t>;
    { value.data() } -> std::convertible_to<const char*>;
};

template <StringLike T>
[[nodiscard]] auto uppercase_copy(const T& text) -> std::string {
    auto oss = std::ostringstream{};
    for (auto idx = 0uz; idx < text.size(); idx++) {
        oss << static_cast<char>(std::toupper(text.data()[idx]));
    }
    return oss.str();
}

template<typename T>
requires std::integral<T>
[[nodiscard]] auto sum_integral(const std::vector<T>& data) -> T {
    return std::ranges::fold_left(data, T{0}, std::plus{});
}

}  // namespace cpp20