// Copyright 2024 Proyectos y Sistemas de Mantenimiento SL (eProsima).

//

// Licensed under the Apache License, Version 2.0 (the "License");

// you may not use this file except in compliance with the License.

// You may obtain a copy of the License at

//

//     http://www.apache.org/licenses/LICENSE-2.0

//

// Unless required by applicable law or agreed to in writing, software

// distributed under the License is distributed on an "AS IS" BASIS,

// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

// See the License for the specific language governing permissions and

// limitations under the License.

/*

 * UnitsParser.cpp

 *

 */

#include <utils/UnitsParser.hpp>

#include <algorithm>

#include <cctype>

#include <cstdint>

#include <limits>

#include <map>

#include <regex>

#include <set>

#include <stdexcept>

#include <string>

namespace eprosima {

namespace fastdds {

namespace dds {

namespace utils {

void to_uppercase(

        std::string& st) noexcept

{

    // These lambda has been taken from the notes in https://en.cppreference.com/w/cpp/string/byte/toupper

    // Note how the argument passed is unsigned char to avoid undefined behavior

    auto my_toupper = [](unsigned char c)

            {

                return static_cast<char>(std::toupper(c));

            };

    std::transform(st.begin(), st.end(), st.begin(), my_toupper);

}

uint32_t parse_value_and_units(

        std::string& value,

        std::string units)

{

    static const std::map<std::string, std::uint32_t> magnitudes = {

        {"", 1},

        {"B", 1},

        {"KB", 1000},

        {"MB", 1000 * 1000},

        {"GB", 1000 * 1000 * 1000},

        {"KIB", 1024},

        {"MIB", 1024 * 1024},

        {"GIB", 1024 * 1024 * 1024},

    };

    uint64_t num = 0;

    try

    {

        num = std::stoull(value);

    }

    catch (std::out_of_range&)

    {

        throw std::invalid_argument("Failed to parse value from string." \

                      " The number is too large to be converted to bytes (Max: (2^32)-1 Bytes).");

    }

    to_uppercase(units);

    uint32_t magnitude = 0;

    try

    {

        magnitude = magnitudes.at(units);

    }

    catch (std::out_of_range&)

    {

        throw std::invalid_argument(

                  "The units are not in the expected format. Use: {B, KB, MG, GB, KIB, MIB, GIB}.");

    }

    // Check whether the product of number * magnitude overflows

    if (num > std::numeric_limits<std::uint32_t>::max() / magnitude)

    {

        throw std::invalid_argument("The number is too large to be converted to bytes (Max: (2^32)-1 Bytes).");

    }

    // The explicit cast to uint32_t is safe since the number has already been checked to fit.

    // The product is also safe since the possible overflow has also been checked.

    const std::uint32_t bytes = static_cast<std::uint32_t>(num) * magnitude;

    return bytes;

}

} /* namespace utils */

} /* namespace dds */

} /* namespace fastdds */

} /* namespace eprosima */