/*******************************************************************************
 * Copyright (c) 2000, 2006 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.dialogs;

import java.util.Comparator;

import org.eclipse.core.runtime.Assert;

/**
 * Quick sort to sort key-value pairs. The keys and arrays are specified
 * in separate arrays.
 * 
 * @since 2.0
 */
/* package */class TwoArrayQuickSorter {

    private Comparator fComparator;

    /**
     * Default comparator.
     */
    public static final class StringComparator implements Comparator {
        private boolean fIgnoreCase;

        StringComparator(boolean ignoreCase) {
            fIgnoreCase = ignoreCase;
        }

        public int compare(Object left, Object right) {
            return fIgnoreCase ? ((String) left)
                    .compareToIgnoreCase((String) right) : ((String) left)
                    .compareTo((String) right);
        }
    }

    /**
     * Creates a sorter with default string comparator.
     * The keys are assumed to be strings.
     * @param ignoreCase specifies whether sorting is case sensitive or not.
     */
    public TwoArrayQuickSorter(boolean ignoreCase) {
        fComparator = new StringComparator(ignoreCase);
    }

    /**
     * Creates a sorter with a comparator.
     * @param comparator the comparator to order the elements. The comparator must not be <code>null.
     */
    public TwoArrayQuickSorter(Comparator comparator) {
        fComparator = comparator;
    }

    /**
     * Sorts keys and values in parallel.
     * @param keys   the keys to use for sorting.
     * @param values the values associated with the keys.
     */
    public void sort(Object[] keys, Object[] values) {
        if ((keys == null) || (values == null)) {
            Assert.isTrue(false, "Either keys or values in null"); //$NON-NLS-1$
            return;
        }

        if (keys.length <= 1) {
			return;
		}

        internalSort(keys, values, 0, keys.length - 1);
    }

    private void internalSort(Object[] keys, Object[] values, int left,
            int right) {
        int original_left = left;
        int original_right = right;

        Object mid = keys[(left + right) / 2];
        do {
            while (fComparator.compare(keys[left], mid) < 0) {
				left++;
			}

            while (fComparator.compare(mid, keys[right]) < 0) {
				right--;
			}

            if (left <= right) {
                swap(keys, left, right);
                swap(values, left, right);
                left++;
                right--;
            }
        } while (left <= right);

        if (original_left < right) {
			internalSort(keys, values, original_left, right);
		}

        if (left < original_right) {
			internalSort(keys, values, left, original_right);
		}
    }

    /*
     * Swaps x[a] with x[b].
     */
    private static final void swap(Object x[], int a, int b) {
        Object t = x[a];
        x[a] = x[b];
        x[b] = t;
    }

}