/*******************************************************************************
 * Copyright (c) 2004, 2008 Tasktop Technologies 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:
 *     Tasktop Technologies - initial API and implementation
 *     Frank Becker - improvements for bug 231336
 *******************************************************************************/

package org.eclipse.mylyn.internal.tasks.ui.util;

import java.util.Comparator;
import java.util.Date;

import org.eclipse.core.runtime.Assert;
import org.eclipse.mylyn.internal.tasks.ui.dialogs.Messages;
import org.eclipse.mylyn.internal.tasks.ui.views.TaskKeyComparator;
import org.eclipse.mylyn.tasks.core.IRepositoryElement;
import org.eclipse.mylyn.tasks.core.ITask;
import org.eclipse.ui.IMemento;

/**
 * @author Mik Kersten
 * @author Frank Becker
 */
public class TaskComparator implements Comparator<ITask> {

	public enum SortByIndex {
		DATE_CREATED, PRIORITY, SUMMARY, TASK_ID;

		public static SortByIndex valueOfLabel(String label) {
			for (SortByIndex value : values()) {
				if (value.getLabel().equals(label)) {
					return value;
				}
			}
			return null;
		}

		public String getLabel() {
			switch (this) {
			case PRIORITY:
				return Messages.TaskCompareDialog_Priority;
			case SUMMARY:
				return Messages.TaskCompareDialog_Summary;
			case DATE_CREATED:
				return Messages.TaskCompareDialog_DateCreated;
			case TASK_ID:
				return Messages.TaskCompareDialog_TaskID;
			default:
				return null;
			}
		}

	}

	public static final int DEFAULT_SORT_DIRECTION = 1;

	private static final SortByIndex DEFAULT_SORT_INDEX = SortByIndex.PRIORITY;

	private static final SortByIndex DEFAULT_SORT_INDEX2 = SortByIndex.DATE_CREATED;

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

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

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

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

	/**
	 * Return a array of values to pass to taskKeyComparator.compare() for sorting
	 * 
	 * @param element
	 *            the element to sort
	 * @return String array[component, taskId, summary]
	 */
	public static String[] getSortableFromElement(IRepositoryElement element) {
		final String a[] = new String[] { "", null, element.getSummary() }; //$NON-NLS-1$

		if (element instanceof ITask) {
			ITask task1 = (ITask) element;
			if (task1.getTaskKey() != null) {
				a[1] = task1.getTaskKey();
			}
		}
		return a;
	}

	private SortByIndex sortByIndex = DEFAULT_SORT_INDEX;

	private SortByIndex sortByIndex2 = DEFAULT_SORT_INDEX2;

	private int sortDirection = DEFAULT_SORT_DIRECTION;

	private int sortDirection2 = DEFAULT_SORT_DIRECTION;

	private final TaskKeyComparator taskKeyComparator = new TaskKeyComparator();

	public TaskComparator() {
	}

	public int compare(ITask element1, ITask element2) {
		if (DEFAULT_SORT_INDEX.equals(sortByIndex)) {
			int result = sortByPriority(element1, element2, sortDirection);
			if (result != 0) {
				return result;
			}

			if (DEFAULT_SORT_INDEX2.equals(sortByIndex2)) {
				return sortByDate(element1, element2, sortDirection2);
			} else {
				if (SortByIndex.SUMMARY.equals(sortByIndex2)) {
					return sortBySummary(element1, element2, sortDirection2);
				} else if (SortByIndex.TASK_ID.equals(sortByIndex2)) {
					return sortByID(element1, element2, sortDirection2);
				} else {
					return result;
				}
			}
		} else if (DEFAULT_SORT_INDEX2.equals(sortByIndex)) {
			int result = sortByDate(element1, element2, sortDirection);
			if (result != 0) {
				return result;
			}
			if (DEFAULT_SORT_INDEX.equals(sortByIndex2)) {
				return sortByPriority(element1, element2, sortDirection2);
			} else {
				if (SortByIndex.SUMMARY.equals(sortByIndex2)) {
					return sortBySummary(element1, element2, sortDirection2);
				} else if (SortByIndex.TASK_ID.equals(sortByIndex2)) {
					return sortByID(element1, element2, sortDirection2);
				} else {
					return result;
				}
			}
		} else if (SortByIndex.SUMMARY.equals(sortByIndex)) {
			int result = sortBySummary(element1, element2, sortDirection);
			if (result != 0) {
				return result;
			}
			if (DEFAULT_SORT_INDEX2.equals(sortByIndex2)) {
				return sortByDate(element1, element2, sortDirection2);
			} else {
				if (DEFAULT_SORT_INDEX.equals(sortByIndex2)) {
					return sortByPriority(element1, element2, sortDirection2);
				} else if (SortByIndex.TASK_ID.equals(sortByIndex2)) {
					return sortByID(element1, element2, sortDirection2);
				} else {
					return result;
				}
			}
		} else {
			int result = sortByID(element1, element2, sortDirection);
			if (result != 0) {
				return result;
			}
			if (DEFAULT_SORT_INDEX2.equals(sortByIndex2)) {
				return sortByDate(element1, element2, sortDirection2);
			} else {
				if (DEFAULT_SORT_INDEX.equals(sortByIndex2)) {
					return sortByPriority(element1, element2, sortDirection2);
				} else if (SortByIndex.SUMMARY.equals(sortByIndex2)) {
					return sortBySummary(element1, element2, sortDirection2);
				} else {
					return result;
				}
			}
		}
	}

