/*
 *  Copyright (c) 2020, 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 includes definitions for the RA-based routing management.
 *
 */

#ifndef ROUTING_MANAGER_HPP_
#define ROUTING_MANAGER_HPP_

#include "openthread-core-config.h"

#if OPENTHREAD_CONFIG_BORDER_ROUTING_ENABLE

#if !OPENTHREAD_CONFIG_BORDER_ROUTER_ENABLE
#error "OPENTHREAD_CONFIG_BORDER_ROUTER_ENABLE is required for OPENTHREAD_CONFIG_BORDER_ROUTING_ENABLE."
#endif

#if !OPENTHREAD_CONFIG_IP6_SLAAC_ENABLE
#error "OPENTHREAD_CONFIG_IP6_SLAAC_ENABLE is required for OPENTHREAD_CONFIG_BORDER_ROUTING_ENABLE."
#endif

#include <openthread/netdata.h>
#include <openthread/platform/infra_if.h>

#include "border_router/router_advertisement.hpp"
#include "common/array.hpp"
#include "common/error.hpp"
#include "common/locator.hpp"
#include "common/notifier.hpp"
#include "common/timer.hpp"
#include "net/ip6.hpp"
#include "thread/network_data.hpp"

namespace ot {

namespace BorderRouter {

/**
 * This class implements bi-directional routing between Thread and Infrastructure networks.
 *
 * The Border Routing manager works on both Thread interface and infrastructure interface.
 * All ICMPv6 messages are sent/received on the infrastructure interface.
 *
 */
class RoutingManager : public InstanceLocator
{
    friend class ot::Notifier;

public:
    /**
     * This constructor initializes the routing manager.
     *
     * @param[in]  aInstance  A OpenThread instance.
     *
     */
    explicit RoutingManager(Instance &aInstance);

    /**
     * This method initializes the routing manager on given infrastructure interface.
     *
     * @param[in]  aInfraIfIndex      An infrastructure network interface index.
     * @param[in]  aInfraIfIsRunning  A boolean that indicates whether the infrastructure
     *                                interface is running.
     *
     * @retval  kErrorNone         Successfully started the routing manager.
     * @retval  kErrorInvalidArgs  The index of the infra interface is not valid.
     *
     */
    Error Init(uint32_t aInfraIfIndex, bool aInfraIfIsRunning);

    /**
     * This method enables/disables the Border Routing Manager.
     *
     * @note  The Border Routing Manager is enabled by default.
     *
     * @param[in]  aEnabled   A boolean to enable/disable the Border Routing Manager.
     *
     * @retval  kErrorInvalidState   The Border Routing Manager is not initialized yet.
     * @retval  kErrorNone           Successfully enabled/disabled the Border Routing Manager.
     *
     */
    Error SetEnabled(bool aEnabled);

    /**
     * This method returns the off-mesh-routable (OMR) prefix.
     *
     * The randomly generated 64-bit prefix will be published
     * in the Thread network if there isn't already an OMR prefix.
     *
     * @param[out]  aPrefix  A reference to where the prefix will be output to.
     *
     * @retval  kErrorInvalidState  The Border Routing Manager is not initialized yet.
     * @retval  kErrorNone          Successfully retrieved the OMR prefix.
     *
     */
    Error GetOmrPrefix(Ip6::Prefix &aPrefix);

    /**
     * This method returns the on-link prefix for the adjacent  infrastructure link.
     *
     * The randomly generated 64-bit prefix will be advertised
     * on the infrastructure link if there isn't already a usable
     * on-link prefix being advertised on the link.
     *
     * @param[out]  aPrefix  A reference to where the prefix will be output to.
     *
     * @retval  kErrorInvalidState  The Border Routing Manager is not initialized yet.
     * @retval  kErrorNone          Successfully retrieved the on-link prefix.
     *
     */
    Error GetOnLinkPrefix(Ip6::Prefix &aPrefix);

#if OPENTHREAD_CONFIG_BORDER_ROUTING_NAT64_ENABLE
    /**
     * This method returns the local NAT64 prefix.
     *
     * The local NAT64 prefix will be published in the Thread network
     * if none exists.
     *
     * @param[out]  aPrefix  A reference to where the prefix will be output to.
     *
     * @retval  kErrorInvalidState  The Border Routing Manager is not initialized yet.
     * @retval  kErrorNone          Successfully retrieved the NAT64 prefix.
     *
     */
    Error GetNat64Prefix(Ip6::Prefix &aPrefix);
#endif // OPENTHREAD_CONFIG_BORDER_ROUTING_NAT64_ENABLE

