/*
 *
 *    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
 *      This file defines subscription client for Weave
 *      Data Management (WDM) profile.
 *
 */

#ifndef _WEAVE_DATA_MANAGEMENT_SUBSCRIPTION_CLIENT_CURRENT_H
#define _WEAVE_DATA_MANAGEMENT_SUBSCRIPTION_CLIENT_CURRENT_H

#include <Weave/Core/WeaveCore.h>

#include <Weave/Profiles/data-management/TraitCatalog.h>
#include <Weave/Profiles/data-management/TraitPathStore.h>
#include <Weave/Profiles/data-management/UpdateClient.h>
#include <Weave/Profiles/data-management/UpdateEncoder.h>
#include <Weave/Profiles/data-management/EventLogging.h>
#include <Weave/Profiles/status-report/StatusReportProfile.h>

namespace nl {
namespace Weave {
namespace Profiles {
namespace WeaveMakeManagedNamespaceIdentifier(DataManagement, kWeaveManagedNamespaceDesignation_Current) {

typedef uint32_t PropertyPathHandle;
typedef uint16_t PropertySchemaHandle;
typedef uint16_t PropertyDictionaryKey;
typedef uint16_t TraitDataHandle;

/**
 * @class IWeaveWDMMutex
 *
 * @brief Interface of a mutex object. Mutexes of this type are implemented by the application
 * and used in WDM to protect data structures that can be accessed from multiple threads.
 * Implementations of this interface must behave like a recursive lock.
 */

class IWeaveWDMMutex
{
public:
    virtual void Lock(void)   = 0;
    virtual void Unlock(void) = 0;
};

class SubscriptionClient
{
public:
    enum
    {
        kNoTimeOut = 0,

        // Note the WDM spec says 0x7FFFFFFF, but Weave implementation can only hold timeout of much shorter
        // 32-bit in milliseconds, which is about 1200 hours
        kMaxTimeoutSec = 3600000,
    };

    enum EventID
    {
        /**
         * Marks the end of this subscription. The parameters sent to the
         * ::nl::Weave::Profiles::DataManagement_Current::SubscriptionClient::EventCallback
         * will indicate whether a resubscribe will be automatically attempted.
         *
         * During the event handler call, the state of the client will be `Terminated`.
         * If no retry will be attempted, the state of the client will transition to
         * `Initialized` when the event handler returns.  Otherwise, the state will
         * transition to `ResubscribeHoldoff` and an attempt will be made to re-establish
         * the subscription after the hold-off time.
         *
         * The application may call AbortSubscription() or Free() in this state.
         *
         * The parameters sent will also include an error code indicating the
         * reason for ending the subscription.
         *
         * The subscription could have been terminated for a number of reasons
         * (WRM ACK missing, ExchangeContext allocation failure, response
         * timeout,...)  Some possible error codes generated by the client:
         *
         * |Error code | Meaning |
         * |-----------|---------|
         * | #WEAVE_ERROR_INVALID_MESSAGE_TYPE | An unrecognized message is received. |
         * | #WEAVE_ERROR_TIMEOUT | An ack is not received or a liveness check fails.|
         * | #WEAVE_ERROR_INCORRECT_STATE | Messages are received in an unexpected state. |
         * | #WEAVE_ERROR_STATUS_REPORT_RECEIVED | A status report is received. |
         * | #WEAVE_ERROR_INVALID_ARGUMENT | Subscribe request fields are invalid. |
         */
        kEvent_OnSubscriptionTerminated = 1,

        /**
         * Generated after the binding has been prepared and ExchangeContext has
         * been set up but prior to any messages being sent.  This is the last
         * chance for an application to adjust ExchangeContext settings, `mEC`
         * is valid and can be tuned for timeout settings.  The application must
         * not touch other fields in the client and must not close the
         * ExchangeContext.
         */
        kEvent_OnExchangeStart = 2,