	public SortByIndex getSortByIndex() {
		return sortByIndex;
	}

	public SortByIndex getSortByIndex2() {
		return sortByIndex2;
	}

	public int getSortDirection() {
		return sortDirection;
	}

	private int getSortDirection(IMemento memento, String key, int defaultValue) {
		Integer value = memento.getInteger(key);
		if (value != null) {
			return value >= 0 ? 1 : -1;
		}
		return defaultValue;
	}

	public int getSortDirection2() {
		return sortDirection2;
	}

	private SortByIndex getSortIndex(IMemento memento, String key, SortByIndex defaultValue) {
		String value = memento.getString(key);
		if (value != null) {
			try {
				return SortByIndex.valueOf(value);
			} catch (IllegalArgumentException e) {
				// ignore
			}
		}
		return defaultValue;
	}

	public void restoreState(IMemento memento) {
		setSortByIndex(getSortIndex(memento, MEMENTO_KEY_SORT_INDEX, DEFAULT_SORT_INDEX));
		setSortDirection(getSortDirection(memento, MEMENTO_KEY_SORT_DIRECTION, DEFAULT_SORT_DIRECTION));
		setSortByIndex2(getSortIndex(memento, MEMENTO_KEY_SORT_INDEX2, DEFAULT_SORT_INDEX2));
		setSortDirection(getSortDirection(memento, MEMENTO_KEY_SORT_DIRECTION2, DEFAULT_SORT_DIRECTION));
	}

	public void saveState(IMemento memento) {
		memento.putString(MEMENTO_KEY_SORT_INDEX, getSortByIndex().name());
		memento.putInteger(MEMENTO_KEY_SORT_DIRECTION, getSortDirection());
		memento.putString(MEMENTO_KEY_SORT_INDEX2, getSortByIndex2().name());
		memento.putInteger(MEMENTO_KEY_SORT_DIRECTION2, getSortDirection2());
	}

	public void setSortByIndex(SortByIndex sortByIndex) {
		Assert.isNotNull(sortByIndex);
		this.sortByIndex = sortByIndex;
	}

	public void setSortByIndex2(SortByIndex sortByIndex) {
		Assert.isNotNull(sortByIndex);
		this.sortByIndex2 = sortByIndex;
	}

	public void setSortDirection(int sortDirection) {
		Assert.isTrue(sortDirection == -1 || sortDirection == 1);
		this.sortDirection = sortDirection;
	}

	public void setSortDirection2(int sortDirection) {
		Assert.isTrue(sortDirection == -1 || sortDirection == 1);
		this.sortDirection2 = sortDirection;
	}

	private int sortByDate(ITask element1, ITask element2, int sortDirection) {
		Date date1 = element1.getCreationDate();
		Date date2 = element2.getCreationDate();
		if (date1 == null) {
			return (date2 != null) ? sortDirection : 0;
		} else if (date2 == null) {
			return -sortDirection;
		}
		return sortDirection * date1.compareTo(date2);
	}

	private int sortByID(ITask element1, ITask element2, int sortDirection) {
		String key1 = element1.getTaskKey();
		String key2 = element2.getTaskKey();
		if (key1 == null) {
			return (key2 != null) ? sortDirection : 0;
		} else if (key2 == null) {
			return -sortDirection;
		}
		return sortDirection * taskKeyComparator.compare2(key1, key2);
	}

	private int sortByPriority(ITask element1, ITask element2, int sortDirection) {
		return sortDirection * element1.getPriority().compareToIgnoreCase(element2.getPriority());
	}

	private int sortBySummary(ITask element1, ITask element2, int sortDirection) {
		String key1 = element1.getSummary();
		String key2 = element2.getSummary();
		if (key1 == null) {
			return (key2 != null) ? sortDirection : 0;
		} else if (key2 == null) {
			return -sortDirection;
		}
		return sortDirection * key1.compareToIgnoreCase(key2);
	}

}