    /**
     * This method receives an ICMPv6 message on the infrastructure interface.
     *
     * Malformed or undesired messages are dropped silently.
     *
     * @param[in]  aInfraIfIndex  The infrastructure interface index.
     * @param[in]  aSrcAddress    The source address this message is sent from.
     * @param[in]  aBuffer        THe ICMPv6 message buffer.
     * @param[in]  aLength        The length of the ICMPv6 message buffer.
     *
     */
    void RecvIcmp6Message(uint32_t            aInfraIfIndex,
                          const Ip6::Address &aSrcAddress,
                          const uint8_t *     aBuffer,
                          uint16_t            aBufferLength);

    /**
     * This method handles infrastructure interface state changes.
     *
     * @param[in]  aInfraIfIndex  The index of the infrastructure interface.
     * @param[in]  aIsRunning     A boolean that indicates whether the infrastructure
     *                            interface is running.
     *
     * @retval  kErrorNone          Successfully updated the infra interface status.
     * @retval  kErrorInvalidState  The Routing Manager is not initialized.
     * @retval  kErrorInvalidArgs   The @p aInfraIfIndex doesn't match the infra interface
     *                              the Routing Manager is initialized with.
     *
     */
    Error HandleInfraIfStateChanged(uint32_t aInfraIfIndex, bool aIsRunning);

private:
    typedef NetworkData::RoutePreference RoutePreference;

    static constexpr uint16_t kMaxRouterAdvMessageLength = 256; // The maximum RA message length we can handle.

    // The maximum number of the OMR prefixes to advertise.
    static constexpr uint8_t kMaxOmrPrefixNum = OPENTHREAD_CONFIG_IP6_SLAAC_NUM_ADDRESSES;

    // The maximum number of prefixes to discover on the infra link.
    static constexpr uint8_t kMaxDiscoveredPrefixNum = 8;

    static constexpr uint8_t kOmrPrefixLength    = OT_IP6_PREFIX_BITSIZE; // The length of an OMR prefix. In bits.
    static constexpr uint8_t kOnLinkPrefixLength = OT_IP6_PREFIX_BITSIZE; // The length of an On-link prefix. In bits.

    // The maximum number of initial Router Advertisements.
    static constexpr uint32_t kMaxInitRtrAdvertisements = 3;

    // The maximum number of Router Solicitations before sending Router Advertisements.
    static constexpr uint32_t kMaxRtrSolicitations = 3;

    static constexpr uint32_t kDefaultOmrPrefixLifetime    = 1800; // The default OMR prefix valid lifetime. In sec.
    static constexpr uint32_t kDefaultOnLinkPrefixLifetime = 1800; // The default on-link prefix valid lifetime. In sec.
    static constexpr uint32_t kMaxRtrAdvInterval           = 600;  // Max Router Advertisement Interval. In sec.
    static constexpr uint32_t kMinRtrAdvInterval           = kMaxRtrAdvInterval / 3; // Min RA Interval. In sec.
    static constexpr uint32_t kMaxInitRtrAdvInterval       = 16;                     // Max Initial RA Interval. In sec.
    static constexpr uint32_t kRaReplyJitter               = 500;    // Jitter for sending RA after rx RS. In msec.
    static constexpr uint32_t kRtrSolicitationInterval     = 4;      // Interval between RSs. In sec.
    static constexpr uint32_t kMaxRtrSolicitationDelay     = 1;      // Max delay for initial solicitation. In sec.
    static constexpr uint32_t kRoutingPolicyEvaluationJitter = 1000; // Jitter for routing policy evaluation. In msec.
    static constexpr uint32_t kRtrSolicitationRetryDelay     = 60;   // The delay before retrying failed RS tx. In Sec.

    // The STALE_RA_TIME in seconds. The Routing Manager will consider the prefixes
    // and learned RA parameters STALE when they are not refreshed in STALE_RA_TIME
    // seconds. The Routing Manager will then start Router Solicitation to verify
    // that the STALE prefix is not being advertised anymore and remove the STALE
    // prefix.
    // The value is chosen in range of [`kMaxRtrAdvInterval` upper bound (1800s), `kDefaultOnLinkPrefixLifetime`].
    static constexpr uint32_t kRtrAdvStaleTime = 1800;

    // The VICARIOUS_SOLICIT_TIME in seconds. The Routing Manager will consider
    // the discovered prefixes invalid if they are not refreshed after receiving
    // a Router Solicitation message.
    // The value is equal to Router Solicitation timeout.
    static constexpr uint32_t kVicariousSolicitationTime =
        kRtrSolicitationInterval * (kMaxRtrSolicitations - 1) + kMaxRtrSolicitationDelay;

