/*
 *
 *    Copyright (c) 2015-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.
 */
// __STDC_FORMAT_MACROS must be defined for PRIX64 to be defined for pre-C++11 clib
#ifndef __STDC_FORMAT_MACROS
#define __STDC_FORMAT_MACROS
#endif // __STDC_FORMAT_MACROS

// it is important for this first inclusion of inttypes.h to have all the right switches turned ON
#include <inttypes.h>

#define WEAVE_CONFIG_BDX_NAMESPACE kWeaveManagedNamespace_Development

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

#include <Weave/Profiles/bulk-data-transfer/Development/BulkDataTransfer.h>
#include <Weave/Profiles/bulk-data-transfer/Development/BDXMessages.h>

#include <SystemLayer/SystemTimer.h>

#if HAVE_NEW
#include <new>
#else
inline void * operator new     (size_t, void * p) throw() { return p; }
inline void * operator new[]   (size_t, void * p) throw() { return p; }
#endif // HAVE_NEW

using namespace nl::Weave::TLV;

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

// Static instance: embedded platforms not always implement a proper
// C++ runtime; instead, the instance is initialized via placement new
// in CreateLoggingManangement.

static LoggingManagement sInstance;

LoggingManagement & LoggingManagement::GetInstance(void)
{
    return sInstance;
}

struct ReclaimEventCtx
{
    CircularEventBuffer *mEventBuffer;
    size_t mSpaceNeededForEvent;
};

WEAVE_ERROR LoggingManagement::AlwaysFail(nl::Weave::TLV::WeaveCircularTLVBuffer &inBuffer, void * inAppData, nl::Weave::TLV::TLVReader & inReader)
{
    return WEAVE_ERROR_NO_MEMORY;
}

WEAVE_ERROR LoggingManagement::CopyToNextBuffer(CircularEventBuffer *inEventBuffer)
{
    CircularTLVWriter writer;
    CircularTLVReader reader;
    WeaveCircularTLVBuffer checkpoint = inEventBuffer->mNext->mBuffer;
    WeaveCircularTLVBuffer *nextBuffer = &(inEventBuffer->mNext->mBuffer);
    WEAVE_ERROR err;

    // Set up the next buffer s.t. it fails if needs to evict an element
    nextBuffer->mProcessEvictedElement = AlwaysFail;

    writer.Init(nextBuffer);

    // Set up the reader s.t. it is positioned to read the head event
    reader.Init(&(inEventBuffer->mBuffer));

    err = reader.Next();
    SuccessOrExit(err);

    err = writer.CopyElement(reader);
    SuccessOrExit(err);

    err = writer.Finalize();
    SuccessOrExit(err);

exit:
    if (err != WEAVE_NO_ERROR)
    {
        inEventBuffer->mNext->mBuffer = checkpoint;
    }
    return err;
}

WEAVE_ERROR LoggingManagement::EnsureSpace(size_t inRequiredSpace)
{
    WEAVE_ERROR err = WEAVE_NO_ERROR;
    size_t requiredSpace = inRequiredSpace;
    CircularEventBuffer *eventBuffer = mEventBuffer;
    WeaveCircularTLVBuffer *circularBuffer;
    ReclaimEventCtx ctx;

    // check whether we actually need to do anything, exit if we don't
    VerifyOrExit(requiredSpace > eventBuffer->mBuffer.AvailableDataLength(), err = WEAVE_NO_ERROR);

    while (true)
    {
        circularBuffer = &(eventBuffer->mBuffer);
        // check that the request can ultimately be satisfied.
        VerifyOrExit(requiredSpace <= circularBuffer->GetQueueSize(), err = WEAVE_ERROR_BUFFER_TOO_SMALL);

        if (requiredSpace > circularBuffer->AvailableDataLength())
        {
            ctx.mEventBuffer = eventBuffer;
            ctx.mSpaceNeededForEvent = 0;

            circularBuffer->mProcessEvictedElement = EvictEvent;
            circularBuffer->mAppData = &ctx;
            err = circularBuffer->EvictHead();

            // one of two things happened: either the element was evicted,
            // or we figured out how much space we need to evict it into
            // the next buffer

            if (err != WEAVE_NO_ERROR)
            {
                VerifyOrExit(ctx.mSpaceNeededForEvent != 0, /* no-op, return err */);
                if (ctx.mSpaceNeededForEvent <= eventBuffer->mNext->mBuffer.AvailableDataLength())
                {
                    // we can copy the event outright.  copy event and
                    // subsequently evict head s.t. evicting the head
                    // element always succeeds.
                    // Since we're calling CopyElement and we've checked
                    // that there is space in the next buffer, we don't expect
                    // this to fail.
                    err = CopyToNextBuffer(eventBuffer);
                    SuccessOrExit(err);

                    // success; evict head unconditionally
                    circularBuffer->mProcessEvictedElement = NULL;
                    err = circularBuffer->EvictHead();
                    // if unconditional eviction failed, this
                    // means that we have no way of further
                    // clearing the buffer.  fail out and let the
                    // caller know that we could not honor the
                    // request
                    SuccessOrExit(err);
                    continue;
                }
                // we cannot copy event outright. We remember the
                // current required space in mAppData, we note the
                // space requirements for the event in the current
                // buffer and make that space in the next buffer.
                circularBuffer->mAppData = reinterpret_cast<void*>(requiredSpace);
                eventBuffer = eventBuffer->mNext;

                // Sanity check: Die here on null event buffer.  If
                // eventBuffer->mNext were null, then the `EvictBuffer`
                // in line 130 would have succeeded -- the event was
                // already in the final buffer.
                VerifyOrDie(eventBuffer != NULL);

                requiredSpace = ctx.mSpaceNeededForEvent;
            }
        }
        else
        {
            if (eventBuffer == mEventBuffer)
                break;
            eventBuffer = eventBuffer->mPrev;
            requiredSpace = reinterpret_cast<size_t>(eventBuffer->mBuffer.mAppData);
            err = WEAVE_NO_ERROR;
        }
    }

    // On exit, configure the top-level s.t. it will always fail to evict an element
    mEventBuffer->mBuffer.mProcessEvictedElement = AlwaysFail;
    mEventBuffer->mBuffer.mAppData = NULL;

exit:
    return err;
}


/**
 * @brief Helper function for writing event header and data according to event
 *   logging protocol.
 *
 * @param aContext[inout]   EventLoadOutContext, initialized with stateful
 *                          information for the buffer. State is updated
 *                          and preserved by BlitEvent using this context.
 *
 * @param inSchema[in]      Schema defining importance, profile ID, and
 *                          structure type of this event.
 *
 * @param inEventWriter[in] The callback to invoke to serialize the event data.
 *
 * @param inAppData[in]     Application context for the callback.
 *
 * @param inOptions[in]     EventOptions describing timestamp and other tags
 *                          relevant to this event.
 *
 */
