/*
 *  Copyright (c) 2016, The OpenThread Authors.
 *  All rights reserved.
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions are met:
 *  1. Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *  2. Redistributions in binary form must reproduce the above copyright
 *     notice, this list of conditions and the following disclaimer in the
 *     documentation and/or other materials provided with the distribution.
 *  3. Neither the name of the copyright holder nor the
 *     names of its contributors may be used to endorse or promote products
 *     derived from this software without specific prior written permission.
 *
 *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 *  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 *  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 *  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 *  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 *  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 *  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 *  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 *  POSSIBILITY OF SUCH DAMAGE.
 */

/**
 * @file
 *   This file implements the trickle timer logic.
 */

#include "trickle_timer.hpp"

#include "common/code_utils.hpp"
#include "common/debug.hpp"
#include "common/num_utils.hpp"
#include "common/random.hpp"

namespace ot {

TrickleTimer::TrickleTimer(Instance &aInstance, Handler aHandler)
    : TimerMilli(aInstance, TrickleTimer::HandleTimer)
    , mIntervalMin(0)
    , mIntervalMax(0)
    , mInterval(0)
    , mTimeInInterval(0)
    , mRedundancyConstant(0)
    , mCounter(0)
    , mHandler(aHandler)
    , mMode(kModeTrickle)
    , mPhase(kBeforeRandomTime)
{
}

TimeMilli TrickleTimer::GetStartTimeOfCurrentInterval(void) const
{
    // Determines and returns the start time of the current
    // interval.

    TimeMilli startTime = TimerMilli::GetFireTime();

    if (mMode == kModePlainTimer)
    {
        startTime -= mInterval;
        ExitNow();
    }

    switch (mPhase)
    {
    case kBeforeRandomTime:
        startTime -= mTimeInInterval;
        break;

    case kAfterRandomTime:
        startTime -= mInterval;
        break;
    }

exit:
    return startTime;
}

void TrickleTimer::SetIntervalMin(uint32_t aIntervalMin)
{
    VerifyOrExit(IsRunning());

    mIntervalMin = aIntervalMin;

    if (mIntervalMax < mIntervalMin)
    {
        SetIntervalMax(mIntervalMin);
    }

exit:
    return;
}

void TrickleTimer::SetIntervalMax(uint32_t aIntervalMax)
{
    TimeMilli endOfInterval;

    VerifyOrExit(IsRunning());

    aIntervalMax = Max(mIntervalMin, aIntervalMax);
    VerifyOrExit(aIntervalMax != mIntervalMax);

    mIntervalMax = aIntervalMax;

    // If the new `aIntervalMax` is greater than the current
    // `mInterval`, no action is needed. The new `aIntervalMax` will be
    // used as the `mInterval` grows.

    VerifyOrExit(mIntervalMax < mInterval);

    // Determine the end of the interval as if the new and shorter
    // `mIntervalMax` would have been used. The calculated time may
    // be in the past. In this case, `FireAt(endOfInterval)` will
    // cause the timer to fire immediately.

    endOfInterval = GetStartTimeOfCurrentInterval() + mIntervalMax;

    if (mMode == kModePlainTimer)
    {
        TimerMilli::FireAt(endOfInterval);
        ExitNow();
    }

    // Trickle mode possible scenarios:
    //
    // We are in `kBeforeRandomTime` phase.
    //
    // a) If the new `aIntervalMax < mTimeInInterval`:
    //    - Reschedule the timer to fire at new `endOfInterval`
    //      (which may fire immediately).
    //    - Set `mTimeInInterval = aIntervalMax`
    //    - Set `mInterval` to use the shorter `aIntervalMax`.
    //
    //   |<---- mInterval ----------------^------------------>|
    //   |<---- mTimeInInterval ----------^---->|             |
    //   |<---- aIntervalMax -------->|   ^     |             |
    //   |                            |  now    |             |
    //
    // b) If the new `aIntervalMax >= mTimeInInterval`:
    //    - Keep timer unchanged to fire at `mTimeInInterval`
    //    - Keep `mTimeInInterval` unchanged.
    //    - Set `mInterval` to use the shorter `aIntervalMax`.
    //
    //   |<---- mInterval ----------------^------------------>|
    //   |<---- mTimeInInterval ----------^---->|    |        |
    //   |<---- aIntervalMax -------------^--------->|        |
    //   |                              now          |        |
    //
    // We are in `kAfterRandomTime` phase.
    //
    // c) If the new `aIntervalMax < mTimeInInterval`:
    //    - Act as if current interval is already finished.
    //    - Reschedule the timer to fire at new `endOfInterval`
    //      (which should fire immediately).
    //    - Set `mInterval` to use the shorter `aIntervalMax`.
    //    - The `mTimeInInterval` value does not matter as we
    //      are in `kAfterRandomTime` phase. Keep it unchanged.
    //
    //   |<---- mInterval ---------------------------^------->|
    //   |<---- mTimeInInterval --------------->|    ^        |
    //   |<---- aIntervalMax -------->|         |    ^        |
    //   |                            |         |   now       |
    //
    // d) If the new `aIntervalMax >= mTimeInInterval`:
    //    - Reschedule the timer to fire at new `endOfInterval`
    //    - Set `mInterval` to use the shorter `aIntervalMax`.
    //    - The `mTimeInInterval` value does not matter as we
    //      are in `kAfterRandomTime` phase. Keep it unchanged.
    //
    //   |<---- mInterval ---------------------------^------->|
    //   |<---- mTimeInInterval --------------->|    ^   |    |
    //   |<---- aIntervalMax ------------------------^-->|    |
    //   |                                      |   now  |    |

    // In all cases we need to set `mInterval` to the new
    // shorter `aIntervalMax`.

    mInterval = aIntervalMax;

    switch (mPhase)
    {
    case kBeforeRandomTime:
        if (aIntervalMax < mTimeInInterval)
        {
            mTimeInInterval = aIntervalMax;
        }
        else
        {
            break;
        }

        OT_FALL_THROUGH;

    case kAfterRandomTime:
        TimerMilli::FireAt(endOfInterval);
        break;
    }

exit:
    return;
}

void TrickleTimer::Start(Mode aMode, uint32_t aIntervalMin, uint32_t aIntervalMax, uint16_t aRedundancyConstant)
{
    OT_ASSERT((aIntervalMax >= aIntervalMin) && (aIntervalMin > 0));

    mIntervalMin        = aIntervalMin;
    mIntervalMax        = aIntervalMax;
    mRedundancyConstant = aRedundancyConstant;
    mMode               = aMode;

    // Select interval randomly from range [Imin, Imax].
    mInterval = Random::NonCrypto::GetUint32InRange(mIntervalMin, mIntervalMax + 1);

    StartNewInterval();
}

void TrickleTimer::IndicateConsistent(void)
{
    if (mCounter < kInfiniteRedundancyConstant)
    {
        mCounter++;
    }
}

void TrickleTimer::IndicateInconsistent(void)
{
    VerifyOrExit(mMode == kModeTrickle);

    // If interval is equal to minimum when an "inconsistent" event
    // is received, do nothing.

    VerifyOrExit(IsRunning() && (mInterval != mIntervalMin));

    mInterval = mIntervalMin;
    StartNewInterval();

exit:
    return;
}

void TrickleTimer::StartNewInterval(void)
{
    uint32_t halfInterval;

    switch (mMode)
    {
    case kModePlainTimer:
        mTimeInInterval = mInterval;
        break;

    case kModeTrickle:
        // Select a random point in the interval taken from the range [I/2, I).
        halfInterval = mInterval / 2;
        mTimeInInterval =
            (halfInterval < mInterval) ? Random::NonCrypto::GetUint32InRange(halfInterval, mInterval) : halfInterval;
        mCounter = 0;
        mPhase   = kBeforeRandomTime;
        break;
    }

    TimerMilli::Start(mTimeInInterval);
}

void TrickleTimer::HandleTimer(Timer &aTimer) { static_cast<TrickleTimer *>(&aTimer)->HandleTimer(); }

void TrickleTimer::HandleTimer(void)
{
    switch (mMode)
    {
    case kModePlainTimer:
        mInterval = Random::NonCrypto::GetUint32InRange(mIntervalMin, mIntervalMax + 1);
        StartNewInterval();
        break;

    case kModeTrickle:
        switch (mPhase)
        {
        case kBeforeRandomTime:
            // We reached end of random `mTimeInInterval` (aka `t`)
            // within the current interval. Trickle timer invokes
            // handler if and only if the counter is less than the
            // redundancy constant.

            mPhase = kAfterRandomTime;
            TimerMilli::Start(mInterval - mTimeInInterval);
            VerifyOrExit(mCounter < mRedundancyConstant);
            break;

        case kAfterRandomTime:
            // Interval has expired. Double the interval length and
            // ensure result is below max.

            if (mInterval == 0)
            {
                mInterval = 1;
            }
            else if (mInterval <= mIntervalMax - mInterval)
            {
                mInterval *= 2;
            }
            else
            {
                mInterval = mIntervalMax;
            }

            StartNewInterval();
            ExitNow(); // Exit so to not call `mHandler`
        }

        break;
    }

    mHandler(*this);

exit:
    return;
}

} // namespace ot