    static_assert(kMinRtrAdvInterval <= 3 * kMaxRtrAdvInterval / 4, "invalid RA intervals");
    static_assert(kDefaultOmrPrefixLifetime >= kMaxRtrAdvInterval, "invalid default OMR prefix lifetime");
    static_assert(kDefaultOnLinkPrefixLifetime >= kMaxRtrAdvInterval, "invalid default on-link prefix lifetime");
    static_assert(kRtrAdvStaleTime >= 1800 && kRtrAdvStaleTime <= kDefaultOnLinkPrefixLifetime,
                  "invalid RA STALE time");

    // This struct represents an external prefix which is
    // discovered on the infrastructure interface.
    struct ExternalPrefix : public Clearable<ExternalPrefix>, public Unequatable<ExternalPrefix>
    {
        Ip6::Prefix mPrefix;
        uint32_t    mValidLifetime;

        union
        {
            // Preferred Lifetime of on-link prefix, available
            // only when `mIsOnLinkPrefix` is TRUE.
            uint32_t mPreferredLifetime;

            // The preference of this route, available
            // only when `mIsOnLinkPrefix` is FALSE.
            RoutePreference mRoutePreference;
        };
        TimeMilli mTimeLastUpdate;
        bool      mIsOnLinkPrefix;

        bool operator==(const ExternalPrefix &aPrefix) const
        {
            return mPrefix == aPrefix.mPrefix && mIsOnLinkPrefix == aPrefix.mIsOnLinkPrefix;
        }

        bool IsDeprecated(void) const
        {
            OT_ASSERT(mIsOnLinkPrefix);

            return mTimeLastUpdate + TimeMilli::SecToMsec(mPreferredLifetime) <= TimerMilli::GetNow();
        }

        TimeMilli GetExpireTime(void) const { return mTimeLastUpdate + GetPrefixExpireDelay(mValidLifetime); }
        TimeMilli GetStaleTime(void) const
        {
            uint32_t delay = OT_MIN(kRtrAdvStaleTime, mIsOnLinkPrefix ? mPreferredLifetime : mValidLifetime);

            return mTimeLastUpdate + TimeMilli::SecToMsec(delay);
        }

        static uint32_t GetPrefixExpireDelay(uint32_t aValidLifetime);
    };

    typedef Array<Ip6::Prefix, kMaxOmrPrefixNum>           OmrPrefixArray;
    typedef Array<ExternalPrefix, kMaxDiscoveredPrefixNum> ExternalPrefixArray;

    void  EvaluateState(void);
    void  Start(void);
    void  Stop(void);
    void  HandleNotifierEvents(Events aEvents);
    bool  IsInitialized(void) const { return mInfraIfIndex != 0; }
    bool  IsEnabled(void) const { return mIsEnabled; }
    Error LoadOrGenerateRandomOmrPrefix(void);
    Error LoadOrGenerateRandomOnLinkPrefix(void);

    const Ip6::Prefix *EvaluateOnLinkPrefix(void);

#if OPENTHREAD_CONFIG_BORDER_ROUTING_NAT64_ENABLE
    Error LoadOrGenerateRandomNat64Prefix(void);
    void  EvaluateNat64Prefix(void);
#endif

    void  EvaluateRoutingPolicy(void);
    void  StartRoutingPolicyEvaluationJitter(uint32_t aJitterMilli);
    void  StartRoutingPolicyEvaluationDelay(uint32_t aDelayMilli);
    void  EvaluateOmrPrefix(OmrPrefixArray &aNewOmrPrefixes);
    Error PublishLocalOmrPrefix(void);
    void  UnpublishLocalOmrPrefix(void);
    Error AddExternalRoute(const Ip6::Prefix &aPrefix, RoutePreference aRoutePreference, bool aNat64 = false);
    void  RemoveExternalRoute(const Ip6::Prefix &aPrefix);
    void  StartRouterSolicitationDelay(void);
    Error SendRouterSolicitation(void);
    void  SendRouterAdvertisement(const OmrPrefixArray &aNewOmrPrefixes, const Ip6::Prefix *aNewOnLinkPrefix);
    bool  IsRouterSolicitationInProgress(void) const;

#if OPENTHREAD_CONFIG_BORDER_ROUTING_VICARIOUS_RS_ENABLE
    static void HandleVicariousRouterSolicitTimer(Timer &aTimer);
    void        HandleVicariousRouterSolicitTimer(void);
#endif
    static void HandleRouterSolicitTimer(Timer &aTimer);
    void        HandleRouterSolicitTimer(void);
    static void HandleDiscoveredPrefixInvalidTimer(Timer &aTimer);
    void        HandleDiscoveredPrefixInvalidTimer(void);
    static void HandleDiscoveredPrefixStaleTimer(Timer &aTimer);
    void        HandleDiscoveredPrefixStaleTimer(void);
    static void HandleRoutingPolicyTimer(Timer &aTimer);
    void        HandleOnLinkPrefixDeprecateTimer(void);
    static void HandleOnLinkPrefixDeprecateTimer(Timer &aTimer);