WEAVE_ERROR LoggingManagement::BlitEvent(EventLoadOutContext *aContext,
                                         const EventSchema &inSchema,
                                         EventWriterFunct inEventWriter,
                                         void *inAppData,
                                         const EventOptions *inOptions)
{

    WEAVE_ERROR err = WEAVE_NO_ERROR;
    TLVWriter checkpoint = aContext->mWriter;
    TLVType containerType;

    VerifyOrExit(aContext->mCurrentEventID >= aContext->mStartingEventID,
                 /* no-op: don't write event, but advance current event ID */);

    VerifyOrExit(inOptions != NULL, err = WEAVE_ERROR_INVALID_ARGUMENT);
    VerifyOrExit(inOptions->timestampType != kTimestampType_Invalid,
                 err = WEAVE_ERROR_INVALID_ARGUMENT);

    err = aContext->mWriter.StartContainer(AnonymousTag, kTLVType_Structure, containerType);
    SuccessOrExit(err);

    // Event metadata

    // Importance
    err = aContext->mWriter.Put(ContextTag(kTag_EventImportance), static_cast<uint16_t>(inSchema.mImportance));
    SuccessOrExit(err);

    // If mFirst, record event ID
    if (aContext->mFirst)
    {
        err = aContext->mWriter.Put(ContextTag(kTag_EventID), aContext->mCurrentEventID);
        SuccessOrExit(err);
    }

    // Related Event processing
    if (inOptions->relatedEventID != 0)
    {
        err = aContext->mWriter.Put(ContextTag(kTag_RelatedEventImportance), static_cast<uint16_t>(inOptions->relatedImportance));
        SuccessOrExit(err);

        err = aContext->mWriter.Put(ContextTag(kTag_RelatedEventID), inOptions->relatedEventID);
        SuccessOrExit(err);
    }

    // if mFirst, record absolute time
    if (aContext->mFirst)
    {
#if WEAVE_CONFIG_EVENT_LOGGING_UTC_TIMESTAMPS
        if (inOptions->timestampType == kTimestampType_UTC)
        {
            err = aContext->mWriter.Put(ContextTag(kTag_EventUTCTimestamp),
                               inOptions->timestamp.utcTimestamp);
            SuccessOrExit(err);
        }
        else
#endif // WEAVE_CONFIG_EVENT_LOGGING_UTC_TIMESTAMPS
        {
            err = aContext->mWriter.Put(ContextTag(kTag_EventSystemTimestamp),
                               inOptions->timestamp.systemTimestamp);
            SuccessOrExit(err);
        }
    }
    // else record delta
    else
    {
#if WEAVE_CONFIG_EVENT_LOGGING_UTC_TIMESTAMPS
        if (inOptions->timestampType == kTimestampType_UTC)
        {
            int64_t deltatime = inOptions->timestamp.utcTimestamp - aContext->mCurrentUTCTime;
            err = aContext->mWriter.Put(ContextTag(kTag_EventDeltaUTCTime), deltatime);
            SuccessOrExit(err);
        }
        else
#endif // WEAVE_CONFIG_EVENT_LOGGING_UTC_TIMESTAMPS
        {
            int32_t deltatime = inOptions->timestamp.systemTimestamp - aContext->mCurrentTime;
            err = aContext->mWriter.Put(ContextTag(kTag_EventDeltaSystemTime), deltatime);
            SuccessOrExit(err);
        }
    }

    // Event Trait Profile ID
    if (inSchema.mMinCompatibleDataSchemaVersion != 1 || inSchema.mDataSchemaVersion != 1) {
        TLV::TLVType type;

        err = aContext->mWriter.StartContainer(ContextTag(kTag_EventTraitProfileID), kTLVType_Array, type);
        SuccessOrExit(err);

        err = aContext->mWriter.Put(TLV::AnonymousTag, inSchema.mProfileId);
        SuccessOrExit(err);

        if (inSchema.mDataSchemaVersion != 1) {
            err = aContext->mWriter.Put(TLV::AnonymousTag, inSchema.mDataSchemaVersion);
            SuccessOrExit(err);
        }

        if (inSchema.mMinCompatibleDataSchemaVersion != 1) {
            err = aContext->mWriter.Put(TLV::AnonymousTag, inSchema.mMinCompatibleDataSchemaVersion);
            SuccessOrExit(err);
        }

        err = aContext->mWriter.EndContainer(type);
        SuccessOrExit(err);
    }
    else {
        err = aContext->mWriter.Put(ContextTag(kTag_EventTraitProfileID), inSchema.mProfileId);
        SuccessOrExit(err);
    }

    // Event resource
    if (inOptions->eventSource != NULL)
    {
        if (mExchangeMgr != NULL)
        {
            if (inOptions->eventSource->ResourceID != mExchangeMgr->FabricState->LocalNodeId)
            {
                err = aContext->mWriter.Put(ContextTag(kTag_EventResourceID),
                                 inOptions->eventSource->ResourceID);
                SuccessOrExit(err);
            }

            err = aContext->mWriter.Put(ContextTag(kTag_EventTraitInstanceID),
                             inOptions->eventSource->TraitInstanceID);
            SuccessOrExit(err);
        }
    }

    // Event Type (aka Event Message ID)
    err = aContext->mWriter.Put(ContextTag(kTag_EventType), inSchema.mStructureType);
    SuccessOrExit(err);

    // Callback to write the EventData
    err = inEventWriter(aContext->mWriter, kTag_EventData, inAppData);
    SuccessOrExit(err);

    err = aContext->mWriter.EndContainer(containerType);
    SuccessOrExit(err);

    err = aContext->mWriter.Finalize();
    SuccessOrExit(err);

    // only update mFirst if an event was successfully written.
    if (aContext->mFirst)
    {
        aContext->mFirst = false;
    }

exit:
    if (err != WEAVE_NO_ERROR)
    {
        aContext->mWriter = checkpoint;
    }
    else
    {
        // update these variables since BlitEvent can be used to track the
        // state of a set of events over multiple calls.
        aContext->mCurrentEventID++;
#if WEAVE_CONFIG_EVENT_LOGGING_UTC_TIMESTAMPS
        if (inOptions->timestampType == kTimestampType_UTC)
        {
            aContext->mCurrentUTCTime = inOptions->timestamp.utcTimestamp;
        }
        else
#endif // WEAVE_CONFIG_EVENT_LOGGING_UTC_TIMESTAMPS
        {
            aContext->mCurrentTime = inOptions->timestamp.systemTimestamp;
        }
    }
    return err;
}

/**
 * @brief Create and initialize the logging management buffers. Must
 *   be called prior to the logging being used.
 *
 * @param inMgr[in]         WeaveExchangeManager to be used with this logging subsystem
 *
 * @param inNumBuffers[in]  Number of buffers to use for event storage
 *
 * @param inBufferLengths[in] Description of inBufferLengths
 *
 * @param inBuffers[in]     The buffers to use for actual event logging.
 */
void LoggingManagement::CreateLoggingManagement(nl::Weave::WeaveExchangeManager *inMgr,
                                                size_t inNumBuffers, size_t *inBufferLengths, void **inBuffers,
                                                nl::Weave::Platform::PersistedStorage::Key *inCounterKeys,
                                                const uint32_t *inCounterEpochs, nl::Weave::PersistedCounter **inCounterStorage)
{
    new (&sInstance)LoggingManagement(inMgr, inNumBuffers, inBufferLengths, inBuffers, inCounterKeys, inCounterEpochs, inCounterStorage);
}

/**
 * @brief Create and initialize the logging management buffers. Must
 *   be called prior to the logging being used.
 *
 * @param inMgr[in]         WeaveExchangeManager to be used with this logging subsystem.
 *
 * @param inNumBuffers[in]  Number of buffers to use for event storage.
 *
 * @param inBufferLengths[in] Description of inBufferLengths.
 *
 * @param inBuffers[in]     The buffers to use for actual event logging.
 *
 * @param nWeaveCounter[in] The array of counter pointers must contain the initialized counters, and has to contain inNumBuffers of counters.
 */
void LoggingManagement::CreateLoggingManagement(nl::Weave::WeaveExchangeManager *inMgr,
                                                size_t inNumBuffers, size_t *inBufferLengths, void **inBuffers,
                                                nl::Weave::MonotonicallyIncreasingCounter **nWeaveCounter
                                                )
{
    new (&sInstance)LoggingManagement(inMgr, inNumBuffers, inBufferLengths, inBuffers, nWeaveCounter);
}

/**
 * @brief Perform any actions we need to on shutdown.
 */
void LoggingManagement::DestroyLoggingManagement(void)
{
    Platform::CriticalSectionEnter();
    sInstance.mState = kLoggingManagementState_Shutdown;
    sInstance.mEventBuffer = NULL;
    Platform::CriticalSectionExit();
}

/**
 * @brief Set the WeaveExchangeManager to be used with this logging subsystem.  On some
 *   platforms, this may need to happen separately from CreateLoggingManagement() above.
 *
 * @param inMgr[in]         WeaveExchangeManager to be used with this logging subsystem
 */
WEAVE_ERROR LoggingManagement::SetExchangeManager(nl::Weave::WeaveExchangeManager *inMgr)
{
    mExchangeMgr = inMgr;
    return WEAVE_NO_ERROR;
}

/**
 * @brief
 *   LoggingManagement constructor
 *
 * For prioritization to work correctly, inBuffers must be incrementally
 * increasing in priority.
 *
 * @param inMgr[in]         WeaveExchangeManager to be used with this logging subsystem
 *
 * @param inNumBuffers[in]  Number of buffers to use for event storage
 *
 * @param inBufferLengths[in] Description of inBufferLengths
 *
 * @paran inBuffers[in]     The buffers to use for actual event logging.
 *
 * @return LoggingManagement
 */
LoggingManagement::LoggingManagement(WeaveExchangeManager *inMgr,
                                     size_t inNumBuffers,
                                     size_t *inBufferLengths,
                                     void **inBuffers,
                                     nl::Weave::Platform::PersistedStorage::Key *inCounterKeys,
                                     const uint32_t *inCounterEpochs,
                                     nl::Weave::PersistedCounter **inCounterStorage)
{
    CircularEventBuffer *current = NULL;
    CircularEventBuffer *prev = NULL;
    CircularEventBuffer *next = NULL;
    size_t i;

    mThrottled = 0;
    mExchangeMgr = inMgr;

    for (i = 0; i < inNumBuffers; i++)
    {
        next = ((i+1) < inNumBuffers) ?
            static_cast<CircularEventBuffer *>(inBuffers[i+1]) :
            NULL;

        new (inBuffers[i]) CircularEventBuffer (static_cast<uint8_t*>(inBuffers[i]) + sizeof(CircularEventBuffer),
                                                inBufferLengths[i] - sizeof(CircularEventBuffer),
                                                prev,
                                                next);

        current = prev = static_cast<CircularEventBuffer *>(inBuffers[i]);
        current->mBuffer.mProcessEvictedElement = AlwaysFail;
        current->mBuffer.mAppData = NULL;
        current->mImportance = static_cast<ImportanceType> (inNumBuffers - i);

        if ((inCounterStorage != NULL) && (inCounterStorage[i] != NULL))
        {
            // We have been provided storage for a counter for this importance level.
            new (inCounterStorage[i]) PersistedCounter();
            WEAVE_ERROR err = inCounterStorage[i]->Init(inCounterKeys[i], inCounterEpochs[i]);
            if (err != WEAVE_NO_ERROR)
            {
                WeaveLogError(EventLogging, "%s inCounterStorage[%d]->Init() failed with %d", __FUNCTION__, i, err);
            }
            current->mEventIdCounter = inCounterStorage[i];
        }
        else
        {
            // No counter has been provided, so we'll use our
            // "built-in" non-persisted counter.
            current->mEventIdCounter = &(current->mNonPersistedCounter);
        }

        current->mFirstEventID = current->mEventIdCounter->GetValue();
    }
    mEventBuffer = static_cast<CircularEventBuffer *> (inBuffers[0]);

    mState = kLoggingManagementState_Idle;
    mBDXUploader = NULL;
    mBytesWritten = 0;
    mUploadRequested = false;
    mMaxImportanceBuffer = static_cast<ImportanceType>(inNumBuffers);
}

        /**
 * @brief
 *   LoggingManagement constructor
 *
 * For prioritization to work correctly, inBuffers must be incrementally
 * increasing in priority.
 *
 * @param inMgr[in]         WeaveExchangeManager to be used with this logging subsystem.
 *
 * @param inNumBuffers[in]  Number of buffers to use for event storage.
 *
 * @param inBufferLengths[in] Description of inBufferLengths.
 *
 * @paran inBuffers[in]     The buffers to use for actual event logging.
 *
 * @param nWeaveCounter[in] The array of counter pointers must contain the initialized counters, and has to contain inNumBuffers of counters.
 * @return LoggingManagement
 */
