/*
 *
 *    Copyright (c) 2016-2017 Nest Labs, Inc.
 *    All rights reserved.
 *
 *    Licensed under the Apache License, Version 2.0 (the "License");
 *    you may not use this file except in compliance with the License.
 *    You may obtain a copy of the License at
 *
 *        http://www.apache.org/licenses/LICENSE-2.0
 *
 *    Unless required by applicable law or agreed to in writing, software
 *    distributed under the License is distributed on an "AS IS" BASIS,
 *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *    See the License for the specific language governing permissions and
 *    limitations under the License.
 */

/**
 *  @file
 *
 *  @brief
 *    Implementations for the ClientNotifier auxiliary class.
 *
 *  This file provides implementations for the ClientNotifier auxiliary
 *  class, which is a employed when support for subscription and
 *  notification is desired for a WDM client. See the document, "Nest
 *  Weave-Data Management Protocol" document for a complete
 *  description.
 */

#ifndef __STDC_FORMAT_MACROS
#define __STDC_FORMAT_MACROS
#endif // __STDC_FORMAT_MACROS

#include <Weave/Core/WeaveConfig.h>

#include <Weave/Support/CodeUtils.h>

#if WEAVE_CONFIG_WDM_ALLOW_CLIENT_SUBSCRIPTION

#include <Weave/Profiles/data-management/Legacy/WdmManagedNamespace.h>
#include <Weave/Profiles/data-management/DataManagement.h>

using namespace ::nl;
using namespace ::nl::Inet;
using namespace ::nl::Weave;
using namespace ::nl::Weave::TLV;
using namespace ::nl::Weave::Profiles;
using namespace ::nl::Weave::Profiles::Common;
using namespace ::nl::Weave::Profiles::DataManagement;
using namespace ::nl::Weave::Profiles::StatusReporting;

/*
 *  This is the listener or unsolicited message handler installed in
 *  the Weave exchange manager when the client wishes to receive
 *  notifications. Once installed, it is called whenever a WDM
 *  notification is received.
 */

static void ClientListener(ExchangeContext *ec,
                           const IPPacketInfo *pktInfo,
                           const WeaveMessageInfo *msgInfo,
                           uint32_t profileId,
                           uint8_t msgType,
                           PacketBuffer *payload)
{
    WEAVE_ERROR err = WEAVE_NO_ERROR;

    ClientNotifier *n = static_cast<ClientNotifier*>(ec->AppState);

    if (msgType == kMsgType_NotifyRequest)
        err = n->DispatchNotifyIndication(ec, payload);

    else
        err = WEAVE_ERROR_INVALID_MESSAGE_TYPE;

    if (err != WEAVE_NO_ERROR)
        WeaveLogError(DataManagement, "ClientListener() - %s", ErrorStr(err));

    PacketBuffer::Free(payload);
}

/**
 *  @brief
 *    The default constructor for the Subscription object used by the
 *    ClientNotifier.
 *
 *  @note
 *    Subscriptions must be initialize using Init() before use.
 */

ClientNotifier::Subscription::Subscription(void)
{
    Free();
}

/**
 *  @brief
 *    The destructor for the Subscription object used by the
 *    ClientNotifier.
 */

ClientNotifier::Subscription::~Subscription(void) { Free(); }

/**
 *  @brief
 *    Initialize a Subscription object.
 *
 *  This basically sets up the state required for a subscription to
 *  operate. In particular, a subscription must have a client to refer
 *  back to, at least one specified topic ID and a concrete publisher.
 *
 *  @note
 *    Subscriptions in WDM have a number of forms. They may be
 *    unilateral subscriptions to broadcast notifications from a
 *    publisher and identified with a well-known topic identifier, or
 *    they may be subscriptions to unicast notifications, which
 *    require a request/response protocol to establish. The latter
 *    form may again be established using a well-know topic ID or by
 *    including an arbitrary list of paths in the subscribe
 *    request. See the WDM specification for further details.
 *
 *  @param [in]     aAssignedId     A reference to the publisher-
 *                                  assigned "working" topic ID for
 *                                  this subscription. This may be
 *                                  unspecified if the subscription is
 *                                  being made unilaterally.
 *
 *  @param [in]     aRequestedId    A reference to the well-known
 *                                  topic ID, if any, under which the
 *                                  subscription was requested
 *
 *  @param [in]     aPublisherId    A reference to the 64-bit node ID
 *                                  of the publisher. In the case
 *                                  where the subscription is to the
 *                                  Weave service, the WDM service
 *                                  endpoint ID may appear here.
 *
 *  @param [in]     aClient         A pointer to the DMClient on
 *                                  behalf of which the subscription
 *                                  is being made. In particular this
 *                                  object should be a concrete
 *                                  subclass of DMClient containing
 *                                  implementations of the relevant
 *                                  indication methods.
 *
 *  @retval #WEAVE_NO_ERROR On success.
 *
 *  @retval #WEAVE_ERROR_INVALID_ARGUMENT If one or more of the
 *  arguments has an invalid value.
 */

