/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You 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.
 */

#ifndef _LOG4CXX_ASYNC_APPENDER_H
#define _LOG4CXX_ASYNC_APPENDER_H

#if defined(_MSC_VER)
#pragma warning ( push )
#pragma warning ( disable: 4231 4251 4275 4786 )
#endif


#include <log4cxx/appenderskeleton.h>
#include <log4cxx/helpers/appenderattachableimpl.h>
#include <deque>
#include <log4cxx/spi/loggingevent.h>
#include <log4cxx/helpers/thread.h>
#include <log4cxx/helpers/mutex.h>
#include <log4cxx/helpers/condition.h>

#if defined(NON_BLOCKING)
#include <boost/lockfree/queue.hpp>
#endif

namespace log4cxx
{
        LOG4CXX_LIST_DEF(LoggingEventList, log4cxx::spi::LoggingEventPtr);

        /**
        The AsyncAppender lets users log events asynchronously. It uses a
        bounded buffer to store logging events.

        <p>The AsyncAppender will collect the events sent to it and then
        dispatch them to all the appenders that are attached to it. You can
        attach multiple appenders to an AsyncAppender.

        <p>The AsyncAppender uses a separate thread to serve the events in
        its bounded buffer.

        <p><b>Important note:</b> The <code>AsyncAppender</code> can only
        be script configured using the {@link xml::DOMConfigurator DOMConfigurator}.
        */
        class LOG4CXX_EXPORT AsyncAppender :
                public virtual spi::AppenderAttachable,
                public virtual AppenderSkeleton
        {
        public:
                DECLARE_LOG4CXX_OBJECT(AsyncAppender)
                BEGIN_LOG4CXX_CAST_MAP()
                        LOG4CXX_CAST_ENTRY(AsyncAppender)
                        LOG4CXX_CAST_ENTRY_CHAIN(AppenderSkeleton)
                        LOG4CXX_CAST_ENTRY(spi::AppenderAttachable)
                END_LOG4CXX_CAST_MAP()

                /**
                 * Create new instance.
                */
                AsyncAppender();

                /**
                 *  Destructor.
                 */
                virtual ~AsyncAppender();

                void addRef() const;
                void releaseRef() const;

                /**
                 * Add appender.
                 *
                 * @param newAppender appender to add, may not be null.
                */
                void addAppender(const AppenderPtr& newAppender);

                virtual void doAppend(const spi::LoggingEventPtr& event,
                                      log4cxx::helpers::Pool& pool1);

                void append(const spi::LoggingEventPtr& event, log4cxx::helpers::Pool& p);

                /**
                Close this <code>AsyncAppender</code> by interrupting the
                dispatcher thread which will process all pending events before
                exiting.
                */
                void close();

                /**
                 * Get iterator over attached appenders.
                 * @return list of all attached appenders.
                */
                AppenderList getAllAppenders() const;

                /**
                 * Get appender by name.
                 *
                 * @param name name, may not be null.
                 * @return matching appender or null.
                */
                AppenderPtr getAppender(const LogString& name) const;

                /**
                 * Gets whether the location of the logging request call
                 * should be captured.
                 *
                 * @return the current value of the <b>LocationInfo</b> option.
                */
                bool getLocationInfo() const;
                /**
                * Determines if specified appender is attached.
                * @param appender appender.
                * @return true if attached.
                */
                bool isAttached(const AppenderPtr& appender) const;

                virtual bool requiresLayout() const;

                /**
                 * Removes and closes all attached appenders.
                */
                void removeAllAppenders();

                /**
                 * Removes an appender.
                 * @param appender appender to remove.
                */
                void removeAppender(const AppenderPtr& appender);
                /**
                * Remove appender by name.
                * @param name name.
                */
                void removeAppender(const LogString& name);

                /**
                * The <b>LocationInfo</b> attribute is provided for compatibility
                * with log4j and has no effect on the log output.
                * @param flag new value.
                */
                void setLocationInfo(bool flag);

                /**
                * The <b>BufferSize</b> option takes a non-negative integer value.
                * This integer value determines the maximum size of the bounded
                * buffer.
                * */
                void setBufferSize(int size);

                /**
                 * Gets the current buffer size.
                 * @return the current value of the <b>BufferSize</b> option.
                */
                int getBufferSize() const;

                /**
                 * Sets whether appender should wait if there is no
                 * space available in the event buffer or immediately return.
                 *
                 * @param value true if appender should wait until available space in buffer.
                 */
                 void setBlocking(bool value);

                /**
                 * Gets whether appender should block calling thread when buffer is full.
                 * If false, messages will be counted by logger and a summary
                 * message appended after the contents of the buffer have been appended.
                 *
                 * @return true if calling thread will be blocked when buffer is full.
                 */
                 bool getBlocking() const;


                 /**
                  * Set appender properties by name.
                  * @param option property name.
                  * @param value property value.
                  */
                 void setOption(const LogString& option, const LogString& value);


        private:
                AsyncAppender(const AsyncAppender&);
                AsyncAppender& operator=(const AsyncAppender&);
                /**
                 * The default buffer size is set to 128 events.
                */
                enum { DEFAULT_BUFFER_SIZE = 128 };

                /**
                 * Event buffer.
                */
#if defined(NON_BLOCKING)
                boost::lockfree::queue<log4cxx::spi::LoggingEvent* > buffer;
                std::atomic<size_t> discardedCount;
#else
                LoggingEventList buffer;
#endif

                /**
                 *  Mutex used to guard access to buffer and discardMap.
                 */
                SHARED_MUTEX bufferMutex;
                
#if defined(NON_BLOCKING)
                ::log4cxx::helpers::Semaphore bufferNotFull;
                ::log4cxx::helpers::Semaphore bufferNotEmpty;
#else
                ::log4cxx::helpers::Condition bufferNotFull;
                ::log4cxx::helpers::Condition bufferNotEmpty;
#endif
                class DiscardSummary {
                private:
                    /**
                     * First event of the highest severity.
                    */
                    ::log4cxx::spi::LoggingEventPtr maxEvent;

                    /**
                    * Total count of messages discarded.
                    */
                    int count;

                public:
                    /**
                     * Create new instance.
                     *
                     * @param event event, may not be null.
                    */
                    DiscardSummary(const ::log4cxx::spi::LoggingEventPtr& event);
                    /** Copy constructor.  */
                    DiscardSummary(const DiscardSummary& src);
                    /** Assignment operator. */
                    DiscardSummary& operator=(const DiscardSummary& src);

                    /**
                     * Add discarded event to summary.
                     *
                     * @param event event, may not be null.
                    */
                    void add(const ::log4cxx::spi::LoggingEventPtr& event);

                    /**
                     * Create event with summary information.
                     *
                     * @return new event.
                     */
                     ::log4cxx::spi::LoggingEventPtr createEvent(::log4cxx::helpers::Pool& p);

                     static
                     ::log4cxx::spi::LoggingEventPtr createEvent(::log4cxx::helpers::Pool& p,
                                                                 size_t discardedCount);
                };

                /**
                  * Map of DiscardSummary objects keyed by logger name.
                */
                typedef std::map<LogString, DiscardSummary> DiscardMap;
                DiscardMap* discardMap;

                /**
                 * Buffer size.
                */
                int bufferSize;

                /**
                 * Nested appenders.
                */
                helpers::AppenderAttachableImplPtr appenders;

                /**
                 *  Dispatcher.
                 */
                helpers::Thread dispatcher;

                /**
                 * Should location info be included in dispatched messages.
                */
                bool locationInfo;

                /**
                 * Does appender block when buffer is full.
                */
                bool blocking;

                /**
                 *  Dispatch routine.
                 */
                static void* LOG4CXX_THREAD_FUNC dispatch(apr_thread_t* thread, void* data);

        }; // class AsyncAppender
        LOG4CXX_PTR_DEF(AsyncAppender);
}  //  namespace log4cxx

#if defined(_MSC_VER)
#pragma warning ( pop )
#endif


#endif//  _LOG4CXX_ASYNC_APPENDER_H