LoggingManagement::LoggingManagement(WeaveExchangeManager *inMgr,
                                     size_t inNumBuffers,
                                     size_t *inBufferLengths,
                                     void **inBuffers,
                                     nl::Weave::MonotonicallyIncreasingCounter **nWeaveCounter)
{
    CircularEventBuffer *current = NULL;
    CircularEventBuffer *prev = NULL;
    CircularEventBuffer *next = NULL;
    size_t i;

    mThrottled = 0;
    mExchangeMgr = inMgr;

    for (i = 0; i < inNumBuffers; i++)
    {
        next = ((i+1) < inNumBuffers) ?
               static_cast<CircularEventBuffer *>(inBuffers[i+1]) :
               NULL;

        new (inBuffers[i]) CircularEventBuffer (static_cast<uint8_t*>(inBuffers[i]) + sizeof(CircularEventBuffer),
                                                inBufferLengths[i] - sizeof(CircularEventBuffer),
                                                prev,
                                                next);

        current = prev = static_cast<CircularEventBuffer *>(inBuffers[i]);
        current->mBuffer.mProcessEvictedElement = AlwaysFail;
        current->mBuffer.mAppData = NULL;
        current->mImportance = static_cast<ImportanceType> (inNumBuffers - i);
        current->mEventIdCounter = nWeaveCounter[i];
        current->mFirstEventID = current->mEventIdCounter->GetValue();
    }

    mEventBuffer = static_cast<CircularEventBuffer *> (inBuffers[0]);

    mState = kLoggingManagementState_Idle;
    mBDXUploader = NULL;
    mBytesWritten = 0;
    mUploadRequested = false;
    mMaxImportanceBuffer = static_cast<ImportanceType>(inNumBuffers);
}
/**
 * @brief
 *   LoggingManagement default constructor. Provided primarily to make the compiler happy.
 *

 * @return LoggingManagement
 */
LoggingManagement::LoggingManagement(void):
    mEventBuffer(NULL),
    mExchangeMgr(NULL),
    mState(kLoggingManagementState_Idle),
    mBDXUploader(NULL),
    mBytesWritten(0),
    mThrottled(0),
    mMaxImportanceBuffer(kImportanceType_Invalid),
    mUploadRequested(false)
{
}

/**
 * @brief
 *   A function to get the current importance of a profile.
 *
 * The function returns the current importance of a profile as
 * currently configured in the #LoggingConfiguration trait.  When
 * per-profile importance is supported, it is used; otherwise only
 * global importance is supported.  When the log is throttled, we only
 * record the Production events
 *
 * @param profileId Profile against which the event is being logged
 *
 * @return Importance of the current profile based on the config
 */
ImportanceType LoggingManagement::GetCurrentImportance(uint32_t profileId)
{
    const LoggingConfiguration &config = LoggingConfiguration::GetInstance();
    ImportanceType retval;

    if (mThrottled != 0)
    {
        retval = Production;
    }
    else if (config.SupportsPerProfileImportance())
    {
        retval = config.GetProfileImportance(profileId);
    }
    else
    {
        retval = config.mGlobalImportance;
    }
    return (retval < mMaxImportanceBuffer ? retval : mMaxImportanceBuffer);
}

/**
 * @brief
 *   Get the max available importance of the system.
 *
 *  This function returns the max importance stored by logging management,
 *  as defined by both the global importance and number of buffers available
 *
 * @return ImportanceType Max importance type currently stored.
 */
ImportanceType LoggingManagement::GetMaxImportance(void)
{
    const LoggingConfiguration &config = LoggingConfiguration::GetInstance();
    return (config.mGlobalImportance < mMaxImportanceBuffer ? config.mGlobalImportance : mMaxImportanceBuffer);
}


/**
 * @brief
 *   Allocate a new event ID based on the event importance, and advance the counter
 *   if we have one.
 *
 * @param inImportance Event importance
 *
 * @return event_id_t Event ID for this importance.
 */
event_id_t CircularEventBuffer::VendEventID(void)
{
    event_id_t retval = 0;
    WEAVE_ERROR err = WEAVE_NO_ERROR;

    // Assign event ID to the buffer's counter's value.
    retval = mEventIdCounter->GetValue();
    mLastEventID = static_cast<event_id_t>(retval);

    // Now advance the counter.
    err = mEventIdCounter->Advance();
    if (err != WEAVE_NO_ERROR)
    {
        WeaveLogError(EventLogging, "%s Advance() for importance %d failed with %d", __FUNCTION__, mImportance, err);
    }

    return retval;
}

/**
 * @brief
 *   Fetch the most recently vended ID for a particular importance level
 *
 * @param inImportance Importance level
 *
 * @return event_id_t most recently vended event ID for that event importance
 */
event_id_t LoggingManagement::GetLastEventID(ImportanceType inImportance)
{
    return GetImportanceBuffer(inImportance)->mLastEventID;
}

/**
 * @brief
 *   Fetch the most recently vended ID for a particular importance level
 *
 * @param inImportance Importance level
 *
 * @return event_id_t most recently vended event ID for that event importance
 */
event_id_t LoggingManagement::GetFirstEventID(ImportanceType inImportance)
{
    return GetImportanceBuffer(inImportance)->mFirstEventID;
}

CircularEventBuffer *LoggingManagement::GetImportanceBuffer(ImportanceType inImportance) const
{
    CircularEventBuffer *buf = mEventBuffer;
    while (!buf->IsFinalDestinationForImportance(inImportance))
    {
        buf = buf->mNext;
    }
    return buf;
}

/**
 * @brief
 *   The public API for registering a set of externally stored events.
 *
 * Register a callback of form #FetchExternalEventsFunct. This API requires
 * the platform to know the number of events on registration. The internal
 * workings also require this number to be constant. Since this API
 * does not allow the platform to register specific event IDs, this prevents
 * the platform from persisting storage of events (at least with unique event
 * IDs).
 *
 * The callback will be called whenever a subscriber attempts to fetch event IDs
 * within the range any number of times until it is unregistered.
 *
 * This variant of the function should be used when the external
 * provider does not care to be notified when the external events have
 * been delivered.
 *
 * The pointer to the ExternalEvents struct will be NULL on failure, otherwise
 * will be populated with start and end event IDs assigned to the callback.
 * This pointer should be used to unregister the set of events.
 *
 * See the documentation for #FetchExternalEventsFunct for details on what
 * the callback must implement.
 *
 * @param inImportance          Importance level
 *
 * @param inCallback            Callback to register to fetch external events
 *
 * @param inNumEvents           Number of events in this set
 *
 * @param aExternalEventsPtr    Pointer to ExternalEvents struct.
 *
 * @return WEAVE_ERROR_NO_MEMORY        If no more callback slots are available.
 *
 * @return WEAVE_ERROR_INVALID_ARGUMENT Null function callback or no events to register.
 *
 * @return WEAVE_NO_ERROR               On success.
 */
WEAVE_ERROR LoggingManagement::RegisterEventCallbackForImportance(ImportanceType inImportance,
        FetchExternalEventsFunct inCallback,
        size_t inNumEvents,
        ExternalEvents **aExternalEventsPtr)
{
    return GetImportanceBuffer(inImportance)->RegisterExternalEventsCallback(inCallback, NULL, inNumEvents, aExternalEventsPtr);
}

/**
 * @brief
 *   The public API for registering a set of externally stored events.
 *
 * Register a callback of form #FetchExternalEventsFunct. This API requires
 * the platform to know the number of events on registration. The internal
 * workings also require this number to be constant. Since this API
 * does not allow the platform to register specific event IDs, this prevents
 * the platform from persisting storage of events (at least with unique event
 * IDs).
 *
 * The callback will be called whenever a subscriber attempts to fetch event IDs
 * within the range any number of times until it is unregistered.
 *
 * This variant of the function should be used when the external
 * provider wants to be notified when the events have been delivered
 * to a subscriber.  When the events are delivered, the external
 * provider is notified that about the node ID of the recipient and
 * last event delivered to that recipient.  Note that the external
 * provider may be notified several times for the same event ID.
 * There are no specific restrictions on the handler, in particular,
 * the handler may unregister the external event IDs.
 *
 * The pointer to the ExternalEvents struct will be NULL on failure, otherwise
 * will be populated with start and end event IDs assigned to the callback.
 * This pointer should be used to unregister the set of events.
 *
 * See the documentation for #FetchExternalEventsFunct for details on what
 * the callback must implement.
 *
 * @param inImportance          Importance level
 *
 * @param inFetchCallback       Callback to register to fetch external events
 *
 * @param inNotifyCallback      Callback to register for delivery notification
 *
 * @param inNumEvents           Number of events in this set
 *
 * @param aExternalEventsPtr    Pointer to ExternalEvents struct.
 *
 * @return WEAVE_ERROR_NO_MEMORY        If no more callback slots are available.
 *
 * @return WEAVE_ERROR_INVALID_ARGUMENT Null function callback or no events to register.
 *
 * @return WEAVE_NO_ERROR               On success.
 */
WEAVE_ERROR LoggingManagement::RegisterEventCallbackForImportance(ImportanceType inImportance,
        FetchExternalEventsFunct inFetchCallback,
        NotifyExternalEventsDeliveredFunct inNotifyCallback,
        size_t inNumEvents,
        ExternalEvents **aExternalEventsPtr)
{
    return GetImportanceBuffer(inImportance)->RegisterExternalEventsCallback(inFetchCallback, inNotifyCallback, inNumEvents, aExternalEventsPtr);
}


/**
 * @brief
 *   The public API for unregistering a set of externally stored events.
 *
 * Unregistering the callback will prevent LoggingManagement from calling
 * the callback for a set of events. LoggingManagement will no longer send
 * those event IDs to subscribers.
 *
 * The intent is for one function to serve a set of events at a time. If
 * a new set of events need to be registered using the same function, the
 * callback should first be unregistered, then registered again. This
 * means the original set of events can no longer be fetched.
 *
 * This function succeeds unconditionally. If the callback was never
 * registered or was already unregistered, it's a no-op.
 *
 * @param inImportance          Importance level
 * @param inPtr                 Pointer to ExternalEvents struct to unregister.
 */
