#include "util/Retry.hpp"

#include <boost/asio/io_context.hpp>
#include <boost/asio/strand.hpp>

#include <algorithm>
#include <chrono>
#include <cstddef>
#include <memory>
#include <utility>

namespace util {

RetryStrategy::RetryStrategy(std::chrono::steady_clock::duration delay)
    : initialDelay_(delay), delay_(delay)
{
}

std::chrono::steady_clock::duration
RetryStrategy::getDelay() const
{
    return delay_;
}

void
RetryStrategy::increaseDelay()
{
    delay_ = nextDelay();
}

void
RetryStrategy::reset()
{
    delay_ = initialDelay_;
}

Retry::Retry(
    RetryStrategyPtr strategy,
    boost::asio::strand<boost::asio::io_context::executor_type> strand
)
    : strategy_(std::move(strategy)), timer_(strand.get_inner_executor())
{
}

Retry::~Retry()
{
    *canceled_ = true;
}

void
Retry::cancel()
{
    timer_.cancel();
    *canceled_ = true;
}

size_t
Retry::attemptNumber() const
{
    return attemptNumber_;
}

std::chrono::steady_clock::duration
Retry::delayValue() const
{
    return strategy_->getDelay();
}

void
Retry::reset()
{
    attemptNumber_ = 0;
    (*strategy_).reset();
}

ExponentialBackoffStrategy::ExponentialBackoffStrategy(
    std::chrono::steady_clock::duration delay,
    std::chrono::steady_clock::duration maxDelay
)
    : RetryStrategy(delay), maxDelay_(maxDelay)
{
}

std::chrono::steady_clock::duration
ExponentialBackoffStrategy::nextDelay() const
{
    auto const next = getDelay() * 2;
    return std::min(next, maxDelay_);
}

Retry
makeRetryExponentialBackoff(
    std::chrono::steady_clock::duration delay,
    std::chrono::steady_clock::duration maxDelay,
    boost::asio::strand<boost::asio::io_context::executor_type> strand
)
{
    return Retry(std::make_unique<ExponentialBackoffStrategy>(delay, maxDelay), std::move(strand));
}

}  // namespace util