/*******************************************************************************
 * Copyright (c) 2007 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 ******************************************************************************/

package org.eclipse.ui.internal.provisional.views.markers;

import java.util.Comparator;
import java.util.HashSet;
import java.util.Iterator;

import org.eclipse.ui.IMemento;
import org.eclipse.ui.internal.provisional.views.markers.api.MarkerField;
import org.eclipse.ui.internal.provisional.views.markers.api.MarkerItem;

/**
 * The MarkerComparator is the class that handles the comparison of markers for
 * a specific content provider.
 * 
 * @since 3.4
 * 
 */
class MarkerComparator implements Comparator {

	private MarkerField category;
	
	//These fields are in sort order
	private MarkerField[] fields;
	/**
	 * Constant to indicate an ascending sort direction.
	 */
	public static final int ASCENDING = 1;
	/**
	 * Constant to indicate an descending sort direction.
	 */
	public static final int DESCENDING = -1;
	private static final String PRIMARY_SORT_FIELD_TAG = "PRIMARY_SORT_FIELD"; //$NON-NLS-1$

	private static final String DESCENDING_FIELDS = "DESCENDING_FIELDS"; //$NON-NLS-1$

	// The fields with reversed direction
	HashSet descendingFields = new HashSet();

	/**
	 * Create a new instance of the receiver categorised by categoryField
	 * 
	 * @param categoryField
	 *            May be <code>null/<code>
	 * @param mainFields in order of compare significance
	 */
	public MarkerComparator(MarkerField categoryField, MarkerField[] mainFields) {
		category = categoryField;
		fields = mainFields;
	}

	/**
	 * Compare the two objects to see if they have the same category value
	 * 
	 * @param object1
	 * @param object2
	 * @return int
	 * @see Comparable#compareTo(Object)
	 */
	public int compareCategory(Object object1, Object object2) {
		if (category == null)
			return 0;
		return category.compare((MarkerItem) object1, (MarkerItem) object2);
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see java.util.Comparator#compare(java.lang.Object, java.lang.Object)
	 */
	public int compare(Object arg0, Object arg1) {

		MarkerItem item0 = (MarkerItem) arg0;
		MarkerItem item1 = (MarkerItem) arg1;
		
		//Sort by category first
		if(category != null){
			int value = category.compare(item0, item1);
			if(value != 0)
				return value;
		}
			
		for (int i = 0; i < fields.length; i++) {

			int value;
			if (descendingFields.contains(fields[i]))
				value = fields[i].compare(item1, item0);
			else
				value = fields[i].compare(item0, item1);
			if (value == 0)
				continue;
			return value;
		}
		return 0;
	}

	/**
	 * Switch the priority of the field from ascending to descending or vice
	 * versa.
	 * 
	 * @param field
	 */
	public void reversePriority(MarkerField field) {
		if (descendingFields.remove(field))
			return;
		descendingFields.add(field);

	}

	/**
	 * Set field to be the first sort field.
	 * 
	 * @param field
	 */
	void setPrimarySortField(MarkerField field) {
		if (fields[0] == field) {
			reversePriority(field);
			return;
		}
		int insertionIndex = 1;
		MarkerField[] newFields = new MarkerField[fields.length];

		newFields[0] = field;
		for (int i = 0; i < newFields.length; i++) {
			if (fields[i] == field)
				continue;
			newFields[insertionIndex] = fields[i];
			insertionIndex++;
		}

		fields = newFields;

	}

	/**
	 * Restore the receiver's state from memento.
	 * 
	 * @param memento
	 */
	void restore(IMemento memento) {
		if(memento == null)
			return;
		
		String primaryField = memento.getString(PRIMARY_SORT_FIELD_TAG);
		if (primaryField == null || primaryField.equals(fields[0].getId()))
			return;
		for (int i = 1; i < fields.length; i++) {
			if (fields[i].getId().equals(primaryField)) {
				setPrimarySortField(fields[i]);
				break;
			}
		}
		IMemento[] descending = memento.getChildren(DESCENDING_FIELDS);
		
		for (int i = 0; i < fields.length; i++) {
			for (int j = 0; j < descending.length; j++) {
				if(descending[j].getID().equals(fields[i].getId())){
					descendingFields.add(fields[i]);
					continue;
				}
				
			}
		}

	}

	/**
	 * Save the current sort field in the memento.
	 * @param memento
	 */
	void saveState(IMemento memento) {
		memento.putString(PRIMARY_SORT_FIELD_TAG, fields[0].getId());
		Iterator descendingIterator = descendingFields.iterator();
		while(descendingIterator.hasNext()){
			memento.createChild(DESCENDING_FIELDS, ((MarkerField)descendingIterator.next()).getId());
		}
		
	}

	/**
	 * Get the field that is the main sort field
	 * @return MarkerField
	 */
	MarkerField getPrimarySortField() {
		return fields[0];
	}

}