void LoggingManagement::UnregisterEventCallbackForImportance(ImportanceType inImportance,
        ExternalEvents *inPtr)
{
    GetImportanceBuffer(inImportance)->UnregisterExternalEventsCallback(inPtr);
}

// Internal API used in copying an event out of the event buffers

WEAVE_ERROR LoggingManagement :: CopyAndAdjustDeltaTime(const TLVReader &aReader, size_t aDepth, void *aContext)
{
    WEAVE_ERROR err;
    CopyAndAdjustDeltaTimeContext *ctx = static_cast<CopyAndAdjustDeltaTimeContext *>(aContext);
    TLVReader reader(aReader);

    if (aReader.GetTag() == nl::Weave::TLV::ContextTag(kTag_EventDeltaSystemTime))
    {
        if (ctx->mContext->mFirst) // First event gets a timestamp, subsequent ones get a delta T
        {
            err = ctx->mWriter->Put(nl::Weave::TLV::ContextTag(kTag_EventSystemTimestamp), ctx->mContext->mCurrentTime);
        }
        else
        {
            err = ctx->mWriter->CopyElement(reader);
        }
    }
#if WEAVE_CONFIG_EVENT_LOGGING_UTC_TIMESTAMPS
    else if (aReader.GetTag() == ContextTag(kTag_EventDeltaUTCTime))
    {
        if (ctx->mContext->mFirstUtc)
        {
            err = ctx->mWriter->Put(ContextTag(kTag_EventUTCTimestamp), ctx->mContext->mCurrentUTCTime);
            ctx->mContext->mFirstUtc = false;
        }
        else
        {
            err = ctx->mWriter->CopyElement(reader);
        }
    }
#endif // WEAVE_CONFIG_EVENT_LOGGING_UTC_TIMESTAMPS
    else
    {
        err = ctx->mWriter->CopyElement(reader);
    }

    // First event in the sequence gets a eventID neatly packaged
    // right after the importance to keep tags ordered
    if (aReader.GetTag() == nl::Weave::TLV::ContextTag(kTag_EventImportance))
    {
        if (ctx->mContext->mFirst)
        {
            err = ctx->mWriter->Put(nl::Weave::TLV::ContextTag(kTag_EventID), ctx->mContext->mCurrentEventID);
        }
    }

    return err;
}

/**
 * @brief
 *   Log an event via a callback, with options.
 *
 * The function logs an event represented as an ::EventWriterFunct and
 * an app-specific `appData` context.  The function writes the event
 * metadata and calls the `inEventWriter` with an ::TLVWriter
 * reference and `inAppData` context so that the user code can emit
 * the event data directly into the event log.  This form of event
 * logging minimizes memory consumption, as event data is serialized
 * directly into the target buffer.  The event data MUST contain
 * context tags to be interpreted within the schema identified by
 * `inProfileID` and `inEventType`. The tag of the first element will be
 * ignored; the event logging system will replace it with the
 * eventData tag.
 *
 * The event is logged if the schema importance exceeds the logging
 * threshold specified in the LoggingConfiguration.  If the event's
 * importance does not meet the current threshold, it is dropped and
 * the function returns a `0` as the resulting event ID.
 *
 * This variant of the invocation permits the caller to set any
 * combination of `EventOptions`:
 * - timestamp, when 0 defaults to the current time at the point of
 *   the call,
 * - "root" section of the event source (event source and trait ID);
 *   if NULL, it defaults to the current device. the event is marked as
 *   relating to the device that is making the call,
 * - a related event ID for grouping event IDs; when the related event
 *   ID is 0, the event is marked as not relating to any other events,
 * - urgency; by default non-urgent.
 *
 * @param[in] inSchema     Schema defining importance, profile ID, and
 *                         structure type of this event.
 *
 * @param[in] inEventWriter The callback to invoke to actually
 *                         serialize the event data
 *
 * @param[in] inAppData    Application context for the callback.
 *
 * @param[in] inOptions    The options for the event metadata. May be NULL.
 *
 * @return event_id_t      The event ID if the event was written to the
 *                         log, 0 otherwise.
 */
event_id_t LoggingManagement :: LogEvent(const EventSchema &inSchema, EventWriterFunct inEventWriter, void *inAppData, const EventOptions *inOptions)
{
    event_id_t event_id = 0;

    Platform::CriticalSectionEnter();

    // Make sure we're alive.
    VerifyOrExit(mState != kLoggingManagementState_Shutdown, /* no-op */);

    event_id = LogEventPrivate(inSchema, inEventWriter, inAppData, inOptions);

exit:
    Platform::CriticalSectionExit();
    return event_id;
}


// Note: the function below must be called with the critical section
// locked, and only when the logger is not shutting down

inline event_id_t LoggingManagement :: LogEventPrivate(const EventSchema &inSchema, EventWriterFunct inEventWriter, void *inAppData, const EventOptions *inOptions)
{
    event_id_t event_id = 0;
    CircularTLVWriter writer;
    WEAVE_ERROR err = WEAVE_NO_ERROR;
    size_t requestSize = WEAVE_CONFIG_EVENT_SIZE_RESERVE;
    bool didWriteEvent = false;
#if WEAVE_CONFIG_EVENT_LOGGING_UTC_TIMESTAMPS
    int32_t ev_opts_deltatime = 0;
#endif // WEAVE_CONFIG_EVENT_LOGGING_UTC_TIMESTAMPS
    WeaveCircularTLVBuffer checkpoint = mEventBuffer->mBuffer;
    EventLoadOutContext ctxt = EventLoadOutContext(writer,
         inSchema.mImportance, GetImportanceBuffer(inSchema.mImportance)->mLastEventID);
    EventOptions opts = EventOptions(static_cast<timestamp_t>(System::Timer::GetCurrentEpoch()));

    // check whether the entry is to be logged or discarded silently
    VerifyOrExit(inSchema.mImportance <= GetCurrentImportance(inSchema.mProfileId), /* no-op */);

    // Create all event specific data
    // Timestamp; encoded as a delta time
    if ((inOptions != NULL) && (inOptions->timestampType == kTimestampType_System))
    {
#if WEAVE_CONFIG_EVENT_LOGGING_UTC_TIMESTAMPS
        ev_opts_deltatime = inOptions->timestamp.systemTimestamp - opts.timestamp.systemTimestamp;
#endif
        opts.timestamp.systemTimestamp = inOptions->timestamp.systemTimestamp;
    }

    if (GetImportanceBuffer(inSchema.mImportance)->mFirstEventTimestamp == 0)
    {
        GetImportanceBuffer(inSchema.mImportance)->AddEvent(opts.timestamp.systemTimestamp);
    }


#if WEAVE_CONFIG_EVENT_LOGGING_UTC_TIMESTAMPS
    // UTC timestamp; encoded as a delta time
    if ((inOptions != NULL) && (inOptions->timestampType == kTimestampType_UTC))
    {
        opts.timestamp.utcTimestamp = inOptions->timestamp.utcTimestamp;
        opts.timestampType = kTimestampType_UTC;
    }
    else
    {
        // temporary until time APIs return unsigned values
        Profiles::Time::timesync_t utc_tmp;
        err = nl::Weave::Platform::Time::GetSystemTimeMs(&utc_tmp);
        if ((err == WEAVE_NO_ERROR) && (utc_tmp != 0))
        {
            opts.timestamp.utcTimestamp = static_cast<utc_timestamp_t>(static_cast<int64_t>(utc_tmp) + ev_opts_deltatime);
            opts.timestampType = kTimestampType_UTC;
        }
    }

    if ((opts.timestampType == kTimestampType_UTC) &&
            (GetImportanceBuffer(inSchema.mImportance)->mFirstEventUTCTimestamp == 0))
    {
        GetImportanceBuffer(inSchema.mImportance)->AddEventUTC(opts.timestamp.utcTimestamp);
    }
#endif // WEAVE_CONFIG_EVENT_LOGGING_UTC_TIMESTAMPS

    if (inOptions != NULL)
    {
        opts.eventSource = inOptions->eventSource;
        opts.relatedEventID = inOptions->relatedEventID;
        opts.relatedImportance = inOptions->relatedImportance;
    }

    ctxt.mFirst = false;
    ctxt.mCurrentEventID = GetImportanceBuffer(inSchema.mImportance)->mLastEventID;
    ctxt.mCurrentTime = GetImportanceBuffer(inSchema.mImportance)->mLastEventTimestamp;
#if WEAVE_CONFIG_EVENT_LOGGING_UTC_TIMESTAMPS
    ctxt.mCurrentUTCTime = GetImportanceBuffer(inSchema.mImportance)->mLastEventUTCTimestamp;
#endif // WEAVE_CONFIG_EVENT_LOGGING_UTC_TIMESTAMPS

    // Begin writing
    while (!didWriteEvent)
    {
        // Ensure we have space in the in-memory logging queues
        err = EnsureSpace(requestSize);
        SuccessOrExit(err);

        // save a checkpoint for the underlying buffer.  Note that with
        // the current event buffering scheme, only the mEventBuffer will
        // be affected by the writes to the `writer` below, and thus
        // that's the only thing we need to checkpoint.
        checkpoint = mEventBuffer->mBuffer;

        // Start the event container (anonymous structure) in the circular buffer
        writer.Init(&(mEventBuffer->mBuffer));

        err = BlitEvent(&ctxt, inSchema, inEventWriter, inAppData, &opts);

        if (err == WEAVE_ERROR_NO_MEMORY)
        {
            // try again
            err = WEAVE_NO_ERROR;
            requestSize += WEAVE_CONFIG_EVENT_SIZE_INCREMENT;
            mEventBuffer->mBuffer = checkpoint;
            continue;
        }

        didWriteEvent = true;
    }

    mBytesWritten += writer.GetLengthWritten();

exit:

    if (err != WEAVE_NO_ERROR)
    {
        mEventBuffer->mBuffer = checkpoint;
    }
    else if (inSchema.mImportance <= GetCurrentImportance(inSchema.mProfileId))
    {
        event_id = GetImportanceBuffer(inSchema.mImportance)->VendEventID();

#if WEAVE_CONFIG_EVENT_LOGGING_UTC_TIMESTAMPS
        if (opts.timestampType == kTimestampType_UTC)
        {
            GetImportanceBuffer(inSchema.mImportance)->AddEventUTC(opts.timestamp.utcTimestamp);

#if WEAVE_CONFIG_EVENT_LOGGING_VERBOSE_DEBUG_LOGS
            WeaveLogDetail(EventLogging, "LogEvent event id: %u importance: %u profile id: 0x%x structure id: 0x%x utc timestamp: 0x%" PRIx64 , event_id, inSchema.mImportance, inSchema.mProfileId, inSchema.mStructureType, opts.timestamp.utcTimestamp);
#endif // WEAVE_CONFIG_EVENT_LOGGING_VERBOSE_DEBUG_LOGS
        }
        else
#endif // WEAVE_CONFIG_EVENT_LOGGING_UTC_TIMESTAMPS
        {
            GetImportanceBuffer(inSchema.mImportance)->AddEvent(opts.timestamp.systemTimestamp);

#if WEAVE_CONFIG_EVENT_LOGGING_VERBOSE_DEBUG_LOGS
            WeaveLogDetail(EventLogging, "LogEvent event id: %u importance: %u profile id: 0x%x structure id: 0x%x sys timestamp: 0x%" PRIx32 , event_id, inSchema.mImportance, inSchema.mProfileId, inSchema.mStructureType, opts.timestamp.systemTimestamp);
#endif // WEAVE_CONFIG_EVENT_LOGGING_VERBOSE_DEBUG_LOGS
        }

        ScheduleFlushIfNeeded(inOptions == NULL ? false : inOptions->urgent);
    }

    return event_id;
}