    void DeprecateOnLinkPrefix(void);
    void HandleRouterSolicit(const Ip6::Address &aSrcAddress, const uint8_t *aBuffer, uint16_t aBufferLength);
    void HandleRouterAdvertisement(const Ip6::Address &aSrcAddress, const uint8_t *aBuffer, uint16_t aBufferLength);
    bool UpdateDiscoveredOnLinkPrefix(const RouterAdv::PrefixInfoOption &aPio);
    void UpdateDiscoveredOmrPrefix(const RouterAdv::RouteInfoOption &aRio);
    void InvalidateDiscoveredPrefixes(const Ip6::Prefix *aPrefix = nullptr, bool aIsOnLinkPrefix = true);
    void InvalidateAllDiscoveredPrefixes(void);
    bool NetworkDataContainsOmrPrefix(const Ip6::Prefix &aPrefix) const;
    bool UpdateRouterAdvMessage(const RouterAdv::RouterAdvMessage *aRouterAdvMessage);
    void ResetDiscoveredPrefixStaleTimer(void);

    static bool IsValidOmrPrefix(const NetworkData::OnMeshPrefixConfig &aOnMeshPrefixConfig);
    static bool IsValidOmrPrefix(const Ip6::Prefix &aOmrPrefix);
    static bool IsValidOnLinkPrefix(const RouterAdv::PrefixInfoOption &aPio);
    static bool IsValidOnLinkPrefix(const Ip6::Prefix &aOnLinkPrefix);

    // Indicates whether the Routing Manager is running (started).
    bool mIsRunning;

    // Indicates whether the Routing manager is enabled. The Routing
    // Manager will be stopped if we are disabled.
    bool mIsEnabled;

    // Indicates whether the infra interface is running. The Routing
    // Manager will be stopped when the Infra interface is not running.
    bool mInfraIfIsRunning;

    // The index of the infra interface on which Router Advertisement
    // messages will be sent.
    uint32_t mInfraIfIndex;

    // The OMR prefix loaded from local persistent storage or randomly
    // generated if non is found in persistent storage.
    Ip6::Prefix mLocalOmrPrefix;

    // The advertised OMR prefixes. For a stable Thread network without
    // manually configured OMR prefixes, there should be a single OMR
    // prefix that is being advertised because each BRs will converge to
    // the smallest OMR prefix sorted by method IsPrefixSmallerThan. If
    // manually configured OMR prefixes exist, they will also be
    // advertised on infra link.
    OmrPrefixArray mAdvertisedOmrPrefixes;

    // The on-link prefix loaded from local persistent storage or
    // randomly generated if non is found in persistent storage.
    Ip6::Prefix mLocalOnLinkPrefix;

    bool mIsAdvertisingLocalOnLinkPrefix;

    // The last time when the on-link prefix is advertised with
    // non-zero preferred lifetime.
    TimeMilli  mTimeAdvertisedOnLinkPrefix;
    TimerMilli mOnLinkPrefixDeprecateTimer;

    // The NAT64 prefix loaded from local persistent storage or
    // randomly generated if none is found in persistent storage.
    Ip6::Prefix mLocalNat64Prefix;

    // True if the local NAT64 prefix is advertised in Thread network.
    bool mIsAdvertisingLocalNat64Prefix;

    // The array of prefixes discovered on the infra link. Those
    // prefixes consist of on-link prefix(es) and OMR prefixes
    // advertised by BRs in another Thread Network which is connected to
    // the same infra link.
    ExternalPrefixArray mDiscoveredPrefixes;

    // The RA header and parameters for the infra interface.
    // This value is initialized with `RouterAdvMessage::SetToDefault`
    // and updated with RA messages initiated from infra interface.
    RouterAdv::RouterAdvMessage mRouterAdvMessage;
    TimeMilli                   mTimeRouterAdvMessageLastUpdate;
    bool                        mLearntRouterAdvMessageFromHost;

    TimerMilli mDiscoveredPrefixInvalidTimer;
    TimerMilli mDiscoveredPrefixStaleTimer;

    uint32_t mRouterAdvertisementCount;

#if OPENTHREAD_CONFIG_BORDER_ROUTING_VICARIOUS_RS_ENABLE
    TimerMilli mVicariousRouterSolicitTimer;
    TimeMilli  mTimeVicariousRouterSolicitStart;
#endif
    TimerMilli mRouterSolicitTimer;
    TimeMilli  mTimeRouterSolicitStart;
    uint8_t    mRouterSolicitCount;

    TimerMilli mRoutingPolicyTimer;
};

} // namespace BorderRouter

} // namespace ot

#endif // OPENTHREAD_CONFIG_BORDER_ROUTING_ENABLE

#endif // ROUTING_MANAGER_HPP_