/*
 * 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