/**
 * @brief
 *   ThrottleLogger elevates the effective logging level to the Production level.
 *
 */
void LoggingManagement::ThrottleLogger(void)
{
    WeaveLogProgress(EventLogging, "LogThrottle on");

    __sync_add_and_fetch(&mThrottled, 1);
}

/**
 * @brief
 *   UnthrottleLogger restores the effective logging level to the configured logging level.
 *
 */
void LoggingManagement::UnthrottleLogger(void)
{
    uint32_t throttled = __sync_sub_and_fetch(&mThrottled, 1);

    if (throttled == 0)
    {
        WeaveLogProgress(EventLogging, "LogThrottle off");
    }
}

// internal API, used to copy events to external buffers
WEAVE_ERROR LoggingManagement :: CopyEvent(const TLVReader & aReader, TLVWriter & aWriter, EventLoadOutContext *aContext)
{
    TLVReader reader;
    TLVType containerType;
    CopyAndAdjustDeltaTimeContext context(&aWriter, aContext);
    const bool recurse = false;
    WEAVE_ERROR err = WEAVE_NO_ERROR;

    reader.Init(aReader);
    err = reader.EnterContainer(containerType);
    SuccessOrExit(err);

    err = aWriter.StartContainer(AnonymousTag, kTLVType_Structure, containerType);
    SuccessOrExit(err);

    err = nl::Weave::TLV::Utilities::Iterate(reader, CopyAndAdjustDeltaTime, &context, recurse);
    VerifyOrExit(err == WEAVE_NO_ERROR || err == WEAVE_END_OF_TLV, );

    err = aWriter.EndContainer(containerType);
    SuccessOrExit(err);

    err = aWriter.Finalize();

exit:
    return err;
}

/**
 * @brief
 *   Internal API used to implement #FetchEventsSince
 *
 * Iterator function to used to copy an event from the log into a
 * TLVWriter. The included aContext contains the context of the copy
 * operation, including the TLVWriter that will hold the copy of an
 * event.  If event cannot be written as a whole, the TLVWriter will
 * be rolled back to event boundary.
 *
 * @retval #WEAVE_END_OF_TLV function reached the end of the event
 *
 * @retval #WEAVE_ERROR_NO_MEMORY Function could not write a portion of
 *                          the event to the TLVWriter.
 *
 * @retval #WEAVE_ERROR_BUFFER_TOO_SMALL Function could not write a
 *                          portion of the event to the TLVWriter.
 */
WEAVE_ERROR LoggingManagement :: CopyEventsSince(const TLVReader & aReader, size_t aDepth, void *aContext)
{
    WEAVE_ERROR err = WEAVE_NO_ERROR;
    const bool recurse = false;
    TLVReader innerReader;
    TLVType tlvType;
    EventEnvelopeContext event;
    EventLoadOutContext *loadOutContext = static_cast<EventLoadOutContext *>(aContext);
    nl::Weave::TLV::TLVWriter   checkpoint;

#if WEAVE_CONFIG_EVENT_LOGGING_NUM_EXTERNAL_CALLBACKS
    // TODO: CopyEventsSince using the LoggingManagement singleton is less than
    // ideal. Consider a future refactor of the Iterate call in FetchEventsSince.
    while (LoggingManagement::GetInstance().IsEventExternal(loadOutContext->mImportance, loadOutContext->mCurrentEventID))
    {
        if (loadOutContext->mCurrentEventID >= loadOutContext->mStartingEventID)
        {
            // the next event is externally handled. return to FetchEventsSince.
            err = WEAVE_END_OF_TLV;
            break;
        }
        else
        {
            // skip over
            loadOutContext->mCurrentEventID = LoggingManagement::GetInstance().GetEndOfExternalEventRange(loadOutContext->mImportance, loadOutContext->mCurrentEventID) + 1;
        }
    }
    SuccessOrExit(err);
#endif // WEAVE_CONFIG_EVENT_LOGGING_NUM_EXTERNAL_CALLBACKS

    innerReader.Init(aReader);
    err = innerReader.EnterContainer(tlvType);
    SuccessOrExit(err);

    err = nl::Weave::TLV::Utilities::Iterate(innerReader, FetchEventParameters, &event, recurse);
    VerifyOrExit(event.mNumFieldsToRead == 0, err = WEAVE_NO_ERROR);

    err = WEAVE_NO_ERROR;

    if (event.mImportance == loadOutContext->mImportance)
    {
        loadOutContext->mCurrentTime += event.mDeltaTime;
#if WEAVE_CONFIG_EVENT_LOGGING_UTC_TIMESTAMPS
        loadOutContext->mCurrentUTCTime += event.mDeltaUtc;
#endif // WEAVE_CONFIG_EVENT_LOGGING_UTC_TIMESTAMPS
        if (loadOutContext->mCurrentEventID >= loadOutContext->mStartingEventID)
        {
            // checkpoint the writer
            checkpoint = loadOutContext->mWriter;

            err = CopyEvent(aReader, loadOutContext->mWriter, loadOutContext);

            // WEAVE_NO_ERROR and WEAVE_END_OF_TLV signify a
            // successful copy.  In all other cases, roll back the
            // writer state back to the checkpoint, i.e., the state
            // before we began the copy operation.
            VerifyOrExit((err == WEAVE_NO_ERROR) || (err == WEAVE_END_OF_TLV),
                loadOutContext->mWriter = checkpoint);

            loadOutContext->mCurrentTime = 0;
            loadOutContext->mFirst = false;
        }

        loadOutContext->mCurrentEventID++;
    }

exit:
    return err;
}

#if WEAVE_CONFIG_EVENT_LOGGING_NUM_EXTERNAL_CALLBACKS
/**
 * @brief
 *   IsEventExternal checks whether inEventID is stored by the platform.
 *
 * @retval True if the event is stored externally.
 * @retval False otherwise.
 */
inline bool LoggingManagement::IsEventExternal(ImportanceType inImportance, event_id_t inEventID) const
{
    return (GetImportanceBuffer(inImportance)->GetExternalEventsFromEventID(inEventID) != NULL);
}

/**
 * @brief
 *   For an event ID known to be stored externally, return the last event ID in that set.
 *
 * @retval The last event ID of a group of event IDs.
 */
inline event_id_t LoggingManagement::GetEndOfExternalEventRange(ImportanceType inImportance, event_id_t inEventID) const
{
    ExternalEvents *ev = GetImportanceBuffer(inImportance)->GetExternalEventsFromEventID(inEventID);
    return ev->mLastEventID;
}
#endif // WEAVE_CONFIG_EVENT_LOGGING_NUM_EXTERNAL_CALLBACKS

/**
 * @brief
 *   A function to retrieve events of specified importance since a specified event ID.
 *
 * Given a ::TLVWriter, an importance type, and an event ID, the
 * function will fetch events of specified importance since the
 * specified event.  The function will continue fetching events until
 * it runs out of space in the ::TLVWriter or in the log. The function
 * will terminate the event writing on event boundary.
 *
 * @param ioWriter[in]     The writer to use for event storage
 *
 * @param inImportance[in] The importance of events to be fetched
 *
 * @param ioEventID[inout] On input, the ID of the event immediately
 *                         prior to the one we're fetching.  On
 *                         completion, the ID of the last event
 *                         fetched.
 *
 * @retval #WEAVE_END_OF_TLV The function has reached the end of the
 *                         available log entries at the specified
 *                         importance level
 *
 * @retval #WEAVE_ERROR_NO_MEMORY The function ran out of space in the
 *                         ioWriter, more events in the log are
 *                         available.
 *
 * @retval #WEAVE_ERROR_BUFFER_TOO_SMALL The function ran out of space
 *                         in the ioWriter, more events in the log are
 *                         available.
 *
 */