WEAVE_ERROR ClientNotifier::Subscription::Init(const TopicIdentifier &aAssignedId,
                                               const TopicIdentifier &aRequestedId,
                                               const uint64_t &aPublisherId,
                                               DMClient *aClient)
{
    WEAVE_ERROR err = WEAVE_NO_ERROR;

    if ((aAssignedId != kTopicIdNotSpecified || aRequestedId != kTopicIdNotSpecified) &&
        aPublisherId != kNodeIdNotSpecified &&
        aClient != NULL)
    {
        mAssignedId = aAssignedId;
        mRequestedId = aRequestedId;
        mPublisherId = aPublisherId;
        mClient = aClient;
    }

    else
    {
        err = WEAVE_ERROR_INVALID_ARGUMENT;
    }

    return err;
}

/**
 *  @brief
 *    Free a client-side subscription.
 *
 *  This method simply blows away the subscription-related state.
 */

void ClientNotifier::Subscription::Free(void)
{
    mAssignedId = kTopicIdNotSpecified;
    mRequestedId = kTopicIdNotSpecified;
    mPublisherId = kNodeIdNotSpecified;
    mClient = NULL;
}

/**
 *  @brief
 *    The default constructor for a client notifier.
 *
 *  @note
 *    No further initialization is required before use.
 */

ClientNotifier::ClientNotifier(void)
{
    Clear();
}

/**
 *  @brief
 *    The destructor for a client notifier.
 *
 *  The destructor attempts to disable subscription on the theory that,
 *  if the notifier is going away, we don't want a listener running
 *  either.
 */

ClientNotifier::~ClientNotifier(void)
{
    if (mExchangeMgr)
        mExchangeMgr->UnregisterUnsolicitedMessageHandler(kWeaveProfile_WDM, kMsgType_NotifyRequest);

    Clear();
}

/**
 *  @brief
 *    Deliver a WDM notification message to the appropriate client.
 *
 *  When a notification arrives, this method checks the notifier
 *  subscription table, looks up the client for which the message is
 *  destined, and delivers the message by calling the relevant
 *  indication method. If no relevant subscription is found, it sends
 *  back a status report to that effect.
 *
 *  @param [in]     aResponseCtx    A pointer to the exchange context
 *                                  under which the message was
 *                                  delivered and which may be used to
 *                                  respond.
 *
 *  @parm [in]      payload         A pointer to an PacketBuffer
 *                                  containing the notification message
 *                                  itself.
 *
 *  @return #WEAVE_NO_ERROR On success. Otherwise return a
 *  #WEAVE_ERROR associated with a failure to process or deliver the
 *  message.
 */

WEAVE_ERROR ClientNotifier::DispatchNotifyIndication(ExchangeContext *aResponseCtx, PacketBuffer *payload)
{
    WEAVE_ERROR err;
    MessageIterator it(payload);
    bool indicated = false;

    TopicIdentifier topicId;
    ReferencedTLVData dataList;

    uint64_t peerId = aResponseCtx->PeerNodeId;

    StatusReport report;

    WeaveLogProgress(DataManagement, "ClientNotifier::DispatchNotifyIndication()");

    err = it.read64(&topicId);
    SuccessOrExit(err);

    WeaveLogProgress(DataManagement, " - topicId = 0x%" PRIx64, topicId);

    err = ReferencedTLVData::parse(it, dataList);
    SuccessOrExit(err);

    for (int i = 0; i < kNotifierTableSize; i++)
    {
        Subscription &s = mNotifierTable[i];

        if (s.CheckSubscription(topicId, peerId))
        {
            indicated = true;

            WeaveLogProgress(DataManagement, " - informing client");

            err = s.mClient->NotifyIndication(topicId, dataList);
        }
    }

    /*
     * if we found a subscription here AND the subscription was
     * explicit (we can tell because the publisher supplied and is
     * using a working topic ID), we should tell the subscription
     * manager on the other side that SOMETHING is still live over
     * here. otherwise we should inform them that the subscription has
     * magically vanished.
     */

    if (IsPublisherSpecific(topicId))
    {
        if (indicated)
        {
            report.init(kWeaveProfile_Common, kStatus_Success);
        }

        else
        {
            err = WEAVE_ERROR_UNKNOWN_TOPIC;

            report.init(kWeaveProfile_WDM, kStatus_UnknownTopic);
        }

        SendStatusReport(aResponseCtx, report);
    }

exit:
    /*
     * in this case, since we're not passing the context on to the
     * NHL, we close it.
     */

    aResponseCtx->Close();

    WeaveLogProgress(DataManagement, "ClientNotifier::DispatchNotifyIndication() => %s", ErrorStr(err));

    return err;
}

