#include "utils.hpp"

#include <phosphor-logging/elog.hpp>
#include <phosphor-logging/elog-errors.hpp>
#include <phosphor-logging/log.hpp>
#include <xyz/openbmc_project/Common/error.hpp>


namespace phosphor
{
namespace time
{

namespace // anonymous
{
constexpr auto MAPPER_BUSNAME = "xyz.openbmc_project.ObjectMapper";
constexpr auto MAPPER_PATH = "/xyz/openbmc_project/object_mapper";
constexpr auto MAPPER_INTERFACE = "xyz.openbmc_project.ObjectMapper";

/** @brief The map that maps the string to Mode */
const std::map<std::string, Mode> modeMap =
{
    { "NTP", Mode::NTP },
    { "MANUAL", Mode::MANUAL },
};

/** @brief The map that maps the string to Owner */
const std::map<std::string, Owner> ownerMap =
{
    { "BMC", Owner::BMC },
    { "HOST", Owner::HOST },
    { "SPLIT", Owner::SPLIT },
    { "BOTH", Owner::BOTH },
};
}

namespace utils
{

using InvalidArgumentError =
    sdbusplus::xyz::openbmc_project::Common::Error::InvalidArgument;

using namespace phosphor::logging;

std::string getService(sdbusplus::bus::bus& bus,
                       const char* path,
                       const char* interface)
{
    auto mapper = bus.new_method_call(MAPPER_BUSNAME,
                                      MAPPER_PATH,
                                      MAPPER_INTERFACE,
                                      "GetObject");

    mapper.append(path, std::vector<std::string>({interface}));
    auto mapperResponseMsg = bus.call(mapper);

    if (mapperResponseMsg.is_method_error())
    {
        using namespace xyz::openbmc_project::Time::Internal;
        elog<MethodErr>(MethodError::METHOD_NAME("GetObject"),
                          MethodError::PATH(path),
                          MethodError::INTERFACE(interface),
                          MethodError::MISC({}));
    }

    std::map<std::string, std::vector<std::string>> mapperResponse;
    mapperResponseMsg.read(mapperResponse);
    if (mapperResponse.empty())
    {
        using namespace xyz::openbmc_project::Time::Internal;
        elog<MethodErr>(MethodError::METHOD_NAME("GetObject"),
                          MethodError::PATH(path),
                          MethodError::INTERFACE(interface),
                          MethodError::MISC("Error reading mapper response"));
    }

    return mapperResponse.begin()->first;
}

Mode strToMode(const std::string& mode)
{
    auto it = modeMap.find(mode);
    if (it == modeMap.end())
    {
        using namespace xyz::openbmc_project::Common;
        elog<InvalidArgumentError>(
            InvalidArgument::ARGUMENT_NAME("TimeMode"),
            InvalidArgument::ARGUMENT_VALUE(mode.c_str()));
    }
    return it->second;
}

Owner strToOwner(const std::string& owner)
{
    auto it = ownerMap.find(owner);
    if (it == ownerMap.end())
    {
        using namespace xyz::openbmc_project::Common;
        elog<InvalidArgumentError>(
            InvalidArgument::ARGUMENT_NAME("TimeOwner"),
            InvalidArgument::ARGUMENT_VALUE(owner.c_str()));
    }
    return it->second;
}

const char* modeToStr(Mode mode)
{
    const char* ret{};
    switch (mode)
    {
    case Mode::NTP:
        ret = "NTP";
        break;
    case Mode::MANUAL:
        ret = "MANUAL";
        break;
    default:
        using namespace xyz::openbmc_project::Common;
        elog<InvalidArgumentError>(
            InvalidArgument::ARGUMENT_NAME("Mode"),
            InvalidArgument::ARGUMENT_VALUE(
                std::to_string(static_cast<int>(mode)).c_str()));
        break;
    }
    return ret;
}

const char* ownerToStr(Owner owner)
{
    const char* ret{};
    switch (owner)
    {
    case Owner::BMC:
        ret = "BMC";
        break;
    case Owner::HOST:
        ret = "HOST";
        break;
    case Owner::SPLIT:
        ret = "SPLIT";
        break;
    case Owner::BOTH:
        ret = "BOTH";
        break;
    default:
        using namespace xyz::openbmc_project::Common;
        elog<InvalidArgumentError>(
            InvalidArgument::ARGUMENT_NAME("Owner"),
            InvalidArgument::ARGUMENT_VALUE(
                std::to_string(static_cast<int>(owner)).c_str()));
        break;
    }
    return ret;
}

} // namespace utils
} // namespace time
} // namespace phosphor