WEAVE_ERROR LoggingManagement :: FetchEventsSince(TLVWriter &ioWriter, ImportanceType inImportance, event_id_t &ioEventID)
{
    WEAVE_ERROR err = WEAVE_NO_ERROR;
    const bool recurse = false;
    TLVReader reader;
    EventLoadOutContext aContext(ioWriter, inImportance, ioEventID);
    CircularEventBuffer *buf = mEventBuffer;

    Platform::CriticalSectionEnter();

    while (!buf->IsFinalDestinationForImportance(inImportance))
    {
        buf = buf->mNext;
    }

    aContext.mCurrentTime = buf->mFirstEventTimestamp;
#if WEAVE_CONFIG_EVENT_LOGGING_UTC_TIMESTAMPS
    aContext.mCurrentUTCTime = buf->mFirstEventUTCTimestamp;
#endif // WEAVE_CONFIG_EVENT_LOGGING_UTC_TIMESTAMPS
    aContext.mCurrentEventID = buf->mFirstEventID;
    err = GetEventReader(reader, inImportance);
    SuccessOrExit(err);

#if WEAVE_CONFIG_EVENT_LOGGING_NUM_EXTERNAL_CALLBACKS
    if (IsEventExternal(inImportance, ioEventID))
    {
        ExternalEvents *ev = buf->GetExternalEventsFromEventID(ioEventID);
        aContext.mCurrentEventID = ev->mFirstEventID;

        if (ev->mFetchEventsFunct)
        {
            err = ev->mFetchEventsFunct(&aContext);
        }
        else
        {
            aContext.mCurrentEventID = ev->mLastEventID + 1;
            err = WEAVE_END_OF_TLV;
        }
    }
    else
#endif // WEAVE_CONFIG_EVENT_LOGGING_NUM_EXTERNAL_CALLBACKS
    {
        err =  nl::Weave::TLV::Utilities::Iterate(reader, CopyEventsSince, &aContext, recurse);
    }

exit:
    ioEventID = aContext.mCurrentEventID;

    Platform::CriticalSectionExit();
    return err;
}

/**
 * @brief
 *   A helper method useful for examining the in-memory log buffers
 *
 * @param ioReader[inout] A reference to the reader that will be
 *                        initialized with the backing storage from
 *                        the event log
 *
 * @param inImportance[in] The starting importance for the reader.
 *                         Note that in this case the starting
 *                         importance is somewhat counter intuitive:
 *                         more important events share the buffers
 *                         with less important events, in addition to
 *                         their dedicated buffers.  As a result, the
 *                         reader will traverse the least data when
 *                         the Debug importance is passed in.
 *
 * @retval #WEAVE_NO_ERROR Unconditionally.
 */
WEAVE_ERROR LoggingManagement :: GetEventReader(TLVReader &ioReader, ImportanceType inImportance)
{
    WEAVE_ERROR err = WEAVE_NO_ERROR;
    CircularEventBuffer *buffer;
    CircularEventReader reader;
    for (buffer = mEventBuffer;
         buffer != NULL && !buffer->IsFinalDestinationForImportance(inImportance);
         buffer= buffer->mNext);
    VerifyOrExit(buffer != NULL, err = WEAVE_ERROR_INVALID_ARGUMENT);

    reader.Init(buffer);

    ioReader.Init(reader);
exit:
    return err;
}

//internal API
WEAVE_ERROR LoggingManagement :: FetchEventParameters(const TLVReader & aReader, size_t aDepth, void *aContext)
{
    WEAVE_ERROR err = WEAVE_NO_ERROR;
    EventEnvelopeContext * envelope = static_cast<EventEnvelopeContext *>(aContext);
    TLVReader reader;
    uint16_t extImportance; // Note: the type here matches the type case in LoggingManagement::LogEvent, importance section
    reader.Init(aReader);

    VerifyOrExit(envelope->mNumFieldsToRead > 0, err = WEAVE_END_OF_TLV);

    if (reader.GetTag() == nl::Weave::TLV::ContextTag(kTag_EventImportance))
    {
        err = reader.Get(extImportance);
        SuccessOrExit(err);
        envelope->mImportance = static_cast<ImportanceType>(extImportance);

        envelope->mNumFieldsToRead --;
    }

    if (reader.GetTag() == nl::Weave::TLV::ContextTag(kTag_EventDeltaSystemTime))
    {
        err = reader.Get(envelope->mDeltaTime);
        SuccessOrExit(err);

        envelope->mNumFieldsToRead --;
    }

#if WEAVE_CONFIG_EVENT_LOGGING_UTC_TIMESTAMPS
    if (reader.GetTag() == nl::Weave::TLV::ContextTag(kTag_EventDeltaUTCTime))
    {
        err = reader.Get(envelope->mDeltaUtc);
        SuccessOrExit(err);

        envelope->mNumFieldsToRead --;
    }
#endif // WEAVE_CONFIG_EVENT_LOGGING_UTC_TIMESTAMPS

exit:
    return err;
}

// internal API: determine importance of an event, and the space the event requires

WEAVE_ERROR LoggingManagement :: EvictEvent(WeaveCircularTLVBuffer &inBuffer, void * inAppData, TLVReader & inReader)
{
    ReclaimEventCtx *ctx = static_cast<ReclaimEventCtx *>(inAppData);
    CircularEventBuffer *eventBuffer = ctx->mEventBuffer;
    TLVType containerType;
    EventEnvelopeContext context;
    const bool recurse = false;
    WEAVE_ERROR err;
    ImportanceType imp = kImportanceType_Invalid;

    // pull out the delta time, pull out the importance

    err = inReader.Next();
    SuccessOrExit(err);

    err = inReader.EnterContainer(containerType);
    SuccessOrExit(err);

    nl::Weave::TLV::Utilities::Iterate(inReader, FetchEventParameters, &context, recurse);

    err = inReader.ExitContainer(containerType);

    SuccessOrExit(err);

    imp = static_cast<ImportanceType>(context.mImportance);

    if (eventBuffer->IsFinalDestinationForImportance(imp))
    {
        // event is getting dropped.  Increase the eventid and first timestamp.
        eventBuffer->RemoveEvent();
        eventBuffer->mFirstEventTimestamp += context.mDeltaTime;
#if WEAVE_CONFIG_EVENT_LOGGING_UTC_TIMESTAMPS
        eventBuffer->mFirstEventUTCTimestamp += context.mDeltaUtc;
#endif // WEAVE_CONFIG_EVENT_LOGGING_UTC_TIMESTAMPS
        ctx->mSpaceNeededForEvent = 0;
    }
    else
    {
        // event is not getting dropped. Note how much space it requires, and return.
        ctx->mSpaceNeededForEvent = inReader.GetLengthRead();
        err = WEAVE_END_OF_TLV;
    }

exit:
    return err;
}

// Notes: called as a result of the timer expiration.  Main job:
// figure out whether trigger still applies, if it does, then kick off
// the upload.  If it does not, perform the appropriate backoff.

void LoggingManagement::LoggingFlushHandler(System::Layer *systemLayer, void *appState, INET_ERROR err)
{
    LoggingManagement *logger = static_cast<LoggingManagement *>(appState);
    logger->FlushHandler(systemLayer, err);
}

// FlushHandler is only called by the Weave thread. As such, guard variables
// do not need to be atomically set or checked.
void LoggingManagement::FlushHandler(System::Layer *inSystemLayer, INET_ERROR inErr)
{
#if WEAVE_CONFIG_EVENT_LOGGING_BDX_OFFLOAD
    const LoggingConfiguration &config = LoggingConfiguration::GetInstance();
#endif //WEAVE_CONFIG_EVENT_LOGGING_BDX_OFFLOAD

    switch (mState)
    {
    case kLoggingManagementState_Idle:
    {
#if WEAVE_CONFIG_EVENT_LOGGING_BDX_OFFLOAD
        // Nothing prevents a flush.  If the configuration supports
        // it, transition into "in progress" state, and kick off the
        // offload process.  If no valid upload location exists,
        // schedule an upload at the maximum upload interval
        if ((mBDXUploader != NULL) && (config.GetDestNodeId() != kAnyNodeId))
        {
            WEAVE_ERROR err;
            mState = kLoggingManagementState_InProgress;
            err = mBDXUploader->StartUpload(config.GetDestNodeId(), config.GetDestNodeIPAddress());
            if (err != WEAVE_NO_ERROR)
                WeaveLogError(EventLogging, "Failed to start BDX (err: %d)", err);
        }
        else
        {
            if (mExchangeMgr != NULL)
            {
                mExchangeMgr->MessageLayer->SystemLayer->StartTimer(config.mMaximumLogUploadInterval, LoggingFlushHandler, this);
            }
        }
#endif //WEAVE_CONFIG_EVENT_LOGGING_BDX_OFFLOAD

#if WEAVE_CONFIG_EVENT_LOGGING_WDM_OFFLOAD
        if (mExchangeMgr != NULL)
        {
            nl::Weave::Profiles::DataManagement::SubscriptionEngine::GetInstance()->GetNotificationEngine()->Run();
            mUploadRequested = false;
        }
#endif //WEAVE_CONFIG_EVENT_LOGGING_WDM_OFFLOAD

        break;
    }
    case kLoggingManagementState_Holdoff:
    {
#if WEAVE_CONFIG_EVENT_LOGGING_BDX_OFFLOAD
        mState = kLoggingManagementState_Idle;
        mUploadRequested = false;
        ScheduleFlushIfNeeded(false);
        if (mUploadRequested == false)
        {
            if (mExchangeMgr != NULL)
            {
                mExchangeMgr->MessageLayer->SystemLayer->StartTimer(config.mMaximumLogUploadInterval, LoggingFlushHandler, this);
            }
        }
#endif //WEAVE_CONFIG_EVENT_LOGGING_BDX_OFFLOAD
        break;
    }

    case kLoggingManagementState_InProgress:
    case kLoggingManagementState_Shutdown:
    {
        // should never end in these states in this function
        break;
    }

    }
}

