/*
 *  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 includes definitions for forwarding IPv6 datagrams across the Thread mesh.
 */

#ifndef MESH_FORWARDER_HPP_
#define MESH_FORWARDER_HPP_

#include "openthread-core-config.h"

#include "common/locator.hpp"
#include "common/tasklet.hpp"
#include "mac/channel_mask.hpp"
#include "mac/data_poll_sender.hpp"
#include "mac/mac.hpp"
#include "net/ip6.hpp"
#include "thread/address_resolver.hpp"
#include "thread/indirect_sender.hpp"
#include "thread/lowpan.hpp"
#include "thread/network_data_leader.hpp"
#include "thread/topology.hpp"

namespace ot {

enum
{
    kReassemblyTimeout = OPENTHREAD_CONFIG_6LOWPAN_REASSEMBLY_TIMEOUT,
};

/**
 * @addtogroup core-mesh-forwarding
 *
 * @brief
 *   This module includes definitions for mesh forwarding within Thread.
 *
 * @{
 */

/**
 * This class represents an IPv6 fragment priority entry
 *
 */
class FragmentPriorityEntry
{
public:
    /**
     * This method returns the fragment datagram tag value.
     *
     * @returns The fragment datagram tag value.
     *
     */
    uint16_t GetDatagramTag(void) const { return mDatagramTag; }

    /**
     * This method sets the fragment datagram tag value.
     *
     * @param[in]  aDatagramTag  The fragment datagram tag value.
     *
     */
    void SetDatagramTag(uint16_t aDatagramTag) { mDatagramTag = aDatagramTag; }

    /**
     * This method returns the source Rloc16 of the fragment.
     *
     * @returns The source Rloc16 value.
     *
     */
    uint16_t GetSrcRloc16(void) const { return mSrcRloc16; }

    /**
     * This method sets the source Rloc16 value of the fragment.
     *
     * @param[in]  aSrcRloc16  The source Rloc16 value.
     *
     */
    void SetSrcRloc16(uint16_t aSrcRloc16) { mSrcRloc16 = aSrcRloc16; }

    /**
     * This method returns the fragment priority value.
     *
     * @returns The fragment priority value.
     *
     */
    uint8_t GetPriority(void) const { return mPriority; }

    /**
     * This method sets the fragment priority value.
     *
     * @param[in]  aPriority  The fragment priority value.
     *
     */
    void SetPriority(uint8_t aPriority) { mPriority = aPriority; }

    /**
     * This method returns the fragment priority entry's remaining lifetime.
     *
     * @returns The fragment priority entry's remaining lifetime.
     *
     */
    uint8_t GetLifetime(void) const { return mLifetime; }

    /**
     * This method sets the remaining lifetime of the fragment priority entry.
     *
     * @param[in]  aLifetime  The remaining lifetime of the fragment priority entry (in seconds).
     *
     */
    void SetLifetime(uint8_t aLifetime)
    {
        if (aLifetime > kMaxLifeTime)
        {
            aLifetime = kMaxLifeTime;
        }

        mLifetime = aLifetime;
    }

    /**
     * This method decrements the entry lifetime.
     *
     */
    void DecrementLifetime(void) { mLifetime--; }

private:
    enum
    {
        kMaxLifeTime = 5, ///< The maximum lifetime of the fragment entry (in seconds).
    };

    uint16_t mSrcRloc16;    ///< The source Rloc16 of the datagram.
    uint16_t mDatagramTag;  ///< The datagram tag of the fragment header.
    uint8_t  mPriority : 3; ///< The priority level of the first fragment.
    uint8_t  mLifetime : 3; ///< The lifetime of the entry (in seconds). 0 means the entry is invalid.
};

/**
 * This class implements mesh forwarding within Thread.
 *
 */
class MeshForwarder : public InstanceLocator
{
    friend class Mac::Mac;
    friend class Instance;
    friend class DataPollSender;
    friend class IndirectSender;

public:
    /**
     * This constructor initializes the object.
     *
     * @param[in]  aInstance     A reference to the OpenThread instance.
     *
     */
    explicit MeshForwarder(Instance &aInstance);

    /**
     * This method enables mesh forwarding and the IEEE 802.15.4 MAC layer.
     *
     */
    void Start(void);

    /**
     * This method disables mesh forwarding and the IEEE 802.15.4 MAC layer.
     *
     */
    void Stop(void);