        /**
         * Sent when the engine is ready to send the SubscribeRequest.  The
         * application is expected to fill in the paths that it wants to
         * subscribe to.
         */
        kEvent_OnSubscribeRequestPrepareNeeded = 3,

        /**
         * Generated upon a successful establishment of the subscription.  The
         * application may call EndSubscription(), AbortSubscription(), or
         * Free() at this point.
         */
        kEvent_OnSubscriptionEstablished = 4,

        /**
         * Generated on a receit of a NotificationRequest. The application may
         * call EndSubscription(), AbortSubscription(), or Free() at this point.
         */
        kEvent_OnNotificationRequest = 5,

        /**
         * Generated when the SubscriptionEngine finishes proceesing a
         * NotificationRequest message. The application may call
         * EndSubscription(), AbortSubscription(), or Free() at this point.
         */
        kEvent_OnNotificationProcessed = 6,

        /**
         * Generated when the SubscriptionEngine encountes an event stream
         * within the NotificationRequest message. The application may call
         * EndSubscription(), AbortSubscription(), or Free() at this point.
         */
        kEvent_OnEventStreamReceived = 7,

        /**
         * An event indicating subscription activity.  It is generated whenever
         * the client receives an indication on subscription activity; this
         * includes successful subscription establishment, a reception of a
         * NotificationRequest or a receipt of a status report in response to
         * the SubscribeConfirm message.
         */
        kEvent_OnSubscriptionActivity = 8,

#if WEAVE_CONFIG_ENABLE_WDM_UPDATE
        /**
         * An event denoting the completion of the update.  Event parameters
         * will indicate whether the update of a specific trait path has
         * succeeded or failed.
         */
        kEvent_OnUpdateComplete = 9,

        /**
         * An event denoting that all paths in the update set have been
         * processed by the peer, and no more paths need to be updated.
         */
        kEvent_OnNoMorePendingUpdates = 10,
#endif // WEAVE_CONFIG_ENABLE_WDM_UPDATE
    };

    struct LastObservedEvent
    {
        uint64_t mSourceId;
        uint8_t mImportance;
        uint64_t mEventId;
    };

    // union of structures for each event some of them might be empty
    union InEventParam
    {
        void Clear(void) { memset(this, 0, sizeof(*this)); }

        struct
        {
            WEAVE_ERROR mReason;

            bool mIsStatusCodeValid;
            uint32_t mStatusProfileId;
            uint16_t mStatusCode;
            ReferencedTLVData * mAdditionalInfoPtr;
            bool mWillRetry;

            SubscriptionClient * mClient;
        } mSubscriptionTerminated;

        struct
        {
            // Do not close the EC
            nl::Weave::ExchangeContext * mEC;
            SubscriptionClient * mClient;
        } mExchangeStart;

        struct
        {
            SubscriptionClient * mClient;
        } mSubscribeRequestPrepareNeeded;

        struct
        {
            uint64_t mSubscriptionId;
            SubscriptionClient * mClient;
        } mSubscriptionEstablished;

        struct
        {
            // Do not close the EC
            nl::Weave::ExchangeContext * mEC;

            // Do not modify the message content
            PacketBuffer * mMessage;
            SubscriptionClient * mClient;
        } mNotificationRequest;

        struct
        {
            SubscriptionClient * mClient;
        } mNotificationProcessed;

        struct
        {
            nl::Weave::TLV::TLVReader * mReader;
            SubscriptionClient * mClient;
        } mEventStreamReceived;

        struct
        {
            SubscriptionClient * mClient;
        } mSubscriptionActivity;

#if WEAVE_CONFIG_ENABLE_WDM_UPDATE
        struct
        {
            WEAVE_ERROR mReason;
            uint32_t mStatusProfileId;
            uint16_t mStatusCode;
            TraitDataHandle mTraitDataHandle;
            PropertyPathHandle mPropertyPathHandle;
            SubscriptionClient * mClient;
            bool mWillRetry;
        } mUpdateComplete;
#endif // WEAVE_CONFIG_ENABLE_WDM_UPDATE
    };

