DI the logging plugin.

Change-Id: I7b8fd7a83d4431dcf551a171fbb23caeb6100c2e
Reviewed-on: http://gerrit.dmdirc.com/3179
Automatic-Compile: DMDirc Build Manager
Reviewed-by: Greg Holmes <greg@dmdirc.com>

src/com/dmdirc/addons/logging/LoggingCommand.java

@@ -32,8 +32,10 @@ import com.dmdirc.commandparser.commands.context.CommandContext;
 import com.dmdirc.interfaces.CommandController;
 import com.dmdirc.ui.input.AdditionalTabTargets;
 
+import javax.inject.Inject;
+
 /**
- * The dcop command retrieves information from a dcop application.
+ * The logging command retrieves information from a dcop application.
  */
 public class LoggingCommand extends Command implements IntelligentCommand {
 
@@ -41,20 +43,21 @@ public class LoggingCommand extends Command implements IntelligentCommand {
     private static final String LOGGING = "logging";
     /** A command info object for this command. */
     public static final BaseCommandInfo INFO = new BaseCommandInfo(LOGGING,
-            "logging - <set|help> [parameters]",
+            "logging <history|help> - view logging related information",
             CommandType.TYPE_SERVER);
-    /** Logging plugin. */
-    private final LoggingPlugin plugin;
+    /** Logging manager. */
+    private final LoggingManager manager;
 
     /**
      * Creates a new instance of this command.
      *
      * @param controller The controller to use for command information.
-     * @param plugin     The plugin providing logging services.
+     * @param manager    The manager providing logging services.
      */
-    public LoggingCommand(final CommandController controller, final LoggingPlugin plugin) {
+    @Inject
+    public LoggingCommand(final CommandController controller, final LoggingManager manager) {
         super(controller);
-        this.plugin = plugin;
+        this.manager = manager;
     }
 
     /** {@inheritDoc} */
@@ -63,13 +66,11 @@ public class LoggingCommand extends Command implements IntelligentCommand {
             final CommandArguments args, final CommandContext context) {
         if (args.getArguments().length > 0) {
             if (args.getArguments()[0].equalsIgnoreCase("history")) {
-                if (!plugin.showHistory(origin)) {
+                if (!manager.showHistory(origin)) {
                     sendLine(origin, args.isSilent(), FORMAT_ERROR,
                             "Unable to open history for this window.");
                 }
             } else if (args.getArguments()[0].equalsIgnoreCase("help")) {
-                sendLine(origin, args.isSilent(), FORMAT_OUTPUT, LOGGING
-                        + " reload           - Reload the logging plugin.");
                 sendLine(origin, args.isSilent(), FORMAT_OUTPUT, LOGGING
                         + " history          - Open the history of this window, if available.");
                 sendLine(origin, args.isSilent(), FORMAT_OUTPUT, LOGGING
@@ -90,7 +91,6 @@ public class LoggingCommand extends Command implements IntelligentCommand {
             final IntelligentCommandContext context) {
         final AdditionalTabTargets res = new AdditionalTabTargets();
         if (arg == 0) {
-            res.add("reload");
             res.add("history");
             res.add("help");
             res.excludeAll();

src/com/dmdirc/addons/logging/LoggingManager.java

@@ -0,0 +1,858 @@
+/*
+ * Copyright (c) 2006-2014 DMDirc Developers
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package com.dmdirc.addons.logging;
+
+import com.dmdirc.Channel;
+import com.dmdirc.ClientModule.GlobalConfig;
+import com.dmdirc.FrameContainer;
+import com.dmdirc.Query;
+import com.dmdirc.actions.CoreActionType;
+import com.dmdirc.addons.logging.LoggingModule.LoggingDomain;
+import com.dmdirc.commandline.CommandLineOptionsModule.Directory;
+import com.dmdirc.interfaces.ActionController;
+import com.dmdirc.interfaces.ActionListener;
+import com.dmdirc.interfaces.Connection;
+import com.dmdirc.interfaces.actions.ActionType;
+import com.dmdirc.interfaces.config.AggregateConfigProvider;
+import com.dmdirc.interfaces.config.ConfigChangeListener;
+import com.dmdirc.logger.ErrorLevel;
+import com.dmdirc.logger.Logger;
+import com.dmdirc.parser.interfaces.ChannelClientInfo;
+import com.dmdirc.parser.interfaces.ChannelInfo;
+import com.dmdirc.parser.interfaces.ClientInfo;
+import com.dmdirc.parser.interfaces.Parser;
+import com.dmdirc.ui.WindowManager;
+import com.dmdirc.ui.messages.Styliser;
+import com.dmdirc.util.URLBuilder;
+import com.dmdirc.util.io.ReverseFileReader;
+import com.dmdirc.util.io.StreamUtils;
+
+import java.awt.Color;
+import java.io.BufferedWriter;
+import java.io.File;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.math.BigInteger;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import java.text.DateFormat;
+import java.text.SimpleDateFormat;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Stack;
+import java.util.Timer;
+import java.util.TimerTask;
+
+import javax.inject.Inject;
+import javax.inject.Provider;
+import javax.inject.Singleton;
+
+/**
+ * Manages logging activities.
+ */
+@Singleton
+public class LoggingManager implements ActionListener, ConfigChangeListener {
+
+    /** Date format used for "File Opened At" log. */
+    private static final DateFormat OPENED_AT_FORMAT = new SimpleDateFormat(
+            "EEEE MMMM dd, yyyy - HH:mm:ss");
+    /** This plugin's plugin info. */
+    private final String domain;
+    /** The action controller to use. */
+    private final ActionController actionController;
+    /** Global config. */
+    private final AggregateConfigProvider config;
+    /** The manager to add history windows to. */
+    private final WindowManager windowManager;
+    /** Map of open files. */
+    private final Map<String, OpenFile> openFiles = Collections.synchronizedMap(
+            new HashMap<String, OpenFile>());
+    private final URLBuilder urlBuilder;
+    private final Provider<String> directoryProvider;
+    /** Timer used to close idle files. */
+    private Timer idleFileTimer;
+    /** Cached boolean settings. */
+    private boolean networkfolders;
+    private boolean filenamehash;
+    private boolean addtime;
+    private boolean stripcodes;
+    private boolean channelmodeprefix;
+    private boolean autobackbuffer;
+    private boolean backbufferTimestamp;
+    private boolean usedate;
+    /** Cached string settings. */
+    private String timestamp;
+    private String usedateformat;
+    private String colour;
+    /** Cached int settings. */
+    private int historyLines;
+    private int backbufferLines;
+
+    @Inject
+    public LoggingManager(
+            @LoggingDomain final String domain,
+            final ActionController actionController,
+            @GlobalConfig final AggregateConfigProvider globalConfig,
+            final WindowManager windowManager,
+            final URLBuilder urlBuilder,
+            @Directory(LoggingModule.LOGS_DIRECTORY) final Provider<String> directoryProvider) {
+        this.domain = domain;
+        this.actionController = actionController;
+        this.config = globalConfig;
+        this.windowManager = windowManager;
+        this.urlBuilder = urlBuilder;
+        this.directoryProvider = directoryProvider;
+    }
+
+    public void load() {
+        setCachedSettings();
+
+        final File dir = new File(directoryProvider.get());
+        if (dir.exists()) {
+            if (!dir.isDirectory()) {
+                Logger.userError(ErrorLevel.LOW,
+                        "Unable to create logging dir (file exists instead)");
+            }
+        } else {
+            if (!dir.mkdirs()) {
+                Logger.userError(ErrorLevel.LOW, "Unable to create logging dir");
+            }
+        }
+
+        config.addChangeListener(domain, this);
+
+        actionController.registerListener(this,
+                CoreActionType.CHANNEL_OPENED,
+                CoreActionType.CHANNEL_CLOSED,
+                CoreActionType.CHANNEL_MESSAGE,
+                CoreActionType.CHANNEL_SELF_MESSAGE,
+                CoreActionType.CHANNEL_ACTION,
+                CoreActionType.CHANNEL_SELF_ACTION,
+                CoreActionType.CHANNEL_GOTTOPIC,
+                CoreActionType.CHANNEL_TOPICCHANGE,
+                CoreActionType.CHANNEL_JOIN,
+                CoreActionType.CHANNEL_PART,
+                CoreActionType.CHANNEL_QUIT,
+                CoreActionType.CHANNEL_KICK,
+                CoreActionType.CHANNEL_NICKCHANGE,
+                CoreActionType.CHANNEL_MODECHANGE,
+                CoreActionType.QUERY_OPENED,
+                CoreActionType.QUERY_CLOSED,
+                CoreActionType.QUERY_MESSAGE,
+                CoreActionType.QUERY_SELF_MESSAGE,
+                CoreActionType.QUERY_ACTION,
+                CoreActionType.QUERY_SELF_ACTION);
+
+        // Close idle files every hour.
+        idleFileTimer = new Timer("LoggingPlugin Timer");
+        idleFileTimer.schedule(new TimerTask() {
+            /** {@inheritDoc} */
+            @Override
+            public void run() {
+                timerTask();
+            }
+        }, 3600000);
+    }
+
+    public void unload() {
+        if (idleFileTimer != null) {
+            idleFileTimer.cancel();
+            idleFileTimer.purge();
+        }
+
+        actionController.unregisterListener(this);
+
+        synchronized (openFiles) {
+            for (OpenFile file : openFiles.values()) {
+                StreamUtils.close(file.writer);
+            }
+            openFiles.clear();
+        }
+    }
+
+    /**
+     * What to do every hour when the timer fires.
+     */
+    protected void timerTask() {
+        // Oldest time to allow
+        final long oldestTime = System.currentTimeMillis() - 3480000;
+
+        synchronized (openFiles) {
+            final Collection<String> old = new ArrayList<>(openFiles.size());
+            for (Map.Entry<String, OpenFile> entry : openFiles.entrySet()) {
+                if (entry.getValue().lastUsedTime < oldestTime) {
+                    StreamUtils.close(entry.getValue().writer);
+                    old.add(entry.getKey());
+                }
+            }
+
+            openFiles.keySet().removeAll(old);
+        }
+    }
+
+    /**
+     * Log a query-related event.
+     *
+     * @param type      The type of the event to process
+     * @param format    Format of messages that are about to be sent. (May be null)
+     * @param arguments The arguments for the event
+     */
+    protected void handleQueryEvent(final CoreActionType type, final StringBuffer format,
+            final Object... arguments) {
+        final Query query = (Query) arguments[0];
+        if (query.getConnection() == null) {
+            Logger.appError(ErrorLevel.MEDIUM, "Query object has no server (" + type.toString()
+                    + ")", new Exception("Query object has no server (" + type.toString() + ")"));
+            return;
+        }
+
+        final Parser parser = query.getConnection().getParser();
+        ClientInfo client;
+
+        if (parser == null) {
+            // Without a parser object, we might not be able to find the file to log this to.
+            if (networkfolders) {
+                // We *wont* be able to, so rather than logging to an incorrect file we just won't log.
+                return;
+            }
+            client = null;
+        } else {
+            client = parser.getClient(query.getHost());
+        }
+
+        final String filename = getLogFile(client);
+
+        switch (type) {
+            case QUERY_OPENED:
+                if (autobackbuffer) {
+                    showBackBuffer(query, filename);
+                }
+
+                appendLine(filename, "*** Query opened at: %s", OPENED_AT_FORMAT.format(new Date()));
+                appendLine(filename, "*** Query with User: %s", query.getHost());
+                appendLine(filename, "");
+                break;
+            case QUERY_CLOSED:
+                appendLine(filename, "*** Query closed at: %s", OPENED_AT_FORMAT.format(new Date()));
+                if (openFiles.containsKey(filename)) {
+                    StreamUtils.close(openFiles.get(filename).writer);
+                    openFiles.remove(filename);
+                }
+                break;
+            case QUERY_MESSAGE:
+            case QUERY_SELF_MESSAGE:
+            case QUERY_ACTION:
+            case QUERY_SELF_ACTION:
+                final boolean isME = (type == CoreActionType.QUERY_SELF_MESSAGE || type
+                        == CoreActionType.QUERY_SELF_ACTION);
+                final String overrideNick = isME ? getDisplayName(parser.getLocalClient()) : "";
+
+                if (type == CoreActionType.QUERY_MESSAGE || type
+                        == CoreActionType.QUERY_SELF_MESSAGE) {
+                    appendLine(filename, "<%s> %s", getDisplayName(client, overrideNick),
+                            arguments[2]);
+                } else {
+                    appendLine(filename, "* %s %s", getDisplayName(client, overrideNick),
+                            arguments[2]);
+                }
+                break;
+        }
+    }
+
+    /**
+     * Log a channel-related event.
+     *
+     * @param type      The type of the event to process
+     * @param format    Format of messages that are about to be sent. (May be null)
+     * @param arguments The arguments for the event
+     */
+    protected void handleChannelEvent(final CoreActionType type, final StringBuffer format,
+            final Object... arguments) {
+        final Channel chan = ((Channel) arguments[0]);
+        final ChannelInfo channel = chan.getChannelInfo();
+        final String filename = getLogFile(channel);
+
+        final ChannelClientInfo channelClient = (arguments.length > 1
+                && arguments[1] instanceof ChannelClientInfo) ? (ChannelClientInfo) arguments[1]
+                : null;
+        final ClientInfo client = channelClient == null ? null : channelClient.getClient();
+
+        final String message = (arguments.length > 2 && arguments[2] instanceof String)
+                ? (String) arguments[2] : null;
+
+        switch (type) {
+            case CHANNEL_OPENED:
+                if (autobackbuffer) {
+                    showBackBuffer(chan, filename);
+                }
+
+                appendLine(filename, "*** Channel opened at: %s", OPENED_AT_FORMAT.
+                        format(new Date()));
+                appendLine(filename, "");
+                break;
+            case CHANNEL_CLOSED:
+                appendLine(filename, "*** Channel closed at: %s", OPENED_AT_FORMAT.
+                        format(new Date()));
+                if (openFiles.containsKey(filename)) {
+                    StreamUtils.close(openFiles.get(filename).writer);
+                    openFiles.remove(filename);
+                }
+                break;
+            case CHANNEL_MESSAGE:
+            case CHANNEL_SELF_MESSAGE:
+            case CHANNEL_ACTION:
+            case CHANNEL_SELF_ACTION:
+                if (type == CoreActionType.CHANNEL_MESSAGE || type
+                        == CoreActionType.CHANNEL_SELF_MESSAGE) {
+                    appendLine(filename, "<%s> %s", getDisplayName(client), message);
+                } else {
+                    appendLine(filename, "* %s %s", getDisplayName(client), message);
+                }
+                break;
+            case CHANNEL_GOTTOPIC:
+                // ActionManager.processEvent(CoreActionType.CHANNEL_GOTTOPIC, this);
+                final DateFormat timeFormat = new SimpleDateFormat("HH:mm:ss");
+                final DateFormat dateFormat = new SimpleDateFormat("dd/MM/yyyy");
+
+                appendLine(filename, "*** Topic is: %s", channel.getTopic());
+                appendLine(filename, "*** Set at: %s on %s by %s", timeFormat.format(1000 * channel.
+                        getTopicTime()), dateFormat.format(1000 * channel.getTopicTime()), channel.
+                        getTopicSetter());
+                break;
+            case CHANNEL_TOPICCHANGE:
+                appendLine(filename, "*** %s Changed the topic to: %s",
+                        getDisplayName(channelClient), message);
+                break;
+            case CHANNEL_JOIN:
+                appendLine(filename, "*** %s (%s) joined the channel", getDisplayName(channelClient),
+                        client.toString());
+                break;
+            case CHANNEL_PART:
+                if (message.isEmpty()) {
+                    appendLine(filename, "*** %s (%s) left the channel", getDisplayName(
+                            channelClient), client.toString());
+                } else {
+                    appendLine(filename, "*** %s (%s) left the channel (%s)", getDisplayName(
+                            channelClient), client.toString(), message);
+                }
+                break;
+            case CHANNEL_QUIT:
+                if (message.isEmpty()) {
+                    appendLine(filename, "*** %s (%s) Quit IRC", getDisplayName(channelClient),
+                            client.toString());
+                } else {
+                    appendLine(filename, "*** %s (%s) Quit IRC (%s)", getDisplayName(channelClient),
+                            client.toString(), message);
+                }
+                break;
+            case CHANNEL_KICK:
+                final String kickReason = (String) arguments[3];
+                final ChannelClientInfo kickedClient = (ChannelClientInfo) arguments[2];
+
+                if (kickReason.isEmpty()) {
+                    appendLine(filename, "*** %s was kicked by %s", getDisplayName(kickedClient),
+                            getDisplayName(channelClient));
+                } else {
+                    appendLine(filename, "*** %s was kicked by %s (%s)",
+                            getDisplayName(kickedClient), getDisplayName(channelClient), kickReason);
+                }
+                break;
+            case CHANNEL_NICKCHANGE:
+                appendLine(filename, "*** %s is now %s", getDisplayName(channelClient, message),
+                        getDisplayName(channelClient));
+                break;
+            case CHANNEL_MODECHANGE:
+                if (channelClient.getClient().getNickname().isEmpty()) {
+                    appendLine(filename, "*** Channel modes are: %s", message);
+                } else {
+                    appendLine(filename, "*** %s set modes: %s", getDisplayName(channelClient),
+                            message);
+                }
+                break;
+        }
+    }
+
+    /**
+     * Process an event of the specified type.
+     *
+     * @param type      The type of the event to process
+     * @param format    Format of messages that are about to be sent. (May be null)
+     * @param arguments The arguments for the event
+     */
+    @Override
+    public void processEvent(final ActionType type, final StringBuffer format,
+            final Object... arguments) {
+        if (type instanceof CoreActionType) {
+            final CoreActionType thisType = (CoreActionType) type;
+
+            switch (thisType) {
+                case CHANNEL_OPENED:
+                case CHANNEL_CLOSED:
+                case CHANNEL_MESSAGE:
+                case CHANNEL_SELF_MESSAGE:
+                case CHANNEL_ACTION:
+                case CHANNEL_SELF_ACTION:
+                case CHANNEL_GOTTOPIC:
+                case CHANNEL_TOPICCHANGE:
+                case CHANNEL_JOIN:
+                case CHANNEL_PART:
+                case CHANNEL_QUIT:
+                case CHANNEL_KICK:
+                case CHANNEL_NICKCHANGE:
+                case CHANNEL_MODECHANGE:
+                    handleChannelEvent(thisType, format, arguments);
+                    break;
+                case QUERY_OPENED:
+                case QUERY_CLOSED:
+                case QUERY_MESSAGE:
+                case QUERY_SELF_MESSAGE:
+                case QUERY_ACTION:
+                case QUERY_SELF_ACTION:
+                    handleQueryEvent(thisType, format, arguments);
+                    break;
+                default:
+                    break;
+            }
+        }
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public void configChanged(final String domain, final String key) {
+        setCachedSettings();
+    }
+
+    /**
+     * Add a backbuffer to a frame.
+     *
+     * @param frame    The frame to add the backbuffer lines to
+     * @param filename File to get backbuffer from
+     */
+    protected void showBackBuffer(final FrameContainer frame, final String filename) {
+        if (frame == null) {
+            Logger.userError(ErrorLevel.LOW, "Given a null frame");
+            return;
+        }
+
+        final File testFile = new File(filename);
+        if (testFile.exists()) {
+            try {
+                final ReverseFileReader file = new ReverseFileReader(testFile);
+                // Because the file includes a newline char at the end, an empty line
+                // is returned by getLines. To counter this, we call getLines(1) and do
+                // nothing with the output.
+                file.getLines(1);
+                final Stack<String> lines = file.getLines(backbufferLines);
+                while (!lines.empty()) {
+                    frame.addLine(getColouredString(colour, lines.pop()), backbufferTimestamp);
+                }
+                file.close();
+                frame.addLine(getColouredString(colour, "--- End of backbuffer\n"),
+                        backbufferTimestamp);
+            } catch (IOException | SecurityException e) {
+                Logger.userError(ErrorLevel.LOW, "Unable to show backbuffer (Filename: " + filename
+                        + "): " + e.getMessage());
+            }
+        }
+    }
+
+    /**
+     * Get a coloured String. If colour is invalid, IRC Colour 14 will be used.
+     *
+     * @param colour The colour the string should be (IRC Colour or 6-digit hex colour)
+     * @param line   the line to colour
+     *
+     * @return The given line with the appropriate irc codes appended/prepended to colour it.
+     */
+    protected static String getColouredString(final String colour, final String line) {
+        String res = null;
+        if (colour.length() < 3) {
+            int num;
+
+            try {
+                num = Integer.parseInt(colour);
+            } catch (NumberFormatException ex) {
+                num = -1;
+            }
+
+            if (num >= 0 && num <= 15) {
+                res = String.format("%c%02d%s%1$c", Styliser.CODE_COLOUR, num, line);
+            }
+        } else if (colour.length() == 6) {
+            try {
+                Color.decode("#" + colour);
+                res = String.format("%c%s%s%1$c", Styliser.CODE_HEXCOLOUR, colour, line);
+            } catch (NumberFormatException ex) { /* Do Nothing */ }
+        }
+
+        if (res == null) {
+            res = String.format("%c%02d%s%1$c", Styliser.CODE_COLOUR, 14, line);
+        }
+        return res;
+    }
+
+    /**
+     * Add a line to a file.
+     *
+     * @param filename Name of file to write to
+     * @param format   Format of line to add. (NewLine will be added Automatically)
+     * @param args     Arguments for format
+     *
+     * @return true on success, else false.
+     */
+    protected boolean appendLine(final String filename, final String format, final Object... args) {
+        return appendLine(filename, String.format(format, args));
+    }
+
+    /**
+     * Add a line to a file.
+     *
+     * @param filename Name of file to write to
+     * @param line     Line to add. (NewLine will be added Automatically)
+     *
+     * @return true on success, else false.
+     */
+    protected boolean appendLine(final String filename, final String line) {
+        final StringBuffer finalLine = new StringBuffer();
+
+        if (addtime) {
+            String dateString;
+            try {
+                final DateFormat dateFormat = new SimpleDateFormat(timestamp);
+                dateString = dateFormat.format(new Date()).trim();
+            } catch (IllegalArgumentException iae) {
+                // Default to known good format
+                final DateFormat dateFormat = new SimpleDateFormat("[dd/MM/yyyy HH:mm:ss]");
+                dateString = dateFormat.format(new Date()).trim();
+
+                Logger.userError(ErrorLevel.LOW, "Dateformat String '" + timestamp
+                        + "' is invalid. For more information: http://java.sun.com/javase/6/docs/api/java/text/SimpleDateFormat.html");
+            }
+            finalLine.append(dateString);
+            finalLine.append(' ');
+        }
+
+        if (stripcodes) {
+            finalLine.append(Styliser.stipControlCodes(line));
+        } else {
+            finalLine.append(line);
+        }
+
+        BufferedWriter out;
+        try {
+            if (openFiles.containsKey(filename)) {
+                final OpenFile of = openFiles.get(filename);
+                of.lastUsedTime = System.currentTimeMillis();
+                out = of.writer;
+            } else {
+                out = new BufferedWriter(new FileWriter(filename, true));
+                openFiles.put(filename, new OpenFile(out));
+            }
+            out.write(finalLine.toString());
+            out.newLine();
+            out.flush();
+            return true;
+        } catch (IOException e) {
+            /*
+             * Do Nothing
+             *
+             * Makes no sense to keep adding errors to the logger when we can't write to the file,
+             * as chances are it will happen on every incomming line.
+             */
+        }
+        return false;
+    }
+
+    /**
+     * Get the name of the log file for a specific object.
+     *
+     * @param obj Object to get name for
+     *
+     * @return the name of the log file to use for this object.
+     */
+    protected String getLogFile(final Object obj) {
+        final StringBuffer directory = new StringBuffer();
+        final StringBuffer file = new StringBuffer();
+        String md5String = "";
+
+        directory.append(directoryProvider.get());
+        if (directory.charAt(directory.length() - 1) != File.separatorChar) {
+            directory.append(File.separatorChar);
+        }
+
+        if (obj == null) {
+            file.append("null.log");
+        } else if (obj instanceof ChannelInfo) {
+            final ChannelInfo channel = (ChannelInfo) obj;
+            if (channel.getParser() != null) {
+                addNetworkDir(directory, file, channel.getParser().getNetworkName());
+            }
+            file.append(sanitise(channel.getName().toLowerCase()));
+            md5String = channel.getName();
+        } else if (obj instanceof ClientInfo) {
+            final ClientInfo client = (ClientInfo) obj;
+            if (client.getParser() != null) {
+                addNetworkDir(directory, file, client.getParser().getNetworkName());
+            }
+            file.append(sanitise(client.getNickname().toLowerCase()));
+            md5String = client.getNickname();
+        } else {
+            file.append(sanitise(obj.toString().toLowerCase()));
+            md5String = obj.toString();
+        }
+
+        if (usedate) {
+            final String dateFormat = usedateformat;
+            final String dateDir = new SimpleDateFormat(dateFormat).format(new Date());
+            directory.append(dateDir);
+            if (directory.charAt(directory.length() - 1) != File.separatorChar) {
+                directory.append(File.separatorChar);
+            }
+
+            if (!new File(directory.toString()).exists() && !(new File(directory.toString())).
+                    mkdirs()) {
+                Logger.userError(ErrorLevel.LOW, "Unable to create date dirs");
+            }
+        }
+
+        if (filenamehash) {
+            file.append('.');
+            file.append(md5(md5String));
+        }
+        file.append(".log");
+
+        return directory.toString() + file.toString();
+    }
+
+    /**
+     * This function adds the networkName to the log file. It first tries to create a directory for
+     * each network, if that fails it will prepend the networkName to the filename instead.
+     *
+     * @param directory   Current directory name
+     * @param file        Current file name
+     * @param networkName Name of network
+     */
+    protected void addNetworkDir(final StringBuffer directory, final StringBuffer file,
+            final String networkName) {
+        if (!networkfolders) {
+            return;
+        }
+
+        final String network = sanitise(networkName.toLowerCase());
+
+        boolean prependNetwork = false;
+
+        // Check dir exists
+        final File dir = new File(directory.toString() + network + System.getProperty(
+                "file.separator"));
+        if (dir.exists() && !dir.isDirectory()) {
+            Logger.userError(ErrorLevel.LOW,
+                    "Unable to create networkfolders dir (file exists instead)");
+            // Prepend network name to file instead.
+            prependNetwork = true;
+        } else if (!dir.exists() && !dir.mkdirs()) {
+            Logger.userError(ErrorLevel.LOW, "Unable to create networkfolders dir");
+            prependNetwork = true;
+        }
+
+        if (prependNetwork) {
+            file.insert(0, " -- ");
+            file.insert(0, network);
+        } else {
+            directory.append(network);
+            directory.append(System.getProperty("file.separator"));
+        }
+    }
+
+    /**
+     * Sanitise a string to be used as a filename.
+     *
+     * @param name String to sanitise
+     *
+     * @return Sanitised version of name that can be used as a filename.
+     */
+    protected static String sanitise(final String name) {
+        // Replace illegal chars with
+        return name.replaceAll("[^\\w\\.\\s\\-\\#\\&\\_]", "_");
+    }
+
+    /**
+     * Get the md5 hash of a string.
+     *
+     * @param string String to hash
+     *
+     * @return md5 hash of given string
+     */
+    protected static String md5(final String string) {
+        try {
+            final MessageDigest m = MessageDigest.getInstance("MD5");
+            m.update(string.getBytes(), 0, string.length());
+            return new BigInteger(1, m.digest()).toString(16);
+        } catch (NoSuchAlgorithmException e) {
+            return "";
+        }
+    }
+
+    /**
+     * Get name to display for client.
+     *
+     * @param client The client to get the display name for
+     *
+     * @return name to display
+     */
+    protected String getDisplayName(final ClientInfo client) {
+        return getDisplayName(client, "");
+    }
+
+    /**
+     * Get name to display for client.
+     *
+     * @param client       The client to get the display name for
+     * @param overrideNick Nickname to display instead of real nickname
+     *
+     * @return name to display
+     */
+    protected String getDisplayName(final ClientInfo client, final String overrideNick) {
+        if (overrideNick.isEmpty()) {
+            return (client == null) ? "Unknown Client" : client.getNickname();
+        } else {
+            return overrideNick;
+        }
+    }
+
+    /**
+     * Get name to display for channelClient (Taking into account the channelmodeprefix setting).
+     *
+     * @param channelClient The client to get the display name for
+     *
+     * @return name to display
+     */
+    protected String getDisplayName(final ChannelClientInfo channelClient) {
+        return getDisplayName(channelClient, "");
+    }
+
+    /**
+     * Get name to display for channelClient (Taking into account the channelmodeprefix setting).
+     *
+     * @param channelClient The client to get the display name for
+     * @param overrideNick  Nickname to display instead of real nickname
+     *
+     * @return name to display
+     */
+    protected String getDisplayName(final ChannelClientInfo channelClient, final String overrideNick) {
+        if (channelClient == null) {
+            return (overrideNick.isEmpty()) ? "Unknown Client" : overrideNick;
+        } else if (overrideNick.isEmpty()) {
+            return channelmodeprefix ? channelClient.toString() : channelClient.getClient().
+                    getNickname();
+        } else {
+            return channelmodeprefix ? channelClient.getImportantModePrefix() + overrideNick
+                    : overrideNick;
+        }
+    }
+
+    /**
+     * Shows the history window for the specified target, if available.
+     *
+     * @param target The window whose history we're trying to open
+     *
+     * @return True if the history is available, false otherwise
+     */
+    protected boolean showHistory(final FrameContainer target) {
+        Object component;
+
+        if (target instanceof Channel) {
+            component = ((Channel) target).getChannelInfo();
+        } else if (target instanceof Query) {
+            final Parser parser = ((Query) target).getConnection().getParser();
+            component = parser.getClient(((Query) target).getHost());
+        } else if (target instanceof Connection) {
+            component = ((Connection) target).getParser();
+        } else {
+            // Unknown component
+            return false;
+        }
+
+        final String log = getLogFile(component);
+
+        if (!new File(log).exists()) {
+            // File doesn't exist
+            return false;
+        }
+
+        ReverseFileReader reader;
+
+        try {
+            reader = new ReverseFileReader(log);
+        } catch (IOException | SecurityException ex) {
+            return false;
+        }
+
+        final HistoryWindow window = new HistoryWindow("History", reader, target, urlBuilder,
+                historyLines);
+        windowManager.addWindow(target, window);
+
+        return true;
+    }
+
+    /** Updates cached settings. */
+    public void setCachedSettings() {
+        networkfolders = config.getOptionBool(domain, "general.networkfolders");
+        filenamehash = config.getOptionBool(domain, "advanced.filenamehash");
+        addtime = config.getOptionBool(domain, "general.addtime");
+        stripcodes = config.getOptionBool(domain, "general.stripcodes");
+        channelmodeprefix = config.getOptionBool(domain, "general.channelmodeprefix");
+        autobackbuffer = config.getOptionBool(domain, "backbuffer.autobackbuffer");
+        backbufferTimestamp = config.getOptionBool(domain, "backbuffer.timestamp");
+        usedate = config.getOptionBool(domain, "advanced.usedate");
+        timestamp = config.getOption(domain, "general.timestamp");
+        usedateformat = config.getOption(domain, "advanced.usedateformat");
+        historyLines = config.getOptionInt(domain, "history.lines");
+        colour = config.getOption(domain, "backbuffer.colour");
+        backbufferLines = config.getOptionInt(domain, "backbuffer.lines");
+    }
+
+    /** Open File. */
+    private static class OpenFile {
+
+        /** Last used time. */
+        public long lastUsedTime = System.currentTimeMillis();
+        /** Open file's writer. */
+        public final BufferedWriter writer;
+
+        /**
+         * Creates a new open file.
+         *
+         * @param writer Writer that has file open
+         */
+        protected OpenFile(final BufferedWriter writer) {
+            this.writer = writer;
+        }
+
+    }
+
+}

src/com/dmdirc/addons/logging/LoggingModule.java

@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) 2006-2014 DMDirc Developers
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package com.dmdirc.addons.logging;
+
+import com.dmdirc.ClientModule;
+import com.dmdirc.ClientModule.GlobalConfig;
+import com.dmdirc.ClientModule.UserConfig;
+import com.dmdirc.commandline.CommandLineOptionsModule.Directory;
+import com.dmdirc.commandline.CommandLineOptionsModule.DirectoryType;
+import com.dmdirc.interfaces.config.AggregateConfigProvider;
+import com.dmdirc.interfaces.config.ConfigProvider;
+
+import java.io.File;
+
+import javax.inject.Qualifier;
+
+import dagger.Module;
+import dagger.Provides;
+
+/**
+ * Dependency injection module for the logging plugin.
+ */
+@Module(addsTo = ClientModule.class, injects = {LoggingManager.class, LoggingCommand.class})
+public class LoggingModule {
+
+    @Qualifier
+    public @interface LoggingDomain {
+    }
+
+    public static final String LOGS_DIRECTORY = "logs";
+
+    private final String domain;
+
+    public LoggingModule(final String domain) {
+        this.domain = domain;
+    }
+
+    @Provides
+    @LoggingDomain
+    public String getDomain() {
+        return domain;
+    }
+
+    @Provides
+    @Directory(LOGS_DIRECTORY)
+    public String getLogsDirectory(
+            @UserConfig final ConfigProvider userConfig,
+            @GlobalConfig final AggregateConfigProvider globalConfig,
+            @Directory(DirectoryType.BASE) final String baseDirectory,
+            @LoggingDomain final String domain) {
+        if (!userConfig.hasOptionString(domain, "general.directory")) {
+            userConfig.setOption(domain, "general.directory",
+                    baseDirectory + "logs" + File.separator);
+        }
+
+        return globalConfig.getOptionString(domain, "general.directory");
+    }
+
+}

src/com/dmdirc/addons/logging/LoggingPlugin.java

@@ -22,237 +22,58 @@
 
 package com.dmdirc.addons.logging;
 
-import com.dmdirc.Channel;
-import com.dmdirc.FrameContainer;
-import com.dmdirc.Query;
-import com.dmdirc.actions.CoreActionType;
 import com.dmdirc.config.prefs.PluginPreferencesCategory;
 import com.dmdirc.config.prefs.PreferencesCategory;
 import com.dmdirc.config.prefs.PreferencesDialogModel;
 import com.dmdirc.config.prefs.PreferencesSetting;
 import com.dmdirc.config.prefs.PreferencesType;
-import com.dmdirc.interfaces.ActionController;
-import com.dmdirc.interfaces.ActionListener;
-import com.dmdirc.interfaces.CommandController;
-import com.dmdirc.interfaces.Connection;
-import com.dmdirc.interfaces.actions.ActionType;
-import com.dmdirc.interfaces.config.AggregateConfigProvider;
-import com.dmdirc.interfaces.config.ConfigChangeListener;
-import com.dmdirc.interfaces.config.ConfigProvider;
-import com.dmdirc.interfaces.config.IdentityController;
-import com.dmdirc.logger.ErrorLevel;
-import com.dmdirc.logger.Logger;
-import com.dmdirc.parser.interfaces.ChannelClientInfo;
-import com.dmdirc.parser.interfaces.ChannelInfo;
-import com.dmdirc.parser.interfaces.ClientInfo;
-import com.dmdirc.parser.interfaces.Parser;
 import com.dmdirc.plugins.PluginInfo;
 import com.dmdirc.plugins.implementations.BaseCommandPlugin;
-import com.dmdirc.ui.WindowManager;
-import com.dmdirc.ui.messages.Styliser;
-import com.dmdirc.util.URLBuilder;
-import com.dmdirc.util.io.ReverseFileReader;
-import com.dmdirc.util.io.StreamUtils;
 
-import java.awt.Color;
-import java.io.BufferedWriter;
-import java.io.File;
-import java.io.FileWriter;
-import java.io.IOException;
-import java.math.BigInteger;
-import java.security.MessageDigest;
-import java.security.NoSuchAlgorithmException;
-import java.text.DateFormat;
-import java.text.SimpleDateFormat;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.Date;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Stack;
-import java.util.Timer;
-import java.util.TimerTask;
+import dagger.ObjectGraph;
 
 /**
  * Adds logging facility to client.
  */
-public class LoggingPlugin extends BaseCommandPlugin implements ActionListener,
-        ConfigChangeListener {
+public class LoggingPlugin extends BaseCommandPlugin {
 
-    /** Cached boolean settings. */
-    private boolean networkfolders;
-    private boolean filenamehash;
-    private boolean addtime;
-    private boolean stripcodes;
-    private boolean channelmodeprefix;
-    private boolean autobackbuffer;
-    private boolean backbufferTimestamp;
-    private boolean usedate;
-    /** Cached string settings. */
-    private String timestamp;
-    private String usedateformat;
-    private String logDirectory;
-    private String colour;
-    /** Cached int settings. */
-    private int historyLines;
-    private int backbufferLines;
     /** This plugin's plugin info. */
     private final PluginInfo pluginInfo;
-    /** The action controller to use. */
-    private final ActionController actionController;
-    /** Global config. */
-    private final AggregateConfigProvider config;
-    /** Addon identity. */
-    private final ConfigProvider identity;
-    /** Parent Identity Manager. */
-    private final IdentityController identityController;
-    /** The manager to add history windows to. */
-    private final WindowManager windowManager;
-    /** Timer used to close idle files. */
-    protected Timer idleFileTimer;
-    /** Map of open files. */
-    protected final Map<String, OpenFile> openFiles = Collections.synchronizedMap(
-            new HashMap<String, OpenFile>());
-    /** Date format used for "File Opened At" log. */
-    final DateFormat openedAtFormat = new SimpleDateFormat("EEEE MMMM dd, yyyy - HH:mm:ss");
-    private final URLBuilder urlBuilder;
+
+    /** The manager in use. */
+    private LoggingManager manager;
 
     /**
      * Creates a new instance of this plugin.
      *
-     * @param pluginInfo         This plugin's plugin info
-     * @param actionController   The action controller to register listeners with
-     * @param identityController The Identity Manager that controls the current config
-     * @param commandController  Command controller to register commands
-     * @param windowManager      The manager to add history windows to.
-     * @param urlBuilder         The URL builder to use when finding icons.
+     * @param pluginInfo This plugin's plugin info
      */
-    public LoggingPlugin(final PluginInfo pluginInfo,
-            final ActionController actionController,
-            final IdentityController identityController,
-            final CommandController commandController,
-            final WindowManager windowManager,
-            final URLBuilder urlBuilder) {
-        super(commandController);
-        this.identityController = identityController;
-        this.windowManager = windowManager;
-        this.urlBuilder = urlBuilder;
-
+    public LoggingPlugin(final PluginInfo pluginInfo) {
         this.pluginInfo = pluginInfo;
-        this.actionController = actionController;
-        config = identityController.getGlobalConfiguration();
-        identity = identityController.getAddonSettings();
-
-        registerCommand(new LoggingCommand(commandController, this), LoggingCommand.INFO);
     }
 
-    /** {@inheritDoc} */
     @Override
-    public void domainUpdated() {
-        identity.setOption(pluginInfo.getDomain(), "general.directory",
-                identityController.getConfigurationDirectory() + "logs" + System.getProperty(
-                "file.separator"));
+    public void load(final PluginInfo pluginInfo, final ObjectGraph graph) {
+        super.load(pluginInfo, graph);
+
+        setObjectGraph(graph.plus(new LoggingModule(pluginInfo.getDomain())));
+        manager = getObjectGraph().get(LoggingManager.class);
+
+        registerCommand(LoggingCommand.class, LoggingCommand.INFO);
     }
 
-    /**
-     * Called when the plugin is loaded.
-     */
     @Override
     public void onLoad() {
-        setCachedSettings();
-
-        final File dir = new File(logDirectory);
-        if (dir.exists()) {
-            if (!dir.isDirectory()) {
-                Logger.userError(ErrorLevel.LOW,
-                        "Unable to create logging dir (file exists instead)");
-            }
-        } else {
-            if (!dir.mkdirs()) {
-                Logger.userError(ErrorLevel.LOW, "Unable to create logging dir");
-            }
-        }
-
-        config.addChangeListener(pluginInfo.getDomain(), this);
-
-        actionController.registerListener(this,
-                CoreActionType.CHANNEL_OPENED,
-                CoreActionType.CHANNEL_CLOSED,
-                CoreActionType.CHANNEL_MESSAGE,
-                CoreActionType.CHANNEL_SELF_MESSAGE,
-                CoreActionType.CHANNEL_ACTION,
-                CoreActionType.CHANNEL_SELF_ACTION,
-                CoreActionType.CHANNEL_GOTTOPIC,
-                CoreActionType.CHANNEL_TOPICCHANGE,
-                CoreActionType.CHANNEL_JOIN,
-                CoreActionType.CHANNEL_PART,
-                CoreActionType.CHANNEL_QUIT,
-                CoreActionType.CHANNEL_KICK,
-                CoreActionType.CHANNEL_NICKCHANGE,
-                CoreActionType.CHANNEL_MODECHANGE,
-                CoreActionType.QUERY_OPENED,
-                CoreActionType.QUERY_CLOSED,
-                CoreActionType.QUERY_MESSAGE,
-                CoreActionType.QUERY_SELF_MESSAGE,
-                CoreActionType.QUERY_ACTION,
-                CoreActionType.QUERY_SELF_ACTION);
-
-        // Close idle files every hour.
-        idleFileTimer = new Timer("LoggingPlugin Timer");
-        idleFileTimer.schedule(new TimerTask() {
-            /** {@inheritDoc} */
-            @Override
-            public void run() {
-                timerTask();
-            }
-        }, 3600000);
         super.onLoad();
+        manager.load();
     }
 
-    /**
-     * What to do every hour when the timer fires.
-     */
-    protected void timerTask() {
-        // Oldest time to allow
-        final long oldestTime = System.currentTimeMillis() - 3480000;
-
-        synchronized (openFiles) {
-            final Collection<String> old = new ArrayList<>(openFiles.size());
-            for (Map.Entry<String, OpenFile> entry : openFiles.entrySet()) {
-                if (entry.getValue().lastUsedTime < oldestTime) {
-                    StreamUtils.close(entry.getValue().writer);
-                    old.add(entry.getKey());
-                }
-            }
-
-            openFiles.keySet().removeAll(old);
-        }
-    }
-
-    /**
-     * Called when this plugin is unloaded.
-     */
     @Override
     public void onUnload() {
-        if (idleFileTimer != null) {
-            idleFileTimer.cancel();
-            idleFileTimer.purge();
-        }
-
-        actionController.unregisterListener(this);
-
-        synchronized (openFiles) {
-            for (OpenFile file : openFiles.values()) {
-                StreamUtils.close(file.writer);
-            }
-            openFiles.clear();
-        }
-
         super.onUnload();
+        manager.unload();
     }
 
-    /** {@inheritDoc} */
     @Override
     public void showConfig(final PreferencesDialogModel manager) {
         final PreferencesCategory general = new PluginPreferencesCategory(
@@ -329,645 +150,4 @@ public class LoggingPlugin extends BaseCommandPlugin implements ActionListener,
         manager.getCategory("Plugins").addSubCategory(general.setInlineAfter());
     }
 
-    /**
-     * Log a query-related event.
-     *
-     * @param type      The type of the event to process
-     * @param format    Format of messages that are about to be sent. (May be null)
-     * @param arguments The arguments for the event
-     */
-    protected void handleQueryEvent(final CoreActionType type, final StringBuffer format,
-            final Object... arguments) {
-        final Query query = (Query) arguments[0];
-        if (query.getConnection() == null) {
-            Logger.appError(ErrorLevel.MEDIUM, "Query object has no server (" + type.toString()
-                    + ")", new Exception("Query object has no server (" + type.toString() + ")"));
-            return;
-        }
-
-        final Parser parser = query.getConnection().getParser();
-        ClientInfo client;
-
-        if (parser == null) {
-            // Without a parser object, we might not be able to find the file to log this to.
-            if (networkfolders) {
-                // We *wont* be able to, so rather than logging to an incorrect file we just won't log.
-                return;
-            }
-            client = null;
-        } else {
-            client = parser.getClient(query.getHost());
-        }
-
-        final String filename = getLogFile(client);
-
-        switch (type) {
-            case QUERY_OPENED:
-                if (autobackbuffer) {
-                    showBackBuffer(query, filename);
-                }
-
-                appendLine(filename, "*** Query opened at: %s", openedAtFormat.format(new Date()));
-                appendLine(filename, "*** Query with User: %s", query.getHost());
-                appendLine(filename, "");
-                break;
-            case QUERY_CLOSED:
-                appendLine(filename, "*** Query closed at: %s", openedAtFormat.format(new Date()));
-                if (openFiles.containsKey(filename)) {
-                    StreamUtils.close(openFiles.get(filename).writer);
-                    openFiles.remove(filename);
-                }
-                break;
-            case QUERY_MESSAGE:
-            case QUERY_SELF_MESSAGE:
-            case QUERY_ACTION:
-            case QUERY_SELF_ACTION:
-                final boolean isME = (type == CoreActionType.QUERY_SELF_MESSAGE || type
-                        == CoreActionType.QUERY_SELF_ACTION);
-                final String overrideNick = isME ? getDisplayName(parser.getLocalClient()) : "";
-
-                if (type == CoreActionType.QUERY_MESSAGE || type
-                        == CoreActionType.QUERY_SELF_MESSAGE) {
-                    appendLine(filename, "<%s> %s", getDisplayName(client, overrideNick),
-                            arguments[2]);
-                } else {
-                    appendLine(filename, "* %s %s", getDisplayName(client, overrideNick),
-                            arguments[2]);
-                }
-                break;
-        }
-    }
-
-    /**
-     * Log a channel-related event.
-     *
-     * @param type      The type of the event to process
-     * @param format    Format of messages that are about to be sent. (May be null)
-     * @param arguments The arguments for the event
-     */
-    protected void handleChannelEvent(final CoreActionType type, final StringBuffer format,
-            final Object... arguments) {
-        final Channel chan = ((Channel) arguments[0]);
-        final ChannelInfo channel = chan.getChannelInfo();
-        final String filename = getLogFile(channel);
-
-        final ChannelClientInfo channelClient = (arguments.length > 1
-                && arguments[1] instanceof ChannelClientInfo) ? (ChannelClientInfo) arguments[1]
-                : null;
-        final ClientInfo client = channelClient == null ? null : channelClient.getClient();
-
-        final String message = (arguments.length > 2 && arguments[2] instanceof String)
-                ? (String) arguments[2] : null;
-
-        switch (type) {
-            case CHANNEL_OPENED:
-                if (autobackbuffer) {
-                    showBackBuffer(chan, filename);
-                }
-
-                appendLine(filename, "*** Channel opened at: %s", openedAtFormat.format(new Date()));
-                appendLine(filename, "");
-                break;
-            case CHANNEL_CLOSED:
-                appendLine(filename, "*** Channel closed at: %s", openedAtFormat.format(new Date()));
-                if (openFiles.containsKey(filename)) {
-                    StreamUtils.close(openFiles.get(filename).writer);
-                    openFiles.remove(filename);
-                }
-                break;
-            case CHANNEL_MESSAGE:
-            case CHANNEL_SELF_MESSAGE:
-            case CHANNEL_ACTION:
-            case CHANNEL_SELF_ACTION:
-                if (type == CoreActionType.CHANNEL_MESSAGE || type
-                        == CoreActionType.CHANNEL_SELF_MESSAGE) {
-                    appendLine(filename, "<%s> %s", getDisplayName(client), message);
-                } else {
-                    appendLine(filename, "* %s %s", getDisplayName(client), message);
-                }
-                break;
-            case CHANNEL_GOTTOPIC:
-                // ActionManager.processEvent(CoreActionType.CHANNEL_GOTTOPIC, this);
-                final DateFormat timeFormat = new SimpleDateFormat("HH:mm:ss");
-                final DateFormat dateFormat = new SimpleDateFormat("dd/MM/yyyy");
-
-                appendLine(filename, "*** Topic is: %s", channel.getTopic());
-                appendLine(filename, "*** Set at: %s on %s by %s", timeFormat.format(1000 * channel.
-                        getTopicTime()), dateFormat.format(1000 * channel.getTopicTime()), channel.
-                        getTopicSetter());
-                break;
-            case CHANNEL_TOPICCHANGE:
-                appendLine(filename, "*** %s Changed the topic to: %s",
-                        getDisplayName(channelClient), message);
-                break;
-            case CHANNEL_JOIN:
-                appendLine(filename, "*** %s (%s) joined the channel", getDisplayName(channelClient),
-                        client.toString());
-                break;
-            case CHANNEL_PART:
-                if (message.isEmpty()) {
-                    appendLine(filename, "*** %s (%s) left the channel", getDisplayName(
-                            channelClient), client.toString());
-                } else {
-                    appendLine(filename, "*** %s (%s) left the channel (%s)", getDisplayName(
-                            channelClient), client.toString(), message);
-                }
-                break;
-            case CHANNEL_QUIT:
-                if (message.isEmpty()) {
-                    appendLine(filename, "*** %s (%s) Quit IRC", getDisplayName(channelClient),
-                            client.toString());
-                } else {
-                    appendLine(filename, "*** %s (%s) Quit IRC (%s)", getDisplayName(channelClient),
-                            client.toString(), message);
-                }
-                break;
-            case CHANNEL_KICK:
-                final String kickReason = (String) arguments[3];
-                final ChannelClientInfo kickedClient = (ChannelClientInfo) arguments[2];
-
-                if (kickReason.isEmpty()) {
-                    appendLine(filename, "*** %s was kicked by %s", getDisplayName(kickedClient),
-                            getDisplayName(channelClient));
-                } else {
-                    appendLine(filename, "*** %s was kicked by %s (%s)",
-                            getDisplayName(kickedClient), getDisplayName(channelClient), kickReason);
-                }
-                break;
-            case CHANNEL_NICKCHANGE:
-                appendLine(filename, "*** %s is now %s", getDisplayName(channelClient, message),
-                        getDisplayName(channelClient));
-                break;
-            case CHANNEL_MODECHANGE:
-                if (channelClient.getClient().getNickname().isEmpty()) {
-                    appendLine(filename, "*** Channel modes are: %s", message);
-                } else {
-                    appendLine(filename, "*** %s set modes: %s", getDisplayName(channelClient),
-                            message);
-                }
-                break;
-        }
-    }
-
-    /**
-     * Process an event of the specified type.
-     *
-     * @param type      The type of the event to process
-     * @param format    Format of messages that are about to be sent. (May be null)
-     * @param arguments The arguments for the event
-     */
-    @Override
-    public void processEvent(final ActionType type, final StringBuffer format,
-            final Object... arguments) {
-        if (type instanceof CoreActionType) {
-            final CoreActionType thisType = (CoreActionType) type;
-
-            switch (thisType) {
-                case CHANNEL_OPENED:
-                case CHANNEL_CLOSED:
-                case CHANNEL_MESSAGE:
-                case CHANNEL_SELF_MESSAGE:
-                case CHANNEL_ACTION:
-                case CHANNEL_SELF_ACTION:
-                case CHANNEL_GOTTOPIC:
-                case CHANNEL_TOPICCHANGE:
-                case CHANNEL_JOIN:
-                case CHANNEL_PART:
-                case CHANNEL_QUIT:
-                case CHANNEL_KICK:
-                case CHANNEL_NICKCHANGE:
-                case CHANNEL_MODECHANGE:
-                    handleChannelEvent(thisType, format, arguments);
-                    break;
-                case QUERY_OPENED:
-                case QUERY_CLOSED:
-                case QUERY_MESSAGE:
-                case QUERY_SELF_MESSAGE:
-                case QUERY_ACTION:
-                case QUERY_SELF_ACTION:
-                    handleQueryEvent(thisType, format, arguments);
-                    break;
-                default:
-                    break;
-            }
-        }
-    }
-
-    /** {@inheritDoc} */
-    @Override
-    public void configChanged(final String domain, final String key) {
-        setCachedSettings();
-    }
-
-    /**
-     * Add a backbuffer to a frame.
-     *
-     * @param frame    The frame to add the backbuffer lines to
-     * @param filename File to get backbuffer from
-     */
-    protected void showBackBuffer(final FrameContainer frame, final String filename) {
-        if (frame == null) {
-            Logger.userError(ErrorLevel.LOW, "Given a null frame");
-            return;
-        }
-
-        final File testFile = new File(filename);
-        if (testFile.exists()) {
-            try {
-                final ReverseFileReader file = new ReverseFileReader(testFile);
-                // Because the file includes a newline char at the end, an empty line
-                // is returned by getLines. To counter this, we call getLines(1) and do
-                // nothing with the output.
-                file.getLines(1);
-                final Stack<String> lines = file.getLines(backbufferLines);
-                while (!lines.empty()) {
-                    frame.addLine(getColouredString(colour, lines.pop()), backbufferTimestamp);
-                }
-                file.close();
-                frame.addLine(getColouredString(colour, "--- End of backbuffer\n"),
-                        backbufferTimestamp);
-            } catch (IOException | SecurityException e) {
-                Logger.userError(ErrorLevel.LOW, "Unable to show backbuffer (Filename: " + filename
-                        + "): " + e.getMessage());
-            }
-        }
-    }
-
-    /**
-     * Get a coloured String. If colour is invalid, IRC Colour 14 will be used.
-     *
-     * @param colour The colour the string should be (IRC Colour or 6-digit hex colour)
-     * @param line   the line to colour
-     *
-     * @return The given line with the appropriate irc codes appended/prepended to colour it.
-     */
-    protected static String getColouredString(final String colour, final String line) {
-        String res = null;
-        if (colour.length() < 3) {
-            int num;
-
-            try {
-                num = Integer.parseInt(colour);
-            } catch (NumberFormatException ex) {
-                num = -1;
-            }
-
-            if (num >= 0 && num <= 15) {
-                res = String.format("%c%02d%s%1$c", Styliser.CODE_COLOUR, num, line);
-            }
-        } else if (colour.length() == 6) {
-            try {
-                Color.decode("#" + colour);
-                res = String.format("%c%s%s%1$c", Styliser.CODE_HEXCOLOUR, colour, line);
-            } catch (NumberFormatException ex) { /* Do Nothing */ }
-        }
-
-        if (res == null) {
-            res = String.format("%c%02d%s%1$c", Styliser.CODE_COLOUR, 14, line);
-        }
-        return res;
-    }
-
-    /**
-     * Add a line to a file.
-     *
-     * @param filename Name of file to write to
-     * @param format   Format of line to add. (NewLine will be added Automatically)
-     * @param args     Arguments for format
-     *
-     * @return true on success, else false.
-     */
-    protected boolean appendLine(final String filename, final String format, final Object... args) {
-        return appendLine(filename, String.format(format, args));
-    }
-
-    /**
-     * Add a line to a file.
-     *
-     * @param filename Name of file to write to
-     * @param line     Line to add. (NewLine will be added Automatically)
-     *
-     * @return true on success, else false.
-     */
-    protected boolean appendLine(final String filename, final String line) {
-        final StringBuffer finalLine = new StringBuffer();
-
-        if (addtime) {
-            String dateString;
-            try {
-                final DateFormat dateFormat = new SimpleDateFormat(timestamp);
-                dateString = dateFormat.format(new Date()).trim();
-            } catch (IllegalArgumentException iae) {
-                // Default to known good format
-                final DateFormat dateFormat = new SimpleDateFormat("[dd/MM/yyyy HH:mm:ss]");
-                dateString = dateFormat.format(new Date()).trim();
-
-                Logger.userError(ErrorLevel.LOW, "Dateformat String '" + timestamp
-                        + "' is invalid. For more information: http://java.sun.com/javase/6/docs/api/java/text/SimpleDateFormat.html");
-            }
-            finalLine.append(dateString);
-            finalLine.append(' ');
-        }
-
-        if (stripcodes) {
-            finalLine.append(Styliser.stipControlCodes(line));
-        } else {
-            finalLine.append(line);
-        }
-
-        BufferedWriter out;
-        try {
-            if (openFiles.containsKey(filename)) {
-                final OpenFile of = openFiles.get(filename);
-                of.lastUsedTime = System.currentTimeMillis();
-                out = of.writer;
-            } else {
-                out = new BufferedWriter(new FileWriter(filename, true));
-                openFiles.put(filename, new OpenFile(out));
-            }
-            out.write(finalLine.toString());
-            out.newLine();
-            out.flush();
-            return true;
-        } catch (IOException e) {
-            /*
-             * Do Nothing
-             *
-             * Makes no sense to keep adding errors to the logger when we can't write to the file,
-             * as chances are it will happen on every incomming line.
-             */
-        }
-        return false;
-    }
-
-    /**
-     * Get the name of the log file for a specific object.
-     *
-     * @param obj Object to get name for
-     *
-     * @return the name of the log file to use for this object.
-     */
-    protected String getLogFile(final Object obj) {
-        final StringBuffer directory = new StringBuffer();
-        final StringBuffer file = new StringBuffer();
-        String md5String = "";
-
-        directory.append(logDirectory);
-        if (directory.charAt(directory.length() - 1) != File.separatorChar) {
-            directory.append(File.separatorChar);
-        }
-
-        if (obj == null) {
-            file.append("null.log");
-        } else if (obj instanceof ChannelInfo) {
-            final ChannelInfo channel = (ChannelInfo) obj;
-            if (channel.getParser() != null) {
-                addNetworkDir(directory, file, channel.getParser().getNetworkName());
-            }
-            file.append(sanitise(channel.getName().toLowerCase()));
-            md5String = channel.getName();
-        } else if (obj instanceof ClientInfo) {
-            final ClientInfo client = (ClientInfo) obj;
-            if (client.getParser() != null) {
-                addNetworkDir(directory, file, client.getParser().getNetworkName());
-            }
-            file.append(sanitise(client.getNickname().toLowerCase()));
-            md5String = client.getNickname();
-        } else {
-            file.append(sanitise(obj.toString().toLowerCase()));
-            md5String = obj.toString();
-        }
-
-        if (usedate) {
-            final String dateFormat = usedateformat;
-            final String dateDir = new SimpleDateFormat(dateFormat).format(new Date());
-            directory.append(dateDir);
-            if (directory.charAt(directory.length() - 1) != File.separatorChar) {
-                directory.append(File.separatorChar);
-            }
-
-            if (!new File(directory.toString()).exists() && !(new File(directory.toString())).
-                    mkdirs()) {
-                Logger.userError(ErrorLevel.LOW, "Unable to create date dirs");
-            }
-        }
-
-        if (filenamehash) {
-            file.append('.');
-            file.append(md5(md5String));
-        }
-        file.append(".log");
-
-        return directory.toString() + file.toString();
-    }
-
-    /**
-     * This function adds the networkName to the log file. It first tries to create a directory for
-     * each network, if that fails it will prepend the networkName to the filename instead.
-     *
-     * @param directory   Current directory name
-     * @param file        Current file name
-     * @param networkName Name of network
-     */
-    protected void addNetworkDir(final StringBuffer directory, final StringBuffer file,
-            final String networkName) {
-        if (!networkfolders) {
-            return;
-        }
-
-        final String network = sanitise(networkName.toLowerCase());
-
-        boolean prependNetwork = false;
-
-        // Check dir exists
-        final File dir = new File(directory.toString() + network + System.getProperty(
-                "file.separator"));
-        if (dir.exists() && !dir.isDirectory()) {
-            Logger.userError(ErrorLevel.LOW,
-                    "Unable to create networkfolders dir (file exists instead)");
-            // Prepend network name to file instead.
-            prependNetwork = true;
-        } else if (!dir.exists() && !dir.mkdirs()) {
-            Logger.userError(ErrorLevel.LOW, "Unable to create networkfolders dir");
-            prependNetwork = true;
-        }
-
-        if (prependNetwork) {
-            file.insert(0, " -- ");
-            file.insert(0, network);
-        } else {
-            directory.append(network);
-            directory.append(System.getProperty("file.separator"));
-        }
-    }
-
-    /**
-     * Sanitise a string to be used as a filename.
-     *
-     * @param name String to sanitise
-     *
-     * @return Sanitised version of name that can be used as a filename.
-     */
-    protected static String sanitise(final String name) {
-        // Replace illegal chars with
-        return name.replaceAll("[^\\w\\.\\s\\-\\#\\&\\_]", "_");
-    }
-
-    /**
-     * Get the md5 hash of a string.
-     *
-     * @param string String to hash
-     *
-     * @return md5 hash of given string
-     */
-    protected static String md5(final String string) {
-        try {
-            final MessageDigest m = MessageDigest.getInstance("MD5");
-            m.update(string.getBytes(), 0, string.length());
-            return new BigInteger(1, m.digest()).toString(16);
-        } catch (NoSuchAlgorithmException e) {
-            return "";
-        }
-    }
-
-    /**
-     * Get name to display for client.
-     *
-     * @param client The client to get the display name for
-     *
-     * @return name to display
-     */
-    protected String getDisplayName(final ClientInfo client) {
-        return getDisplayName(client, "");
-    }
-
-    /**
-     * Get name to display for client.
-     *
-     * @param client       The client to get the display name for
-     * @param overrideNick Nickname to display instead of real nickname
-     *
-     * @return name to display
-     */
-    protected String getDisplayName(final ClientInfo client, final String overrideNick) {
-        if (overrideNick.isEmpty()) {
-            return (client == null) ? "Unknown Client" : client.getNickname();
-        } else {
-            return overrideNick;
-        }
-    }
-
-    /**
-     * Get name to display for channelClient (Taking into account the channelmodeprefix setting).
-     *
-     * @param channelClient The client to get the display name for
-     *
-     * @return name to display
-     */
-    protected String getDisplayName(final ChannelClientInfo channelClient) {
-        return getDisplayName(channelClient, "");
-    }
-
-    /**
-     * Get name to display for channelClient (Taking into account the channelmodeprefix setting).
-     *
-     * @param channelClient The client to get the display name for
-     * @param overrideNick  Nickname to display instead of real nickname
-     *
-     * @return name to display
-     */
-    protected String getDisplayName(final ChannelClientInfo channelClient, final String overrideNick) {
-        if (channelClient == null) {
-            return (overrideNick.isEmpty()) ? "Unknown Client" : overrideNick;
-        } else if (overrideNick.isEmpty()) {
-            return channelmodeprefix ? channelClient.toString() : channelClient.getClient().
-                    getNickname();
-        } else {
-            return channelmodeprefix ? channelClient.getImportantModePrefix() + overrideNick
-                    : overrideNick;
-        }
-    }
-
-    /**
-     * Shows the history window for the specified target, if available.
-     *
-     * @param target The window whose history we're trying to open
-     *
-     * @return True if the history is available, false otherwise
-     */
-    protected boolean showHistory(final FrameContainer target) {
-        Object component;
-
-        if (target instanceof Channel) {
-            component = ((Channel) target).getChannelInfo();
-        } else if (target instanceof Query) {
-            final Parser parser = ((Query) target).getConnection().getParser();
-            component = parser.getClient(((Query) target).getHost());
-        } else if (target instanceof Connection) {
-            component = ((Connection) target).getParser();
-        } else {
-            // Unknown component
-            return false;
-        }
-
-        final String log = getLogFile(component);
-
-        if (!new File(log).exists()) {
-            // File doesn't exist
-            return false;
-        }
-
-        ReverseFileReader reader;
-
-        try {
-            reader = new ReverseFileReader(log);
-        } catch (IOException | SecurityException ex) {
-            return false;
-        }
-
-        final HistoryWindow window = new HistoryWindow("History", reader, target, urlBuilder,
-                historyLines);
-        windowManager.addWindow(target, window);
-
-        return true;
-    }
-
-    /** Updates cached settings. */
-    public void setCachedSettings() {
-        networkfolders = config.getOptionBool(pluginInfo.getDomain(), "general.networkfolders");
-        filenamehash = config.getOptionBool(pluginInfo.getDomain(), "advanced.filenamehash");
-        addtime = config.getOptionBool(pluginInfo.getDomain(), "general.addtime");
-        stripcodes = config.getOptionBool(pluginInfo.getDomain(), "general.stripcodes");
-        channelmodeprefix = config.getOptionBool(pluginInfo.getDomain(),
-                "general.channelmodeprefix");
-        autobackbuffer = config.getOptionBool(pluginInfo.getDomain(), "backbuffer.autobackbuffer");
-        backbufferTimestamp = config.getOptionBool(pluginInfo.getDomain(), "backbuffer.timestamp");
-        usedate = config.getOptionBool(pluginInfo.getDomain(), "advanced.usedate");
-        timestamp = config.getOption(pluginInfo.getDomain(), "general.timestamp");
-        usedateformat = config.getOption(pluginInfo.getDomain(), "advanced.usedateformat");
-        historyLines = config.getOptionInt(pluginInfo.getDomain(), "history.lines");
-        colour = config.getOption(pluginInfo.getDomain(), "backbuffer.colour");
-        backbufferLines = config.getOptionInt(pluginInfo.getDomain(), "backbuffer.lines");
-        logDirectory = config.getOption(pluginInfo.getDomain(), "general.directory");
-    }
-
-    /** Open File. */
-    protected static class OpenFile {
-
-        /** Last used time. */
-        public long lastUsedTime = System.currentTimeMillis();
-        /** Open file's writer. */
-        public BufferedWriter writer = null;
-
-        /**
-         * Creates a new open file.
-         *
-         * @param writer Writer that has file open
-         */
-        protected OpenFile(final BufferedWriter writer) {
-            this.writer = writer;
-        }
-
-    }
-
 }