    /**
     * This method submits a message to the mesh forwarder for forwarding.
     *
     * @param[in]  aMessage  A reference to the message.
     *
     * @retval OT_ERROR_NONE     Successfully enqueued the message.
     * @retval OT_ERROR_ALREADY  The message was already enqueued.
     * @retval OT_ERROR_DROP     The message could not be sent and should be dropped.
     *
     */
    otError SendMessage(Message &aMessage);

    /**
     * This method is called by the address resolver when an EID-to-RLOC mapping has been resolved.
     *
     * @param[in]  aEid    A reference to the EID that has been resolved.
     * @param[in]  aError  OT_ERROR_NONE on success and OT_ERROR_DROP otherwise.
     *
     */
    void HandleResolved(const Ip6::Address &aEid, otError aError);

    /**
     * This method indicates whether or not rx-on-when-idle mode is enabled.
     *
     * @retval TRUE   The rx-on-when-idle mode is enabled.
     * @retval FALSE  The rx-on-when-idle-mode is disabled.
     *
     */
    bool GetRxOnWhenIdle(void) const;

    /**
     * This method sets the rx-on-when-idle mode
     *
     * @param[in]  aRxOnWhenIdle  TRUE to enable, FALSE otherwise.
     *
     */
    void SetRxOnWhenIdle(bool aRxOnWhenIdle);

    /**
     * This method sets the scan parameters for MLE Discovery Request messages.
     *
     * @param[in]  aScanChannels  A reference to channel mask indicating which channels to scan.
     *                            If @p aScanChannels is empty, then all channels are used instead.
     *
     */
    void SetDiscoverParameters(const Mac::ChannelMask &aScanChannels);

    /**
     * This method frees any indirect messages queued for children that are no longer attached.
     *
     */
    void UpdateIndirectMessages(void);

    /**
     * This method frees any messages queued for an existing child.
     *
     * @param[in]  aChild    A reference to the child.
     * @param[in]  aSubType  The message sub-type to remove.
     *                       Use Message::kSubTypeNone remove all messages for @p aChild.
     *
     */
    void RemoveMessages(Child &aChild, uint8_t aSubType);

    /**
     * This method frees unicast/multicast MLE Data Responses from Send Message Queue if any.
     *
     */
    void RemoveDataResponseMessages(void);

    /**
     * This method evicts the message with lowest priority in the send queue.
     *
     * @param[in]  aPriority  The highest priority level of the evicted message.
     *
     * @retval OT_ERROR_NONE       Successfully evicted a low priority message.
     * @retval OT_ERROR_NOT_FOUND  No low priority messages available to evict.
     *
     */
    otError EvictMessage(uint8_t aPriority);

    /**
     * This method returns a reference to the send queue.
     *
     * @returns  A reference to the send queue.
     *
     */
    const PriorityQueue &GetSendQueue(void) const { return mSendQueue; }

    /**
     * This method returns a reference to the reassembly queue.
     *
     * @returns  A reference to the reassembly queue.
     *
     */
    const MessageQueue &GetReassemblyQueue(void) const { return mReassemblyList; }

    /**
     * This method returns a reference to the IP level counters.
     *
     * @returns A reference to the IP level counters.
     *
     */
    const otIpCounters &GetCounters(void) const { return mIpCounters; }

    /**
     * This method resets the IP level counters.
     *
     */
    void ResetCounters(void) { memset(&mIpCounters, 0, sizeof(mIpCounters)); }

#if OPENTHREAD_FTD
    /**
     * This method returns a reference to the resolving queue.
     *
     * @returns  A reference to the resolving queue.
     *
     */
    const MessageQueue &GetResolvingQueue(void) const { return mResolvingQueue; }
#endif

private:
    enum
    {
        kStateUpdatePeriod  = 1000,                     ///< State update period in milliseconds.
        kDefaultMsgPriority = Message::kPriorityNormal, ///< Default message priority.

        /**
         * The number of fragment priority entries.
         *
         */
        kNumFragmentPriorityEntries = OPENTHREAD_CONFIG_NUM_FRAGMENT_PRIORITY_ENTRIES,
    };

    enum MessageAction ///< Defines the action parameter in `LogMessageInfo()` method.
    {
        kMessageReceive,         ///< Indicates that the message was received.
        kMessageTransmit,        ///< Indicates that the message was sent.
        kMessagePrepareIndirect, ///< Indicates that the message is being prepared for indirect tx.
        kMessageDrop,            ///< Indicates that the outbound message is being dropped (e.g., dst unknown).
        kMessageReassemblyDrop,  ///< Indicates that the message is being dropped from reassembly list.
        kMessageEvict,           ///< Indicates that the message was evicted.
    };