    union OutEventParam
    {
        void Clear(void) { memset(this, 0, sizeof(*this)); }

        struct
        {
            TraitPath * mPathList;                   ///< Pointer to a list of trait paths
            VersionedTraitPath * mVersionedPathList; ///< Pointer to a list of versioned trait paths. If both this and mPathList are
                                                     ///< non-NULL, the versioned path list is selected
            size_t mPathListSize;                    ///< Number of trait paths in mPathList
            LastObservedEvent * mLastObservedEventList; ///< A list of the last known events received by the subscriber
            size_t mLastObservedEventListSize;          ///< Number of observed events in mLastObservedEventList
            uint32_t mTimeoutSecMin;                    ///< Field specifying lower bound of liveness timeout
            uint32_t mTimeoutSecMax;                    ///< Field specifying upper bound of liveness timeout
            uint64_t mSubscriptionId;                   ///< The subscription ID to use for a mutual subscription
            bool mNeedAllEvents;                        ///< Indicates whether the subscriber is interested in events
        } mSubscribeRequestPrepareNeeded;
    };

    struct ResubscribeParam
    {
        typedef enum
        {
            kSubscription,
            kUpdate
        } RequestType;
        WEAVE_ERROR mReason;      ///< Error received on most recent failure
        uint32_t mNumRetries;     ///< Number of retries, reset on a successful attempt
        RequestType mRequestType; ///< Request being backed off
    };

    /**
     * @brief Callback to pass subscription events to application.
     *
     * @param[in] aAppState     App state pointer set during initialization of
     *                          the SubscriptionClient.
     *
     * @param[in] aEvent        Indicates which event is happening
     *
     * @param[in] aInParam      Struct with additional details about the event
     *
     * @param[out] aOutParam    Information passed back by the application
     */
    typedef void (*EventCallback)(void * const aAppState, EventID aEvent, const InEventParam & aInParam, OutEventParam & aOutParam);

    static void DefaultEventHandler(EventID aEvent, const InEventParam & aInParam, OutEventParam & aOutParam);

    /**
     * @brief Callback to fetch the interval of time to wait before the next
     * resubscribe. Applications are allowed to abort/free in this function
     * if they've decided to give up on resubscribing.
     *
     * @param[in] aAppState         App state pointer set during initialization of
     *                              the SubscriptionClient.
     *
     * @param[in] aInParam          Struct with additional details about the retry
     *
     * @param[out] aOutIntervalMsec Time in milliseconds to wait before next retry
     */
    typedef void (*ResubscribePolicyCallback)(void * const aAppState, ResubscribeParam & aInParam, uint32_t & aOutIntervalMsec);

    static void DefaultResubscribePolicyCallback(void * const aAppState, ResubscribeParam & aInParam, uint32_t & aOutIntervalMsec);

    void InitiateSubscription(void);
    void InitiateCounterSubscription(const uint32_t aLivenessTimeoutSec);

    Binding * GetBinding(void) const;

    uint64_t GetPeerNodeId(void) const;

    /**
     * @brief
     *   End the subscription.
     *
     * When #WDM_ENABLE_SUBSCRIPTION_CANCEL compile-time option is enabled,
     * gracefully end the subscription by sending a CancelRequest to the peer.
     * The resources associated with the subscription are freed on response
     * from the peer or on timeout.  When the option is disabled, the call is
     * equivalent to AbortSubscription().
     */
    WEAVE_ERROR EndSubscription(void);

    /**
     * @brief
     *  Abort the subscription.
     *
     * Immediately stop accepting all traffic associated with the subscription,
     * and release all underlying communication resources.  The
     * SubscriptionClient object itself remains valid and may be used again.
     */
    void AbortSubscription(void);