/**
 *  @brief
 *    Check if a notifier has a particular subscription.
 *
 *  This method scans the subscription table looking for a subscription
 *  that matches the given parameters (see MatchSubscription()).
 *
 *  @param [in]     aTopicId        A reference to a topic ID to look
 *                                  for - may have the wild-card value
 *                                  kTopicIdNotSpecified.
 *
 *  @param [in]     aPublisherId    A reference to a 64-bit publisher
 *                                  ID or service endpoint to look for
 *                                  - may have the wild-card value
 *                                  kNodeIdNotSpecified or the
 *                                  broadcast value kAnyNodeId.
 *
 *  @param [in]     aClient         A pointer to the DMClient on behalf
 *                                  of which the subscription is in use.
 *
 *  @return True if a match is found. Otherwise return false.
 */

bool ClientNotifier::HasSubscription(const TopicIdentifier &aTopicId, const uint64_t &aPublisherId, DMClient *aClient) const
{
    bool result = false;

    for (int i = 0; i < kNotifierTableSize; i++)
    {
        const Subscription &s = mNotifierTable[i];

        if (s.MatchSubscription(aTopicId, aPublisherId, aClient))
        {
            result = true;

            break;
        }
    }

    return result;
}

/**
 *  @brief
 *    Install a subscription in the table.
 *
 *  This method checks whether a subscription with the given parameters
 *  is already available in the subscription table and, if not,
 *  installs one.
 *
 *  @param [in]     aTopicId            A reference to the
 *                                      publisher-assigned "working"
 *                                      topic ID for this
 *                                      subscription.
 *
 *  @param [in]     aRequestedId        A reference to the well-known
 *                                      topic ID, if any, under which
 *                                      the subscription was
 *                                      requested. If the subscription
 *                                      was not requested in this way
 *                                      then the value may be
 *                                      kTopicIdNotSpecified.
 *
 *  @param [in]     aPublisherId        A reference to the 64-bit node
 *                                      ID or service endpoint ID of
 *                                      the publisher to which the
 *                                      subscription applies.
 *
 *  @param [in]     aClient             A pointer to the DMClient that
 *                                      requested the subscription.
 *
 *  @retval #WEAVE_NO_ERROR On success.
 *
 *  @retval #WEAVE_ERROR_NO_MEMORY If no subscription could be allocated.
 *
 *  @return Otherwise, an error reflecting the inability to install a
 *  subscription.
 */

WEAVE_ERROR ClientNotifier::InstallSubscription(const TopicIdentifier &aTopicId,
                                                const TopicIdentifier &aRequestedId,
                                                const uint64_t &aPublisherId,
                                                DMClient *aClient)
{
    WEAVE_ERROR err = WEAVE_ERROR_NO_MEMORY;

    /*
     * if the subscription already exists then there's nothing else to
     * do.
     */

    if (HasSubscription(aTopicId, aPublisherId, aClient))
    {
        err = WEAVE_NO_ERROR;
    }

    /*
     * otherwise, there exists the possiblity that a subscription with
     * the correct requested topic ID has been installed but the
     * working topic ID has not been assigned. if so, assign it.
     */

    else if (HasSubscription(aRequestedId, aPublisherId, aClient))
    {
        for (int i = 0; i < kNotifierTableSize; i++)
        {
            Subscription &s = mNotifierTable[i];

            if (s.MatchSubscription(aRequestedId, aPublisherId))
            {
                err = s.Init(aTopicId, aRequestedId, aPublisherId, aClient);

                break;
            }
        }
    }

    /*
     * otherwise just look for a free slot.
     */

    else
    {
        for (int i = 0; i < kNotifierTableSize; i++)
        {
            Subscription &s = mNotifierTable[i];

            if (s.IsFree())
            {
                /*
                 * deal with counting and start up the listener if
                 * this is the first installation.
                 */

                mSubscriptionCount++;

                if (mSubscriptionCount == 1)
                {

                    /*
                     * this is basically a hack pput here to try and
                     * get everything to build. NONE of this code
                     * should be lying around if subscription isn't
                     * allowed.
                     */

                    mExchangeMgr = aClient->mExchangeMgr;

                    err = mExchangeMgr->RegisterUnsolicitedMessageHandler(kWeaveProfile_WDM, kMsgType_NotifyRequest, ClientListener, this);
                    SuccessOrExit(err);
                }

                err = s.Init(aTopicId, aRequestedId, aPublisherId, aClient);

                break;
            }
        }
    }

exit:

    return err;
}