    otError CheckReachability(uint8_t *           aFrame,
                              uint16_t            aFrameLength,
                              const Mac::Address &aMeshSource,
                              const Mac::Address &aMeshDest);
    void    UpdateRoutes(uint8_t *           aFrame,
                         uint16_t            aFrameLength,
                         const Mac::Address &aMeshSource,
                         const Mac::Address &aMeshDest);

    otError  DecompressIp6Header(const uint8_t *     aFrame,
                                 uint16_t            aFrameLength,
                                 const Mac::Address &aMacSource,
                                 const Mac::Address &aMacDest,
                                 Ip6::Header &       aIp6Header,
                                 uint8_t &           aHeaderLength,
                                 bool &              aNextHeaderCompressed);
    otError  GetIp6Header(const uint8_t *     aFrame,
                          uint16_t            aFrameLength,
                          const Mac::Address &aMacSource,
                          const Mac::Address &aMacDest,
                          Ip6::Header &       aIp6Header);
    void     GetMacDestinationAddress(const Ip6::Address &aIp6Addr, Mac::Address &aMacAddr);
    void     GetMacSourceAddress(const Ip6::Address &aIp6Addr, Mac::Address &aMacAddr);
    Message *GetDirectTransmission(void);
    otError  PrepareDiscoverRequest(void);
    void     HandleMesh(uint8_t *               aFrame,
                        uint16_t                aFrameLength,
                        const Mac::Address &    aMacSource,
                        const otThreadLinkInfo &aLinkInfo);
    void     HandleFragment(uint8_t *               aFrame,
                            uint16_t                aFrameLength,
                            const Mac::Address &    aMacSource,
                            const Mac::Address &    aMacDest,
                            const otThreadLinkInfo &aLinkInfo);
    void     HandleLowpanHC(uint8_t *               aFrame,
                            uint16_t                aFrameLength,
                            const Mac::Address &    aMacSource,
                            const Mac::Address &    aMacDest,
                            const otThreadLinkInfo &aLinkInfo);
    uint16_t PrepareDataFrame(Mac::TxFrame &      aFrame,
                              Message &           aMessage,
                              const Mac::Address &aMacSource,
                              const Mac::Address &aMacDest,
                              bool                aAddMeshHeader = false,
                              uint16_t            aMeshSource    = 0xffff,
                              uint16_t            aMeshDest      = 0xffff);

    void    SendMesh(Message &aMessage, Mac::TxFrame &aFrame);
    otError UpdateIp6Route(Message &aMessage);
    otError UpdateIp6RouteFtd(Ip6::Header &ip6Header);
    otError UpdateMeshRoute(Message &aMessage);
    bool    UpdateReassemblyList(void);
    bool    UpdateFragmentLifetime(void);
    void    UpdateFragmentPriority(Lowpan::FragmentHeader &aFragmentHeader,
                                   uint16_t                aFragmentLength,
                                   uint16_t                aSrcRloc16,
                                   uint8_t                 aPriority);
    otError HandleDatagram(Message &aMessage, const otThreadLinkInfo &aLinkInfo, const Mac::Address &aMacSource);
    void    ClearReassemblyList(void);
    void    RemoveMessage(Message &aMessage);
    void    HandleDiscoverComplete(void);

    void      HandleReceivedFrame(Mac::RxFrame &aFrame);
    otError   HandleFrameRequest(Mac::TxFrame &aFrame);
    Neighbor *UpdateNeighborOnSentFrame(Mac::TxFrame &aFrame, otError aError, const Mac::Address &aMacDest);
    void      HandleSentFrame(Mac::TxFrame &aFrame, otError aError);

    static void HandleDiscoverTimer(Timer &aTimer);
    void        HandleDiscoverTimer(void);
    static void HandleUpdateTimer(Timer &aTimer);
    void        HandleUpdateTimer(void);
    static void ScheduleTransmissionTask(Tasklet &aTasklet);
    void        ScheduleTransmissionTask(void);

    otError GetFramePriority(const uint8_t *     aFrame,
                             uint16_t            aFrameLength,
                             const Mac::Address &aMacSource,
                             const Mac::Address &aMacDest,
                             uint8_t &           aPriority);
    otError GetFragmentPriority(Lowpan::FragmentHeader &aFragmentHeader, uint16_t aSrcRloc16, uint8_t &aPriority);
    otError GetForwardFramePriority(const uint8_t *     aFrame,
                                    uint16_t            aFrameLength,
                                    const Mac::Address &aMeshSource,
                                    const Mac::Address &aMeshDest,
                                    uint8_t &           aPriority);

