/*
 * 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 _DECAF_UTIL_LOGGING_STREAMHANDLER_H_
#define _DECAF_UTIL_LOGGING_STREAMHANDLER_H_

#include <decaf/util/logging/LoggerCommon.h>
#include <decaf/util/logging/Handler.h>
#include <decaf/lang/exceptions/NullPointerException.h>
#include <decaf/lang/exceptions/InvalidStateException.h>
#include <decaf/util/concurrent/Concurrent.h>
#include <decaf/util/Config.h>

namespace decaf{
namespace io{
    class OutputStream;
    class Writer;
}
namespace util{
namespace logging{

    /**
     * Stream based logging Handler.
     *
     * This is primarily intended as a base class or support class to be used in implementing
     * other logging Handlers.
     *
     * LogRecords are published to a given <code>decaf::io::OutputStream</code>.
     *
     * Configuration: By default each StreamHandler is initialized using the following LogManager
     * configuration properties. If properties are not defined (or have invalid values) then the
     * specified default values are used.
     *
     *   * decaf.util.logging.StreamHandler.level specifies the default level for the Handler
     *     (defaults to Level.INFO).
     *   * decaf.util.logging.StreamHandler.filter specifies the name of a Filter class to use
     *     (defaults to no Filter).
     *   * decaf.util.logging.StreamHandler.formatter specifies the name of a Formatter class
     *     to use (defaults to decaf.util.logging.SimpleFormatter).
     *
     * @since 1.0
     */
    class DECAF_API StreamHandler : public Handler {
    private:

        // OutputStream to write to
        decaf::io::OutputStream* stream;

        // A Writer to wrap the OutputStream
        decaf::io::Writer* writer;

        // Indicates if the writer has been initialized already
        bool writerNotInitialized;

    private:

        StreamHandler( const StreamHandler& );
        StreamHandler& operator= ( const StreamHandler& );

    public:

        /**
         * Create a StreamHandler, with no current output stream.
         */
        StreamHandler();

        /**
         * Create a StreamHandler, with no current output stream.
         */
        StreamHandler( decaf::io::OutputStream* stream, Formatter* formatter );

        virtual ~StreamHandler();

        /**
         * Close the current output stream.
         *
         * The close method will perform a flush and then close the Handler.
         * After close has been called this Handler  should no longer be used.
         * Method calls may either be silently ignored or may throw runtime
         * exceptions.
         *
         * @throw IOException if an I/O error occurs.
         */
        virtual void close();

        /**
         * Flush the Handler's output, clears any buffers.
         */
        virtual void flush();

        /**
         * Publish the Log Record to this Handler
         *
         * @param record
         *      The <code>LogRecord</code> to Publish
         */
        virtual void publish( const LogRecord& record );

        /**
         * Check if this Handler would actually log a given LogRecord.
         * <p>
         * @param record
         *      <code>LogRecord</code> to check
         *
         * @return true if the record can be logged with current settings.
         */
        virtual bool isLoggable( const LogRecord& record ) const;

    protected:

        /**
         * Change the output stream.
         *
         * If there is a current output stream then the Formatter's tail string is written and
         * the stream is flushed and closed. Then the output stream is replaced with the new
         * output stream.
         *
         * @param stream
         *      The new output stream. May not be NULL.
         *
         * @throws NullPointerException if the passed stream is NULL.
         */
        virtual void setOuputStream( decaf::io::OutputStream* stream );

        /**
         * Closes this handler, but the underlying output stream is only closed if
         * closeStream is true.
         *
         * @param closeStream
         *      whether to close the underlying output stream.
         */
        void close( bool closeStream );

    private:

        // Safely writes the string to the output stream, calling the ErrorManager
        // if any exceptions are thrown while writing.
        void write( const std::string& value );

        // Initialize the Writer if its not already been initialized.
        void initializeWritter();

    };

}}}

#endif /*_DECAF_UTIL_LOGGING_STREAMHANDLER_H_*/