void LoggingManagement::SignalUploadDone(void)
{
#if WEAVE_CONFIG_EVENT_LOGGING_BDX_OFFLOAD
    const LoggingConfiguration &config = LoggingConfiguration::GetInstance();
    if (mState == kLoggingManagementState_InProgress)
    {
        mState = kLoggingManagementState_Holdoff;
        if (mExchangeMgr != NULL)
        {
            mExchangeMgr->MessageLayer->SystemLayer->StartTimer(config.mMinimumLogUploadInterval, LoggingFlushHandler, this);
        }
    }
#endif //WEAVE_CONFIG_EVENT_LOGGING_BDX_OFFLOAD
}

/**
 * @brief
 *  Schedule a log offload task.
 *
 * The function decides whether to schedule a task offload process,
 * and if so, it schedules the `LoggingFlushHandler` to be run
 * asynchronously on the Weave thread.
 *
 * The decision to schedule a flush is dependent on three factors:
 *
 * -- an explicit request to flush the buffer
 *
 * -- the state of the event buffer and the amount of data not yet
 *    synchronized with the event consumers
 *
 * -- whether there is an already pending request flush request event.
 *
 * The explicit request to schedule a flush is passed via an input
 * parameter.
 *
 * The automatic flush is typically scheduled when the event buffers
 * contain enough data to merit starting a new offload.  Additional
 * triggers -- such as minimum and maximum time between offloads --
 * may also be taken into account depending on the offload strategy.
 *
 * The pending state of the event log is indicated by
 * `mUploadRequested` variable. Since this function can be called by
 * multiple threads, `mUploadRequested` must be atomically read and
 * set, to avoid scheduling a redundant `LoggingFlushHandler` before
 * the notification has been sent.
 *
 * @param inRequestFlush A boolean value indicating whether the flush
 *                       should be scheduled regardless of internal
 *                       buffer management policy.
 *
 * @retval #WEAVE_ERROR_INCORRECT_STATE LoggingManagement module was not initialized fully.
 *
 * @retval #WEAVE_NO_ERROR On success.
 */
WEAVE_ERROR LoggingManagement::ScheduleFlushIfNeeded(bool inRequestFlush)
{
    WEAVE_ERROR err = WEAVE_NO_ERROR;

#if WEAVE_CONFIG_EVENT_LOGGING_BDX_OFFLOAD
    inRequestFlush |= CheckShouldRunBDX();
#endif // WEAVE_CONFIG_EVENT_LOGGING_BDX_OFFLOAD
#if WEAVE_CONFIG_EVENT_LOGGING_WDM_OFFLOAD
    inRequestFlush |= CheckShouldRunWDM();
#endif // WEAVE_CONFIG_EVENT_LOGGING_WDM_OFFLOAD

    if (inRequestFlush && __sync_bool_compare_and_swap(&mUploadRequested, false, true))
    {
        if ((mExchangeMgr != NULL) &&
            (mExchangeMgr->MessageLayer != NULL) &&
            (mExchangeMgr->MessageLayer->SystemLayer != NULL))
        {
            mExchangeMgr->MessageLayer->SystemLayer->ScheduleWork(LoggingFlushHandler, this);
        }
        else
        {
            err = WEAVE_ERROR_INCORRECT_STATE;
            mUploadRequested = false;
        }
    }

    return err;
}

#if WEAVE_CONFIG_EVENT_LOGGING_BDX_OFFLOAD
bool LoggingManagement::CheckShouldRunBDX(void)
{
    const LoggingConfiguration &config = LoggingConfiguration::GetInstance();
    return ((mBDXUploader != NULL) && ((mBytesWritten - mBDXUploader->GetUploadPosition()) > config.mUploadThreshold));
}
#endif // WEAVE_CONFIG_EVENT_LOGGING_BDX_OFFLOAD

#if WEAVE_CONFIG_EVENT_LOGGING_WDM_OFFLOAD
/**
 * @brief
 *  Decide whether to offload events based on the number of bytes in event buffers unscheduled for upload.
 *
 * The behavior of the function is controlled via
 * #WEAVE_CONFIG_EVENT_LOGGING_BYTE_THRESHOLD constant.  If the system
 * wrote more than that number of bytes since the last time a WDM
 * Notification was sent, the function will indicate it is time to
 * trigger the NotificationEngine.
 *
 * @returns true  events should be offloaded
 * @returns false otherwise
 */
bool LoggingManagement::CheckShouldRunWDM(void)
{
    WEAVE_ERROR err = WEAVE_NO_ERROR;
    size_t minimalBytesOffloaded = mBytesWritten;
    bool ret = false;

    // Get the minimal log position (in bytes) across all subscribers
    err = nl::Weave::Profiles::DataManagement::SubscriptionEngine::GetInstance()->GetMinEventLogPosition(minimalBytesOffloaded);
    SuccessOrExit(err);

    // return true if we can offload more than the threshold bytes to a subscription
    ret = ((minimalBytesOffloaded + WEAVE_CONFIG_EVENT_LOGGING_BYTE_THRESHOLD) < mBytesWritten);

exit:
    return ret;
}

#endif // WEAVE_CONFIG_EVENT_LOGGING_WDM_OFFLOAD

WEAVE_ERROR LoggingManagement::SetLoggingEndpoint(event_id_t *inEventEndpoints, size_t inNumImportanceLevels, size_t &outBytesOffloaded)
{
    WEAVE_ERROR err = WEAVE_NO_ERROR;
    CircularEventBuffer *eventBuffer = mEventBuffer;

    Platform::CriticalSectionEnter();

    outBytesOffloaded = mBytesWritten;

    while (eventBuffer != NULL && inNumImportanceLevels > 0)
    {
      if ((eventBuffer->mImportance >= kImportanceType_First) &&
          ((static_cast<size_t>(eventBuffer->mImportance - kImportanceType_First)) < inNumImportanceLevels))
        {
            inEventEndpoints[eventBuffer->mImportance - kImportanceType_First] = eventBuffer->mLastEventID;
        }
        eventBuffer = eventBuffer->mNext;
    }

    Platform::CriticalSectionExit();
    return err;
}

/**
 * @brief
 *   Get the total number of bytes written (across all event
 *   importances) to this log since its instantiation
 *
 * @returns The number of bytes written to the log.
 */
uint32_t LoggingManagement::GetBytesWritten(void) const
{
    return mBytesWritten;
}

void LoggingManagement::NotifyEventsDelivered(ImportanceType inImportance, event_id_t inLastDeliveredEventID, uint64_t inRecipientNodeID) const
{
#if WEAVE_CONFIG_EVENT_LOGGING_NUM_EXTERNAL_CALLBACKS

    for (size_t i = 0; i < WEAVE_CONFIG_EVENT_LOGGING_NUM_EXTERNAL_CALLBACKS; i++)
    {
        ExternalEvents *externalEvents = &(GetImportanceBuffer(inImportance)->mExternalEventsList[i]);
        if ((externalEvents->mFetchEventsFunct != NULL) && (externalEvents->mNotifyEventsDeliveredFunct != NULL))
        {
            if (inLastDeliveredEventID >= externalEvents->mFirstEventID)
            {
                event_id_t eventId = inLastDeliveredEventID;
                if (eventId > externalEvents->mLastEventID)
                {
                    eventId = externalEvents->mLastEventID;
                }

                externalEvents->mNotifyEventsDeliveredFunct(externalEvents, eventId, inRecipientNodeID);
            }
        }
    }
#endif
}

void LoggingManagement::SetBDXUploader(LogBDXUpload *inUploader)
{
    if (mBDXUploader == NULL)
    {
        mBDXUploader = inUploader;
    }
    else
    {
        WeaveLogError(EventLogging, "mBDXUploader already set");
    }
}

/**
 * @brief
 *   A constructor for the CircularEventBuffer (internal API).
 *
 * @param inBuffer[in]       The actual storage to use for event storage.
 *
 * @param inBufferLength[in] The length of the #inBuffer in bytes.
 *
 * @param inPrev[in]         The pointer to CircularEventBuffer storing
 *                           events of lesser priority.
 *
 * @param inNext[in]         The pointer to CircularEventBuffer storing
 *                           events of greater priority.
 *
 * @return CircularEventBuffer
 */
CircularEventBuffer::CircularEventBuffer(uint8_t *inBuffer, size_t inBufferLength, CircularEventBuffer *inPrev, CircularEventBuffer *inNext) :
    mBuffer(inBuffer, inBufferLength),
    mPrev(inPrev),
    mNext(inNext),
    mImportance(kImportanceType_First),
    mFirstEventID(1),
    mLastEventID(0),
    mFirstEventTimestamp(0),
    mLastEventTimestamp(0),
#if WEAVE_CONFIG_EVENT_LOGGING_UTC_TIMESTAMPS
    mFirstEventUTCTimestamp(0),
    mLastEventUTCTimestamp(0),
    mUTCInitialized(false),
#endif // WEAVE_CONFIG_EVENT_LOGGING_UTC_TIMESTAMPS
    mEventIdCounter(NULL)
{
    // TODO: hook up the platform-specific persistent event ID.
#if WEAVE_CONFIG_EVENT_LOGGING_NUM_EXTERNAL_CALLBACKS
    for (int i = 0; i < WEAVE_CONFIG_EVENT_LOGGING_NUM_EXTERNAL_CALLBACKS; i++)
    {
        mExternalEventsList[i] = ExternalEvents();
    }
#endif // WEAVE_CONFIG_EVENT_LOGGING_NUM_EXTERNAL_CALLBACKS
}

/**
 * @brief
 *   A helper function that determines whether the event of
 *   specified importance is dropped from this buffer.
 *
 * @param[in]   inImportance   Importance of the event.
 *
 * @returns True if the event will be dropped from this buffer as
 * a result of queue overflow.  False if the event will be instead
 * bumped to the next queue.
 */