/**
 *  @brief
 *    Remove a subscription for the table.
 *
 *  If a subscription with the given parameters exists in the
 *  subscription table, it is removed.
 *
 *  @param [in]     aTopicId        A reference to a topic ID that
 *                                  applies to this subscription. This
 *                                  may be a publisher-assigned
 *                                  "working" ID or the well-known ID
 *                                  under which the subscription was
 *                                  requested.
 *
 *  @param [in]     aPublisherId    A reference to the 64-bit node ID
 *                                  or service endpoint ID of the
 *                                  publisher to which the
 *                                  subscription applies.
 *
 *  @param [in]     aClient         A pointer to the client that requested
 *                                  the subscription.
 */

void ClientNotifier::RemoveSubscription(const TopicIdentifier &aTopicId, const uint64_t &aPublisherId, DMClient *aClient)
{
    for (int i = 0; i < kNotifierTableSize; i++)
    {
        Subscription &s = mNotifierTable[i];

        if (s.MatchSubscription(aTopicId, aPublisherId, aClient))
        {
            /*
             * deal with counting and stop the listener if this is the
             * last subscription.
             */

            if (mSubscriptionCount > 0)
                mSubscriptionCount--;

            if (mSubscriptionCount == 0)
                mExchangeMgr->UnregisterUnsolicitedMessageHandler(kWeaveProfile_WDM, kMsgType_NotifyRequest);

            s.Free();
        }
    }
}

/**
 *  @brief
 *    Remove a subscription for the table and tell the next higher layer.
 *
 *  If a subscription with the given parameters exists in the
 *  subscription table, it is removed, and the UnsubscribeIndication()
 *  method on the client is called.
 *
 *  @param [in]     aTopicId        A reference to a topic ID that
 *                                  applies to this subscription. This
 *                                  may be a publisher-assigned
 *                                  "working" ID or the well-known ID
 *                                  under which the subscription was
 *                                  requested.
 *
 *  @param [in]     aPublisherId    A reference to the 64-bit node ID
 *                                  or service endpoint ID of the
 *                                  publisher to which the
 *                                  subscription applies.
 *
 *  @param [in]     aClient         A pointer to the DMClient that
 *                                  requested the subscription.
 *
 *  @param [in]     aReport         A reference to a status report
 *                                  describing the reason for failure.
 */

void ClientNotifier::FailSubscription(const TopicIdentifier &aTopicId, const uint64_t &aPublisherId, DMClient *aClient, StatusReport &aReport)
{
    for (int i = 0; i < kNotifierTableSize; i++)
    {
        Subscription &s = mNotifierTable[i];

        if (s.MatchSubscription(aTopicId, aPublisherId, aClient))
        {
            /*
             * deal with counting and stop the listener if this is the
             * last subscription.
             */

            if (mSubscriptionCount > 0)
                mSubscriptionCount--;

            if (mSubscriptionCount == 0)
                mExchangeMgr->UnregisterUnsolicitedMessageHandler(kWeaveProfile_WDM, kMsgType_NotifyRequest);

            aClient->UnsubscribeIndication(s.mPublisherId, s.mAssignedId, aReport);

            s.Free();
        }
    }
}

/**
 *  @brief
 *    Clear client notifier state.
 *
 *  This method just clears the notifier working state without call
 *  any indications to higher layers.
 */

void ClientNotifier::Clear(void)
{
    mSubscriptionCount = 0;

    for (int i = 0; i < kNotifierTableSize; i++)
    {
        Subscription &s = mNotifierTable[i];

        s.Free();
    }

    mExchangeMgr = NULL;
}

#endif // WEAVE_CONFIG_WDM_ALLOW_CLIENT_SUBSCRIPTION