    /**
     * @brief
     *   Free this SubscriptionClient object.
     *
     * Calls AbortSubscription() if necessary and releases the refcount on this
     * SubscriptionClient object.  Under correct usage, this should enable the
     * object to be returned to the object pool
     */
    void Free(void);

    WEAVE_ERROR GetSubscriptionId(uint64_t * const apSubscriptionId);

    uint32_t GetLivenessTimeoutMsec(void) const { return mLivenessTimeoutMsec; };
    void SetLivenessTimeoutMsec(uint32_t val) { mLivenessTimeoutMsec = val; }

    void EnableResubscribe(ResubscribePolicyCallback aCallback);
    void DisableResubscribe(void);
    void ResetResubscribe(void);

    bool IsInProgressOrEstablished()
    {
        return (mCurrentState >= kState_InProgressOrEstablished_Begin && mCurrentState <= kState_InProgressOrEstablished_End);
    }

    bool IsRetryEnabled() { return (mResubscribePolicyCallback != NULL); }

    bool IsEstablished() { return (mCurrentState >= kState_Established_Begin && mCurrentState <= kState_Established_End); }
    bool IsEstablishedIdle() { return (mCurrentState == kState_SubscriptionEstablished_Idle); }
    bool IsFree() { return (mCurrentState == kState_Free); }
    bool IsCanceling() const { return (mCurrentState == kState_Canceling); }
    bool IsTerminated() { return (mCurrentState == kState_Terminated); }
    bool IsInResubscribeHoldoff() { return (mCurrentState == kState_Resubscribe_Holdoff); }

    void IndicateActivity(void);

#if WEAVE_CONFIG_ENABLE_WDM_UPDATE
    void LockUpdateMutex(void);
    void UnlockUpdateMutex(void);

    WEAVE_ERROR FlushUpdate();
    WEAVE_ERROR FlushUpdate(bool aForce);
    WEAVE_ERROR SetUpdated(TraitUpdatableDataSink * aDataSink, PropertyPathHandle aPropertyHandle, bool aIsConditional);
    void DiscardUpdates();
    void SuspendUpdateRetries();
    void OnCatalogChanged();

    bool IsUpdatePendingOrInProgress() { return (kPendingSetEmpty != mPendingSetState || IsUpdateInProgress()); }
#endif // WEAVE_CONFIG_ENABLE_WDM_UPDATE

private:
    friend class SubscriptionEngine;
    friend class TestTdm;
    friend class TestWdm;
    friend class WdmUpdateEncoderTest;
    friend class MockWdmSubscriptionInitiatorImpl;
    friend class TraitDataSink;
    friend class TraitSchemaEngine;
    friend class UpdateDirtyPathFilter;
    friend class UpdateDictionaryDirtyPathCut;
    friend class UpdateEncoder;

    enum ClientState
    {
        kState_Free                                 = 0,
        kState_Initialized                          = 1,
        kState_Subscribing                          = 2,
        kState_Subscribing_IdAssigned               = 3,
        kState_SubscriptionEstablished_Idle         = 4,
        kState_SubscriptionEstablished_Confirming   = 5,
        kState_Canceling                            = 6,
        kState_Resubscribe_Holdoff                  = 7,
        kState_Terminated                           = 8,

        kState_NotifyDataSinkOnAbort_Begin          = kState_Subscribing,
        kState_NotifyDataSinkOnAbort_End            = kState_Canceling,
        kState_TimerTick_Begin                      = kState_Subscribing,
        kState_TimerTick_End                        = kState_Resubscribe_Holdoff,

        // Note that these are the same as the allowed states in NotificationRequestHandler
        kState_InProgressOrEstablished_Begin        = kState_Subscribing,
        kState_InProgressOrEstablished_End          = kState_SubscriptionEstablished_Confirming,

        kState_Established_Begin                    = kState_SubscriptionEstablished_Idle,
        kState_Established_End                      = kState_SubscriptionEstablished_Confirming,
    };

