DefaultMessage

package com.github.triceo.splitlog;

import it.unimi.dsi.fastutil.longs.AbstractLongComparator;
import it.unimi.dsi.fastutil.longs.LongComparator;

import java.lang.ref.WeakReference;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Date;
import java.util.List;

import com.github.triceo.splitlog.api.CommonFollower;
import com.github.triceo.splitlog.api.ExceptionDescriptor;
import com.github.triceo.splitlog.api.Message;
import com.github.triceo.splitlog.api.MessageSeverity;
import com.github.triceo.splitlog.api.MessageType;
import com.github.triceo.splitlog.api.TailSplitter;
import com.github.triceo.splitlog.splitters.SimpleTailSplitter;

final class DefaultMessage implements Message {

    private static final LongComparator COMPARATOR = new AbstractLongComparator() {

        @Override
        public int compare(final long k1, final long k2) {
            if (k1 < k2) {
                return -1;
            } else if (k1 == k2) {
                return 0;
            } else {
                return 1;
            }
        }

    };
    private static final TailSplitter DEFAULT_SPLITTER = new SimpleTailSplitter();

    private final ExceptionDescriptor exceptionDescriptor;
    private final List<String> lines;
    private final String logger;
    private final long millisecondsSinceJanuary1st1970;
    private final WeakReference<Message> previousMessage;
    private final MessageSeverity severity;
    private final TailSplitter splitter;
    private final MessageType type;

    private final long uniqueId;

    /**
     * Will call {@link #DefaultMessage(long, Collection, TailSplitter)} with
     * {@link #DEFAULT_SPLITTER}.
     *
     * @param id
     *            Unique ID for the message. No other instance may have this ID,
     *            or else they will be considered equal.
     * @param raw
     *            DefaultMessage lines, expected without any pre-processing.
     */
    protected DefaultMessage(final long id, final Collection<String> raw) {
        this(id, raw, DefaultMessage.DEFAULT_SPLITTER);
    }

    /**
     * Form a new message and infer its metadata using a given splitter.
     *
     * @param id
     *            Unique ID for the message. No other instance may have this ID,
     *            or else they will be considered equal.
     * @param raw
     *            DefaultMessage lines, expected without any pre-processing.
     * @param timestamp
     *            In milliseconds since January 1st 1970. Will be overriden if
     *            {@link TailSplitter} can decode the timestamp from the log.
     * @param splitter
     *            Used to extract metadata out of the raw lines.
     * @param previousMessage
     *            DefaultMessage that preceded this one in the log file. Should
     *            not include tags from {@link CommonFollower}.
     */
    protected DefaultMessage(final long id, final Collection<String> raw, final long timestamp,
        final TailSplitter splitter, final Message previousMessage) {
        if ((raw == null) || raw.isEmpty()) {
            throw new IllegalArgumentException("DefaultMessage must not be null.");
        } else if (splitter == null) {
            throw new IllegalArgumentException("DefaultMessage requires a TailSplitter.");
        }
        if (previousMessage == null) {
            this.previousMessage = null;
        } else {
            this.previousMessage = new WeakReference<Message>(previousMessage);
        }
        this.uniqueId = id;
        this.splitter = splitter;
        this.lines = Collections.unmodifiableList(new ArrayList<String>(raw));
        final String logger = splitter.determineLogger(this.lines);
        this.logger = (logger == null) ? "" : logger;
        this.severity = splitter.determineSeverity(this.lines);
        this.type = splitter.determineType(this.lines);
        this.exceptionDescriptor = splitter.determineException(this.lines);
        // determine message timestamp
        final Date d = splitter.determineDate(this.lines);
        if (d == null) {
            this.millisecondsSinceJanuary1st1970 = timestamp;
        } else {
            this.millisecondsSinceJanuary1st1970 = d.getTime();
        }
    }

