#include "dbus_handler.hpp"

#include "log.hpp"

namespace boot_time_monitor
{
namespace dbus
{

namespace btm = boot_time_monitor;

constexpr std::string_view kPSUCheckpointName = "TrayPowerCycle";
constexpr std::string_view kPSUDurationName = "TrayPowerCycle";

Handler::Handler(sdbusplus::bus::bus& dbus, const btm::NodeConfig& nodeConfig,
                 const btm::dbus::DbusConfig& dbusConfig,
                 std::shared_ptr<btm::api::IBoottimeApi> api) :
    sdbusplus::server::object::object<Duration>(dbus,
                                                dbusConfig.dbusObjPath.c_str()),
    sdbusplus::server::object::object<Checkpoint>(
        dbus, dbusConfig.dbusObjPath.c_str()),
    sdbusplus::server::object::object<Statistic>(
        dbus, dbusConfig.dbusObjPath.c_str()),
    mNodeConfig(nodeConfig), mApi(std::move(api))
{}

void Handler::setCheckpoint(std::string checkpointName, int64_t wallTime,
                            int64_t selfMeasuredDuration)
{
    if (checkpointName == kPSUCheckpointName)
    {
        absl::Status status = mApi->SetPSUCheckpoint(checkpointName, wallTime,
                                                     selfMeasuredDuration);
        btm::log::LogIfError(status);
    }
    else
    {
        absl::Status status = mApi->SetNodeCheckpoint(
            mNodeConfig, checkpointName, wallTime, selfMeasuredDuration);
        btm::log::LogIfError(status);
    }
}

std::vector<std::tuple<std::string, int64_t, int64_t>>
    Handler::getCheckpointList()
{
    return mApi->GetNodeCheckpointList(mNodeConfig);
}

void Handler::rebootComplete()
{
    if (!isRebooting())
    {
        fmt::print(stderr,
                   "[{}]: Not rebooting. Skip this `rebootComplete` command\n",
                   __FUNCTION__);
        return;
    }

    absl::Status status = mApi->NotifyNodeComplete(mNodeConfig);
    btm::log::LogIfError(status);
}

void Handler::setDuration(std::string durationName, int64_t duration)
{
    if (durationName == kPSUDurationName)
    {
        absl::Status status = mApi->SetPSUDuration(durationName, duration);
        btm::log::LogIfError(status);
    }
    else
    {
        absl::Status status = mApi->SetNodeDuration(mNodeConfig, durationName,
                                                    duration);
        btm::log::LogIfError(status);
    }
}

std::vector<std::tuple<std::string, int64_t>> Handler::getAdditionalDurations()
{
    return mApi->GetNodeAdditionalDurations(mNodeConfig);
}

bool Handler::isRebooting() const
{
    return mApi->IsNodeRebooting(mNodeConfig);
}
} // namespace dbus
} // namespace boot_time_monitor