    ClientState mCurrentState;

    /**
     * The runtime configuration; i.e. the desired state of the Client.
     */
    enum ClientConfig
    {
        kConfig_Down,             /**< The default configuration: no subscription, no binding.
                                       The client comes back to this configuration automatically if the responder
                                       sends a Cancel request. */
        kConfig_Initiator,        /**< Subscribe as an initiator */
        kConfig_CounterSubscriber /**< Start a "counter subscription" */
    };

    bool IsInitiator() { return mConfig == kConfig_Initiator; }
    bool IsCounterSubscriber() { return mConfig == kConfig_CounterSubscriber; }
    bool ShouldSubscribe() { return mConfig > kConfig_Down; }

    ClientConfig mConfig;
    bool mPrevIsPartialChange;
#if WDM_ENABLE_PROTOCOL_CHECKS
    TraitDataHandle mPrevTraitDataHandle;
#endif

    int8_t mRefCount;

    Binding * mBinding;
    nl::Weave::ExchangeContext * mEC;

    void * mAppState;
    EventCallback mEventCallback;

    Binding::EventCallback mAppBindingCallback;
    void * mAppBindingState;

    ResubscribePolicyCallback mResubscribePolicyCallback;

    TraitCatalogBase<TraitDataSink> * mDataSinkCatalog;

    ExchangeContext::Timeout mInactivityTimeoutDuringSubscribingMsec;
    uint32_t mLivenessTimeoutMsec;
    uint64_t mSubscriptionId;

    // retry params
    uint32_t mRetryCounter;

    // Do nothing
    SubscriptionClient(void);

    void InitAsFree(void);
    void Reset(void);

    // AddRef to Binding
    // store pointers to binding and delegate
    // null out EC
    WEAVE_ERROR Init(Binding * const apBinding, void * const apAppState, EventCallback const aEventCallback,
                     const TraitCatalogBase<TraitDataSink> * const apCatalog,
                     const uint32_t aInactivityTimeoutDuringSubscribingMsec, IWeaveWDMMutex * aUpdateMutex);

    void _InitiateSubscription(void);
    WEAVE_ERROR SendSubscribeRequest(void);

    void _Cleanup();

    WEAVE_ERROR ProcessDataList(nl::Weave::TLV::TLVReader & aReader);

    void _AddRef(void);
    void _Release(void);

    void TerminateSubscription(WEAVE_ERROR aReason, Profiles::StatusReporting::StatusReport * aStatusReport, bool suppressAppCallback);
    WEAVE_ERROR _PrepareBinding(void);

    WEAVE_ERROR ReplaceExchangeContext(void);

    void FlushExistingExchangeContext(const bool aAbortNow = false);

    void NotificationRequestHandler(nl::Weave::ExchangeContext * aEC, const nl::Inet::IPPacketInfo * aPktInfo,
                                    const nl::Weave::WeaveMessageInfo * aMsgInfo, PacketBuffer * aPayload);

#if WDM_ENABLE_SUBSCRIPTION_CANCEL
    void CancelRequestHandler(nl::Weave::ExchangeContext * aEC, const nl::Inet::IPPacketInfo * aPktInfo,
                              const nl::Weave::WeaveMessageInfo * aMsgInfo, PacketBuffer * aPayload);
#endif // WDM_ENABLE_SUBSCRIPTION_CANCEL

    void TimerEventHandler(void);
    WEAVE_ERROR RefreshTimer(void);

    void SetRetryTimer(WEAVE_ERROR aReason); // TODO: rename to SetResubscribeTimer()
    void CancelSubscriptionTimer(void);

    void MoveToState(const ClientState aTargetState);

    const char * GetStateStr(void) const;