    /**
     * Will call
     * {@link #DefaultMessage(long, Collection, long, TailSplitter, DefaultMessage)}
     * with current time and no previous message.
     *
     * @param id
     *            Unique ID for the message. No other instance may have this ID,
     *            or else they will be considered equal.
     * @param raw
     *            DefaultMessage lines, expected without any pre-processing.
     * @param splitter
     *            Used to extract metadata out of the raw lines.
     */
    protected DefaultMessage(final long id, final Collection<String> raw, final TailSplitter splitter) {
        this(id, raw, System.currentTimeMillis(), splitter, null);
    }

    /**
     * Creates a one-line message of type {@link MessageType#TAG}. The message
     * will point to no previous message.
     *
     * @param id
     *            Unique ID for the message. No other instance may have this ID,
     *            or else they will be considered equal.
     * @param message
     *            The only line in the message.
     */
    protected DefaultMessage(final long id, final String message) {
        if ((message == null) || (message.length() == 0)) {
            throw new IllegalArgumentException("DefaultMessage must not be empty.");
        }
        this.logger = "";
        this.uniqueId = id;
        this.previousMessage = null;
        this.splitter = null;
        this.lines = Collections.singletonList(message.trim());
        this.severity = MessageSeverity.UNKNOWN;
        this.type = MessageType.TAG;
        this.millisecondsSinceJanuary1st1970 = System.currentTimeMillis();
        this.exceptionDescriptor = null;
    }

    @Override
    public int compareTo(final Message o) {
        return DefaultMessage.COMPARATOR.compare(this.getUniqueId(), o.getUniqueId());
    }

    @Override
    public boolean equals(final Object obj) {
        if (this == obj) {
            return true;
        }
        if (obj == null) {
            return false;
        }
        if (this.getClass() != obj.getClass()) {
            return false;
        }
        final DefaultMessage other = (DefaultMessage) obj;
        if (this.uniqueId != other.uniqueId) {
            return false;
        }
        return true;
    }

    @Override
    public Date getDate() {
        return new Date(this.millisecondsSinceJanuary1st1970);
    }

    @Override
    public ExceptionDescriptor getExceptionDescriptor() {
        return this.exceptionDescriptor;
    }

    @Override
    public List<String> getLines() {
        return this.lines;
    }

    @Override
    public List<String> getLinesWithoutMetadata() {
        if (this.type == MessageType.TAG) {
            // nothing to split for tags
            return this.lines;
        }
        final List<String> stripped = new ArrayList<String>();
        for (final String line : this.lines) {
            stripped.add(this.splitter.stripOfMetadata(line));
        }
        return Collections.unmodifiableList(stripped);
    }

    @Override
    public String getLogger() {
        return this.logger;
    }

    @Override
    public Message getPreviousMessage() {
        if (this.previousMessage == null) {
            return null;
        }
        return this.previousMessage.get();
    }

    @Override
    public MessageSeverity getSeverity() {
        return this.severity;
    }

    @Override
    public MessageType getType() {
        return this.type;
    }

    @Override
    public long getUniqueId() {
        return this.uniqueId;
    }

    @Override
    public boolean hasException() {
        return this.exceptionDescriptor != null;
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = (prime * result) + (int) (this.uniqueId ^ (this.uniqueId >>> 32));
        return result;
    }

    @Override
    public String toString() {
        final StringBuilder sb = new StringBuilder();
        sb.append('#');
        sb.append(this.getUniqueId());
        sb.append(" ");
        sb.append(" [");
        sb.append(this.logger);
        sb.append("] ");
        sb.append(this.getDate());
        sb.append(" (");
        sb.append(this.type);
        sb.append(") ");
        sb.append(this.severity);
        sb.append(" '");
        sb.append(this.lines.get(0));
        sb.append("'");
        if (this.lines.size() > 1) {
            sb.append(" and ");
            sb.append(this.lines.size() - 1);
            sb.append(" more lines...");
        }
        return sb.toString();
    }

}