    FragmentPriorityEntry *FindFragmentPriorityEntry(uint16_t aTag, uint16_t aSrcRloc16);
    FragmentPriorityEntry *GetUnusedFragmentPriorityEntry(void);

    otError GetDestinationRlocByServiceAloc(uint16_t aServiceAloc, uint16_t &aMeshDest);

    void LogMessage(MessageAction aAction, const Message &aMessage, const Mac::Address *aAddress, otError aError);
    void LogFrame(const char *aActionText, const Mac::Frame &aFrame, otError aError);
    void LogFragmentFrameDrop(otError                       aError,
                              uint16_t                      aFrameLength,
                              const Mac::Address &          aMacSource,
                              const Mac::Address &          aMacDest,
                              const Lowpan::FragmentHeader &aFragmentHeader,
                              bool                          aIsSecure);
    void LogLowpanHcFrameDrop(otError             aError,
                              uint16_t            aFrameLength,
                              const Mac::Address &aMacSource,
                              const Mac::Address &aMacDest,
                              bool                aIsSecure);

#if (OPENTHREAD_CONFIG_LOG_LEVEL >= OT_LOG_LEVEL_NOTE) && (OPENTHREAD_CONFIG_LOG_MAC == 1)
    const char *MessageActionToString(MessageAction aAction, otError aError);
    const char *MessagePriorityToString(const Message &aMessage);

    otError ParseIp6UdpTcpHeader(const Message &aMessage,
                                 Ip6::Header &  aIp6Header,
                                 uint16_t &     aChecksum,
                                 uint16_t &     aSourcePort,
                                 uint16_t &     aDestPort);
#if OPENTHREAD_FTD
    otError DecompressIp6UdpTcpHeader(const Message &     aMessage,
                                      uint16_t            aOffset,
                                      const Mac::Address &aMeshSource,
                                      const Mac::Address &aMeshDest,
                                      Ip6::Header &       aIp6Header,
                                      uint16_t &          aChecksum,
                                      uint16_t &          aSourcePort,
                                      uint16_t &          aDestPort);
    otError LogMeshFragmentHeader(MessageAction       aAction,
                                  const Message &     aMessage,
                                  const Mac::Address *aMacAddress,
                                  otError             aError,
                                  uint16_t &          aOffset,
                                  Mac::Address &      aMeshSource,
                                  Mac::Address &      aMeshDest,
                                  otLogLevel          aLogLevel);
    void    LogMeshIpHeader(const Message &     aMessage,
                            uint16_t            aOffset,
                            const Mac::Address &aMeshSource,
                            const Mac::Address &aMeshDest,
                            otLogLevel          aLogLevel);
    void    LogMeshMessage(MessageAction       aAction,
                           const Message &     aMessage,
                           const Mac::Address *aAddress,
                           otError             aError,
                           otLogLevel          aLogLevel);
#endif
    void LogIp6SourceDestAddresses(Ip6::Header &aIp6Header,
                                   uint16_t     aSourcePort,
                                   uint16_t     aDestPort,
                                   otLogLevel   aLogLevel);
    void LogIp6Message(MessageAction       aAction,
                       const Message &     aMessage,
                       const Mac::Address *aAddress,
                       otError             aError,
                       otLogLevel          aLogLevel);
#endif // #if (OPENTHREAD_CONFIG_LOG_LEVEL >= OT_LOG_LEVEL_NOTE) && (OPENTHREAD_CONFIG_LOG_MAC == 1)

    TimerMilli mDiscoverTimer;
    TimerMilli mUpdateTimer;

    PriorityQueue mSendQueue;
    MessageQueue  mReassemblyList;
    uint16_t      mFragTag;
    uint16_t      mMessageNextOffset;

    Message *mSendMessage;

    Mac::Address mMacSource;
    Mac::Address mMacDest;
    uint16_t     mMeshSource;
    uint16_t     mMeshDest;
    bool         mAddMeshHeader;

    bool mSendBusy;

    Tasklet mScheduleTransmissionTask;
    bool    mEnabled;

    Mac::ChannelMask mScanChannels;
    uint8_t          mScanChannel;
    uint16_t         mRestorePanId;
    bool             mScanning;

    otIpCounters mIpCounters;

#if OPENTHREAD_FTD
    FragmentPriorityEntry mFragmentEntries[kNumFragmentPriorityEntries];
    MessageQueue          mResolvingQueue;
    IndirectSender        mIndirectSender;
#endif

    DataPollSender mDataPollSender;
};

/**
 * @}
 *
 */

} // namespace ot

#endif // MESH_FORWARDER_HPP_