    static void BindingEventCallback(void * const apAppState, const Binding::EventType aEvent,
                                     const Binding::InEventParam & aInParam, Binding::OutEventParam & aOutParam);
    static void OnTimerCallback(System::Layer * aSystemLayer, void * aAppState, System::Error aErrorCode);
    static void DataSinkOperation_NoMoreData(void * const apOpState, TraitDataSink * const apDataSink);
    static void OnSendError(ExchangeContext * aEC, WEAVE_ERROR aErrorCode, void * aMsgSpecificContext);
    static void OnResponseTimeout(nl::Weave::ExchangeContext * aEC);
    static void OnMessageReceivedFromLocallyInitiatedExchange(nl::Weave::ExchangeContext * aEC,
                                                              const nl::Inet::IPPacketInfo * aPktInfo,
                                                              const nl::Weave::WeaveMessageInfo * aMsgInfo, uint32_t aProfileId,
                                                              uint8_t aMsgType, PacketBuffer * aPayload);

#if WEAVE_CONFIG_ENABLE_WDM_UPDATE

    IWeaveWDMMutex * mUpdateMutex;

    struct UpdateRequestContext
    {
        void Reset();

        size_t mItemInProgress;
        PropertyPathHandle mNextDictionaryElementPathHandle;
        uint32_t mUpdateRequestIndex;
        bool mIsPartialUpdate;
    };
    uint32_t mUpdateRetryCounter;
    bool mSuspendUpdateRetries;
    bool mUpdateRetryScheduled;
    bool mUpdateFlushScheduled;

    void StartUpdateRetryTimer(WEAVE_ERROR aReason);
    static void OnUpdateTimerCallback(System::Layer * aSystemLayer, void * aAppState, System::Error);
    static void OnUpdateScheduleWorkCallback(System::Layer * aSystemLayer, void * aAppState, System::Error);
    void UpdateTimerEventHandler(void);

    uint32_t GetMaxUpdateSize(void) const { return mMaxUpdateSize == 0 ? UINT16_MAX : mMaxUpdateSize; }
    void SetMaxUpdateSize(const uint32_t aMaxPayload);

    // Methods to encode and send update requests
    void FormAndSendUpdate();
    WEAVE_ERROR SendSingleUpdateRequest(void);
    static WEAVE_ERROR AddElementFunc(UpdateEncoder * aEncoder, void * apCallState, TLV::TLVWriter & aOuterWriter);
    void SetUpdateStartVersions(void);

    // Methods to handle update response and exchange failures (OnResponseTimeout, OnSendError)
    void OnUpdateResponse(WEAVE_ERROR aReason, nl::Weave::Profiles::StatusReporting::StatusReport * apStatus);
    void OnUpdateNoResponse(WEAVE_ERROR aReason);
    static bool WillRetryUpdate(WEAVE_ERROR aErr, uint32_t aStatusProfileId, uint16_t aStatusCode);

    // Methods to purge obsolete pending paths
    WEAVE_ERROR PurgePendingUpdate(void);
    void MarkFailedPendingPaths(TraitDataHandle aTraitDataHandle, TraitUpdatableDataSink & aSink,
                                const DataVersion & aLatestVersion);
    WEAVE_ERROR PurgeFailedPendingPaths(WEAVE_ERROR aErr, size_t & aCount);

    // Methods to handle potential data loss due to notifications received with updates pending or in progress
    bool FilterNotifiedPath(TraitDataHandle aTraitDataHandle, PropertyPathHandle aPropertyPathHandle,
                            const TraitSchemaEngine * const aSchemaEngine);
    void ClearPotentialDataLoss(TraitDataHandle aTraitDataHandle, TraitUpdatableDataSink & aUpdatableSink);
    bool CheckForSinksWithDataLoss();
    static void CheckForSinksWithDataLossIteratorCb(void * aDataSink, TraitDataHandle aDataHandle, void * aContext);

    // Methods to fail everything and notify the application
    void PurgeAndNotifyFailedPaths(WEAVE_ERROR aErr, TraitPathStore & aPathStore, size_t & aCount);

