/* TagDifference.java created 2007-11-13
 *
 */

package org.signalml.domain.tag;

import org.signalml.plugin.export.signal.SignalSelection;
import org.signalml.plugin.export.signal.SignalSelectionType;
import org.signalml.plugin.export.signal.Tag;
import org.signalml.plugin.export.signal.TagStyle;

/**
 * This class represents the difference between two {@link Tag tags} from
 * different sets.
 * Difference is actually a selection representing that on this interval
 * in one set tag exists
 * (for the given {@link TagStyle style}, type and channel) and in
 * the other not.
 *
 * @author Michal Dobaczewski © 2007-2008 CC Otwarte Systemy Komputerowe Sp. z o.o.
 */
public class TagDifference extends SignalSelection implements Comparable<TagDifference> {

	private static final long serialVersionUID = 1L;

	/**
	 * the {@link TagDifferenceType type} of the difference
	 */
	private TagDifferenceType differenceType;

	/**
	 * Constructor. Creates the difference.
	 * @param type the {@link SignalSelectionType type} of a
	 * {@link SignalSelection signal} selection which this difference
	 * concerns
	 * @param position the position when difference begins
	 * @param length the length of the difference
	 * @param channel the index of the channel
	 * @param differenceType the {@link TagDifferenceType type} of
	 * this difference
	 */
	public TagDifference(SignalSelectionType type, double position, double length, int channel, TagDifferenceType differenceType) {
		super(type, position, length, channel);
		this.differenceType = differenceType;
	}

	/**
	 * Constructor. Creates the difference.
	 * @param type the {@link SignalSelectionType type} of a
	 * {@link SignalSelection signal} selection which this difference
	 * concerns
	 * @param d the position when difference begins
	 * @param maxValue the length of the difference
	 * @param differenceType the {@link TagDifferenceType type} of
	 * this difference
	 */
	public TagDifference(SignalSelectionType type, double d, double maxValue, TagDifferenceType differenceType) {
		super(type, d, maxValue);
		this.differenceType = differenceType;
	}

	/**
	 * Returns the {@link SignalSelectionType type} of this difference.
	 * @return the type of this difference.
	 */
	public TagDifferenceType getDifferenceType() {
		return differenceType;
	}

	/**
	 * Compares this difference to another difference.
	 * Parameters used (in this order): starting position, length,
	 * number of a channel, type of selection, type of a difference
	 * @param t the difference to be compared to this reference
	 * @return grater then 0 if this difference is larger,
	 * less then 0 if this reference is smaller,
	 * 0 if references are equal
	 */
	@Override
	public int compareTo(TagDifference t) {

		double test = position - t.position;
		if (test == 0) {
			test = length - t.length;
			if (test == 0) {
				test = channel - t.channel;
				if (((int) test) == 0) {
					int itest = type.ordinal() - t.type.ordinal();
					if (itest == 0) {
						return differenceType.ordinal() - t.differenceType.ordinal();
					}
				}
			}
		}
		return (int) Math.signum(test);

	}

	/**
	 * Checks if this reference object is equal to given.
	 * Uses {@link #compareTo}.
	 * @param obj the object to be compared with this reference
	 * @return true if the given object is equal to this reference,
	 * false otherwise
	 */
	@Override
	public boolean equals(Object obj) {
		if (obj == null || !(obj instanceof TagDifference)) {
			return false;
		}
		return (this.compareTo((TagDifference) obj) == 0);
	}

}