/*

* Copyright (c) 2008 Nokia Corporation and/or its subsidiary(-ies). 

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:  Writer for logging

 *

*/

package com.nokia.tools.themeinstaller.logger;

import java.io.File;

import java.io.IOException;

import java.util.logging.ConsoleHandler;

import java.util.logging.FileHandler;

import java.util.logging.Level;

import java.util.logging.Logger;

/**

 * Class for writing logs to file or console.

 * This LogWriter is a singleton version of using logging

 * so that there is no need to instantiate Logger in

 * every class that uses logs.

 *

 * NOTE: User of this class has to make sure that closeInstance() is

 * called when logger is no longer used. If this is not called,

 * the used file resources are not closed.

 */

public class LogWriter

    {

    // The logger used in writing.

    private static Logger iLogger = Logger.getLogger( LogWriter.class.getName() );

    // Singleton instance

    private static LogWriter sInstance = null;

    // Filename for log writing

    private static String sLogFileName = null;

    // Log file constants

    private final static String LOG_FILENAME = "ThemeInstaller";

    private final static String UNDERLINE_CHARACTER = "_";

    private final static String LOG_FILENAME_EXTENSION = ".log";

    // Date format for log filename

    private final static String DATE_FORMAT = "yyyyMMdd_HHmmssSS";

    /**

     * Instantiates a new log writer for console.

     *

     * @param aLevel The level

     */

    private LogWriter( Level aLevel )

        {

        iLogger.setLevel( aLevel );

        // If level == OFF, no need to continue the instantiating

        if ( aLevel == Level.OFF )

            {

            return;

            }

        // Disabling parent handlers so that the console handler remains as only

        // handler

        iLogger.setUseParentHandlers( false );

        ConsoleHandler consoleHandler = new ConsoleHandler();

        consoleHandler.setFormatter( new LogFormatter() );

        iLogger.addHandler( consoleHandler );

        }

    /**

     * Instantiates a new log writer for file.

     *

     * @param aDir The directory for log files

     * @param aLevel The level

     */

    private LogWriter( File aDir, Level aLevel )

        {

        try

            {

            iLogger.setLevel( aLevel );

            // If level == OFF, no need to continue the instantiating

            if ( aLevel == Level.OFF )

                {

                return;

                }

            // Disabling parent handlers so that the file handler remains as only

            // handler

            iLogger.setUseParentHandlers( false );

            String filename = validateDir( aDir );

            FileHandler fileHandler = new FileHandler( filename );

            fileHandler.setFormatter( new LogFormatter() );

            iLogger.addHandler( fileHandler );

            }

        catch ( IOException e )

            {

            iLogger.log( Level.SEVERE, "Unable to create logging file.", e );

            }

        }

    /**

     * Gets the level.

     *

     * @return The level

     */

    public Level getLevel()

        {

        return iLogger.getLevel();

        }

    /**

     * Close file.

     */

    private static void closeFile()

        {

        if ( iLogger.getHandlers().length > 0

        // LogWriter has maximum of 1 handler

                && iLogger.getHandlers()[ 0 ] instanceof FileHandler )

            {

            iLogger.getHandlers()[ 0 ].close();

            }

        }

    /**

     * Validate that directory for logging exists.

     *

     * @param aDir The directory

     *

     * @return Log file name

     */

    private String validateDir( File aDir )

        {

        if ( aDir.isFile() )

            {

            throw new IllegalArgumentException( "Invalid log file path. Not a directory: " + aDir );

            }

        // Create directory structure

        if ( !aDir.exists() )

            {

            aDir.mkdirs();

            }

        return aDir + File.separator + LOG_FILENAME + UNDERLINE_CHARACTER

                + LogFormatter.dateToString( DATE_FORMAT, System.currentTimeMillis() )

                + LOG_FILENAME_EXTENSION;

        }

    /**

     * Sets the level for logging.

     *

     * @param level The logging level in scale from 0 to 7

     */

    public void setLevel( int aLevel )

        {

        if ( aLevel < 0 || 7 < aLevel )

            {

            throw new IllegalStateException(

                    "Trying to set invalid logging level" );

            }

        switch ( aLevel )

            {

            case 0:

                iLogger.setLevel( Level.ALL );

                break;

            case 1:

                iLogger.setLevel( Level.FINEST );

                break;

            case 2:

                iLogger.setLevel( Level.FINER );

                break;

            case 3:

                iLogger.setLevel( Level.FINE );

                break;

            case 4:

                iLogger.setLevel( Level.CONFIG );

                break;

            case 5:

                iLogger.setLevel( Level.INFO );

                break;

            case 6:

                iLogger.setLevel( Level.WARNING );

                break;

            case 7:

                iLogger.setLevel( Level.SEVERE );

                break;

            default:

                break;

            }

        }

    /**

     * Check if logger is in console mode.

     *

     * @return true, if Logger is writing on console

     */

    public boolean inConsoleMode()

        {

        if ( iLogger.getHandlers().length > 0

                // LogWriter has maximum of 1 handler

                && iLogger.getHandlers()[ 0 ] instanceof ConsoleHandler )

            {

            return true;

            }

        return false;

        }

    /**

     * Log severe.

     *

     * @param aMessage The message for logging

     */

    public void logSevere( String aMessage )

        {

        iLogger.log( Level.SEVERE, aMessage );

        }

    /**

     * Log warning.

     *

     * @param aMessage The message for logging

     */

    public void logWarning( String aMessage )

        {

        iLogger.log( Level.WARNING, aMessage );

        }

    /**

     * Log info.

     *

     * @param aMessage The message for logging

     */

    public void logInfo( String aMessage )

        {

        iLogger.log( Level.INFO, aMessage );

        }

    /**

     * Log message.

     *

     * @param aMessage The message for logging

     */

    public void logConfig( String aMessage )

        {

        iLogger.log( Level.CONFIG, aMessage );

        }

    /**

     * Log fine.

     *

     * @param aMessage The message for logging

     */

    public void logFine( String aMessage )

        {

        iLogger.log( Level.FINE, aMessage );

        }

    /**

     * Closes singleton resources and removes the singleton instance

     */

    public static synchronized void closeInstance()

        {

        closeFile();

        sInstance = null;

        }

    /**

     * Gets the single instance of LogWriter.

     * Note that initialize method has to be called

     * before this.

     *

     * @return Single instance of LogWriter

     */

    public static synchronized LogWriter getInstance()

        {

        if ( sInstance == null )

            {

            // Initialize method not called yet

            sInstance = new LogWriter( Level.OFF );

            }

        return sInstance;

        }

    /**

     * Initialize new instance of LogWriter.

     * Note that the default logging level is Level.ALL.

     *

     * @param aDir The directory for writing log

     *

     * @throws IOException Signals that an I/O exception has occurred.

     */

    public static void initialize( File aDir ) throws IOException

        {

        // Already initialized if:

        // sInstance is not null AND

        // sLogFileName equals with aLogFile

        if ( sInstance != null &&

           ( sLogFileName != null && aDir != null && sLogFileName.equals( aDir.getPath() ) ||

           ( sLogFileName == null && aDir == null ) ) )

            {

            return;

            }

        // Create a new instance

        // If no log file given, the log is written in console

        if ( aDir == null )

            {

            sInstance = new LogWriter( Level.ALL );

            sLogFileName = null;

            }

        else

            {

            sInstance = new LogWriter( aDir, Level.ALL );

            sLogFileName = aDir.getPath();

            }

        }

    }