bool CircularEventBuffer :: IsFinalDestinationForImportance(ImportanceType inImportance) const
{
    return !((mNext != NULL) && (mNext->mImportance >= inImportance));
}

/**
 * @brief
 *   Given a timestamp of an event, compute the delta time to store in the log
 *
 * @param inEventTimestamp The event timestamp.
 *
 * @return int32_t         Time delta to encode for the event.
 */
void CircularEventBuffer :: AddEvent(timestamp_t inEventTimestamp)
{
    if (mFirstEventTimestamp == 0)
    {
        mFirstEventTimestamp = inEventTimestamp;
        mLastEventTimestamp = inEventTimestamp;
    }
    mLastEventTimestamp = inEventTimestamp;
}


#if WEAVE_CONFIG_EVENT_LOGGING_UTC_TIMESTAMPS
/**
 * @brief
 *   Given a timestamp of an event, compute the delta utc time to store in the log
 *
 * @param inEventTimestamp The event's utc timestamp
 *
 * @return int64_t         Time delta to encode for the event.
 */
void CircularEventBuffer :: AddEventUTC(utc_timestamp_t inEventTimestamp)
{
    if (mUTCInitialized == false)
    {
        mFirstEventUTCTimestamp = inEventTimestamp;
        mUTCInitialized = true;
    }
    mLastEventUTCTimestamp = inEventTimestamp;
}
#endif // WEAVE_CONFIG_EVENT_LOGGING_UTC_TIMESTAMPS

void CircularEventBuffer :: RemoveEvent(void)
{
#if WEAVE_CONFIG_EVENT_LOGGING_NUM_EXTERNAL_CALLBACKS
    ExternalEvents *ev;
    while ((ev = GetExternalEventsFromEventID(mFirstEventID)) != NULL)
    {
        mFirstEventID = ev->mLastEventID + 1;
        ev->mFetchEventsFunct = NULL;
    }
#endif // WEAVE_CONFIG_EVENT_LOGGING_NUM_EXTERNAL_CALLBACKS
    mFirstEventID++;
}

/**
 * @brief
 *   This function registers a set of event IDs and a function
 *   callback for externally stored events.
 *
 * @param aFetchCallback  The function callback for unloading events.
 * @param aNotifyCallback The function callback to notify about offload
 * @param aNumEvents      Number of events to register.
 *
 * @return WEAVE_ERROR_INVALID_ARGUMENT Null function callback or no events to register.
 * @return WEAVE_ERROR_NO_MEMORY If all callbacks are in use.
 * @return WEAVE_NO_ERROR Otherwise
 */
WEAVE_ERROR CircularEventBuffer :: RegisterExternalEventsCallback(
        FetchExternalEventsFunct aFetchCallback,
        NotifyExternalEventsDeliveredFunct aNotifyCallback,
        size_t aNumEvents,
        ExternalEvents **aExternalEventsPtr)
{
    WEAVE_ERROR err = WEAVE_NO_ERROR;
#if WEAVE_CONFIG_EVENT_LOGGING_NUM_EXTERNAL_CALLBACKS
    ExternalEvents *ev;

    Platform::CriticalSectionEnter();

    VerifyOrExit(aFetchCallback != NULL, err = WEAVE_ERROR_INVALID_ARGUMENT);
    VerifyOrExit(aNumEvents > 0, err = WEAVE_ERROR_INVALID_ARGUMENT);

    ev = GetNextAvailableExternalEvents();
    VerifyOrExit(ev != NULL, err = WEAVE_ERROR_NO_MEMORY);

    ev->mFirstEventID = VendEventID();
    // need to vend event IDs in a batch.
    for (size_t i = 1; i < aNumEvents; i++)
    {
        event_id_t tmp_id = VendEventID();
        IgnoreUnusedVariable(tmp_id);
    }

    ev->mLastEventID = mLastEventID;
    ev->mFetchEventsFunct = aFetchCallback;
    ev->mNotifyEventsDeliveredFunct = aNotifyCallback;
    if (aExternalEventsPtr != NULL)
    {
        *aExternalEventsPtr = ev;
    }

exit:
    Platform::CriticalSectionExit();
#else // WEAVE_CONFIG_EVENT_LOGGING_NUM_EXTERNAL_CALLBACKS
    err = WEAVE_ERROR_NOT_IMPLEMENTED;
#endif // WEAVE_CONFIG_EVENT_LOGGING_NUM_EXTERNAL_CALLBACKS

    return err;
}

/**
 * @brief
 *   This function unregisters a callback.
 *
 * Once the callback is unregistered, if the event IDs are fetched by
 * a subscriber, the event logging framework will return an empty buffer.
 * If the event IDs no longer need to be fetched, the ExternalEvents
 * callback can be reused.
 *
 * @param inPtr   Pointer to ExternalEvents struct to unregister.
 */
void CircularEventBuffer :: UnregisterExternalEventsCallback(
        ExternalEvents *inPtr)
{
#if WEAVE_CONFIG_EVENT_LOGGING_NUM_EXTERNAL_CALLBACKS
    Platform::CriticalSectionEnter();

    if (inPtr != NULL)
    {
        inPtr->mFetchEventsFunct = NULL;
        inPtr->mNotifyEventsDeliveredFunct = NULL;
    }

    Platform::CriticalSectionExit();
#endif // WEAVE_CONFIG_EVENT_LOGGING_NUM_EXTERNAL_CALLBACKS
}

#if WEAVE_CONFIG_EVENT_LOGGING_NUM_EXTERNAL_CALLBACKS
/**
 * @brief
 *   A function to get a pointer to the ExternalEvent storing aEventID.
 *
 * @retval NULL if aEventID is not externally stored.
 */
ExternalEvents *CircularEventBuffer :: GetExternalEventsFromEventID(
        event_id_t aEventID)
{
    uint8_t idx;
    ExternalEvents *ev = NULL;

    for (idx = 0; idx < WEAVE_CONFIG_EVENT_LOGGING_NUM_EXTERNAL_CALLBACKS; idx++)
    {
        ev = &mExternalEventsList[idx];

        if ((aEventID >= ev->mFirstEventID) &&
            (aEventID <= ev->mLastEventID) &&
            (mFirstEventID <= ev->mFirstEventID))
        {
            break;
        }
        ev = NULL;
    }

    return ev;
}

/**
 * @brief
 *   A function to get a pointer to the next available ExternalEvent.
 *
 * A NULL pointer assigned to an ExternalEvents.mFetchEventsFunct is an
 * indication that the callback slot is unused.
 *
 * @retval NULL if all callbacks are in use.
 */
ExternalEvents *CircularEventBuffer :: GetNextAvailableExternalEvents(void)
{
    uint8_t idx;
    ExternalEvents *ev = NULL;

    for (idx = 0; idx < WEAVE_CONFIG_EVENT_LOGGING_NUM_EXTERNAL_CALLBACKS; idx++)
    {
        ev = &mExternalEventsList[idx];

        if ((ev->mFetchEventsFunct == NULL) &&
            (ev->mLastEventID <= mFirstEventID))
        {
            break;
        }
        ev = NULL;
    }

    return ev;
}
#endif // WEAVE_CONFIG_EVENT_LOGGING_NUM_EXTERNAL_CALLBACKS

/**
 * @brief
 *   Initializes a TLVReader object backed by CircularEventBuffer
 *
 * Reading begins in the CircularTLVBuffer belonging to this
 * CircularEventBuffer.  When the reader runs out of data, it begins
 * to read from the previous CircularEventBuffer.
 *
 * @param[in] inBuf A pointer to a fully initialized CircularEventBuffer
 *
 */
void CircularEventReader::Init(CircularEventBuffer *inBuf)
{
    CircularTLVReader reader;
    CircularEventBuffer *prev;
    reader.Init(&inBuf->mBuffer);
    TLVReader::Init(reader);
    mBufHandle =  (uintptr_t)inBuf;
    GetNextBuffer = CircularEventBuffer::GetNextBufferFunct;
    for (prev = inBuf->mPrev; prev != NULL; prev = prev->mPrev)
    {
        reader.Init(&prev->mBuffer);
        mMaxLen += reader.GetRemainingLength();
    }
}

WEAVE_ERROR CircularEventBuffer :: GetNextBufferFunct(TLVReader& ioReader, uintptr_t &inBufHandle, const uint8_t *&outBufStart, uint32_t &outBufLen)
{
    WEAVE_ERROR err = WEAVE_NO_ERROR;
    CircularEventBuffer *buf;

    VerifyOrExit(inBufHandle != 0, err = WEAVE_ERROR_INVALID_ARGUMENT);

    buf = static_cast<CircularEventBuffer *>((void *) inBufHandle);

    err = buf->mBuffer.GetNextBuffer(ioReader, outBufStart, outBufLen);
    SuccessOrExit(err);

    if ((outBufLen == 0) && (buf->mPrev != NULL))
    {
        inBufHandle = (uintptr_t) buf->mPrev;
        outBufStart = NULL;
        err  = GetNextBufferFunct(ioReader, inBufHandle, outBufStart, outBufLen);
    }

exit:
    return err;
}

CopyAndAdjustDeltaTimeContext::CopyAndAdjustDeltaTimeContext(TLVWriter *inWriter, EventLoadOutContext *inContext) :
    mWriter(inWriter),
    mContext(inContext)
{
}

EventEnvelopeContext::EventEnvelopeContext(void) :
    mNumFieldsToRead(2), // read out importance and either system or utc delta time. events do not store both deltas.
    mDeltaTime(0),
#if WEAVE_CONFIG_EVENT_LOGGING_UTC_TIMESTAMPS
    mDeltaUtc(0),
#endif // WEAVE_CONFIG_EVENT_LOGGING_UTC_TIMESTAMPS
    mImportance(kImportanceType_First)
{
}

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