    // Methods to manage the pending set and in-progress list
    enum PendingSetState
    {
        kPendingSetEmpty,
        kPendingSetOpen,
        kPendingSetReady
    };
    void SetPendingSetState(PendingSetState aState);
    WEAVE_ERROR MovePendingToInProgress(void);
    WEAVE_ERROR AddItemPendingUpdateSet(const TraitPath & aItem, const TraitSchemaEngine * const aSchemaEngine);
    WEAVE_ERROR MoveInProgressToPending(void);

    // Tracking if a payload is in flight
    bool IsUpdateInFlight() { return mUpdateInFlight; }
    void SetUpdateInFlight() { mUpdateInFlight = true; }
    void ClearUpdateInFlight() { mUpdateInFlight = false; }

    // Knowing if an update is pending or in progress
    bool IsUpdateInProgress() { return (false == mInProgressUpdateList.IsEmpty()); }
    bool IsReadyToSendNewUpdate() { return (mPendingSetState == kPendingSetReady && false == IsUpdateInProgress()); }

    // Methods to notify the application
    void UpdateCompleteEventCbHelper(const TraitPath & aTraitPath, uint32_t aStatusProfileId, uint16_t aStatusCode,
                                     WEAVE_ERROR aReason, bool aWillRetry);
    void NoMorePendingEventCbHelper(void);

    // Other methods related to mUpdateClient
    static void UpdateEventCallback(void * const aAppState, UpdateClient::EventType aEvent,
                                    const UpdateClient::InEventParam & aInParam, UpdateClient::OutEventParam & aOutParam);
    void AbortUpdates(WEAVE_ERROR);

    void ConfigureUpdatableSinks(void);

    static void MovePendingToInProgressUpdatableSinkTrait(void * aDataSink, TraitDataHandle aDataHandle, void * aContext);
    static void RefreshUpdatableSinkTrait(void * aDataSink, TraitDataHandle aDataHandle, void * aContext);
    static void PurgePendingUpdatableSinkTrait(void * aDataSink, TraitDataHandle aDataHandle, void * aContext);
    static void ConfigureUpdatableSinkTrait(void * aDataSink, TraitDataHandle aDataHandle, void * aContext);
    static void CleanupUpdatableSinkTrait(void * aDataSink, TraitDataHandle aDataHandle, void * aContext);

    bool mResubscribeNeeded;
    UpdateRequestContext mUpdateRequestContext;
    uint16_t mMaxUpdateSize;
    bool mUpdateInFlight;

    // Flags used with mInProgressUpdateList
    enum
    {
        kFlag_ForceMerge = 0x4, /**< In UpdateRequest, DataElements are encoded with the "replace" format by
                                  default; this flag is used to force the encoding of
                                  dictionaries so that the items are merged.
                                  */
        kFlag_Private = 0x8,    /**< The path was created internally by the engine
                                  to encode a dictionary in its own separate
                                  DataElement; the application is notified about it
                                  only if the update fails.
                                  */

    };

    PendingSetState mPendingSetState;
    TraitPathStore mPendingUpdateSet;
    TraitPathStore::Record mPendingStore[WDM_UPDATE_MAX_ITEMS_IN_TRAIT_DIRTY_PATH_STORE];

    TraitPathStore mInProgressUpdateList;
    TraitPathStore::Record mInProgressStore[WDM_UPDATE_MAX_ITEMS_IN_TRAIT_DIRTY_PATH_STORE];

    UpdateClient mUpdateClient;
    UpdateEncoder mUpdateEncoder;
#endif // WEAVE_CONFIG_ENABLE_WDM_UPDATE
};

}; // namespace WeaveMakeManagedNamespaceIdentifier(DataManagement, kWeaveManagedNamespaceDesignation_Current)
}; // namespace Profiles
}; // namespace Weave
}; // namespace nl

#endif // _WEAVE_DATA_MANAGEMENT_SUBSCRIPTION_CLIENT_CURRENT_H