package simulator.utils;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;

public class MergeSort<T>{

	private Class<?> c;
	private Method m;

	public void initSort(T[] array, String methodName, boolean ascending) {
		try {
			c = Class.forName(array.getClass().getCanonicalName().substring(0,  array.getClass().getCanonicalName().length() -2));
		} catch (ClassNotFoundException e) {
			return;
		}
		try {
			m = c.getMethod(methodName);
		} catch (SecurityException e) {
			return;
		} catch (NoSuchMethodException e) {
			return;
		}
		T[] tmpArray = array.clone();
		mergeSort(array, tmpArray, 0, array.length-1, ascending);
	}
	
	public void initCollectionSort(Collection<T> collection, String methodName, boolean ascending) {
		
		Iterator<T> iterator = collection.iterator();
		try {
			while (iterator.hasNext() && c == null) {
				c = Class.forName(iterator.next().getClass().getCanonicalName());
			}
		} catch (ClassNotFoundException e) {
			return;
		}
		if(c == null)
			return;
		try {
			m = c.getMethod(methodName);
		} catch (SecurityException e) {
			return;
		} catch (NoSuchMethodException e) {
			return;
		}
		T[] array = (T[]) collection.toArray();
		T[] tmpArray = array.clone();
		mergeSort(array, tmpArray, 0, array.length-1, ascending);
		collection.clear();
		collection.addAll(new ArrayList(Arrays.asList(array)));

	}

	private void mergeSort(T[] array, T[] tmpArray, int left,
			int right, boolean ascending) {
		if (left < right) {
			int center = (left + right) / 2;
			mergeSort(array, tmpArray, left, center, ascending);
			mergeSort(array, tmpArray, center + 1, right, ascending);
			merge(array, tmpArray, left, center + 1, right, ascending);
		}
	}

	private void merge(T[] array, T[] tmpArray, int leftPos,
			int rightPos, int rightEnd, boolean ascending) {
		int leftEnd = rightPos - 1;
		int tmpPos = leftPos;
		int numElements = rightEnd - leftPos + 1;
		while (leftPos <= leftEnd && rightPos <= rightEnd)
			try {
				if(ascending)
				{	
					if (Integer.class.isInstance(m.invoke(array[leftPos])))
					{
						if ((Integer) m.invoke(array[leftPos]) < (Integer) m.invoke(array[rightPos]))
							tmpArray[tmpPos++] = array[leftPos++];
						else
							tmpArray[tmpPos++] = array[rightPos++];
					}
					else if (Long.class.isInstance(m.invoke(array[leftPos])))
					{
						if ((Long) m.invoke(array[leftPos]) < (Long) m.invoke(array[rightPos]))
							tmpArray[tmpPos++] = array[leftPos++];
						else
							tmpArray[tmpPos++] = array[rightPos++];
					}
					else if (Double.class.isInstance(m.invoke(array[leftPos])))
					{
						if ((Double) m.invoke(array[leftPos]) < (Double) m.invoke(array[rightPos]))
							tmpArray[tmpPos++] = array[leftPos++];
						else
							tmpArray[tmpPos++] = array[rightPos++];
					}
					else if (String.class.isInstance(m.invoke(array[leftPos])))
					{
						if (((String) m.invoke(array[leftPos])).compareTo((String) m.invoke(array[rightPos])) < 0)
							tmpArray[tmpPos++] = array[leftPos++];
						else
							tmpArray[tmpPos++] = array[rightPos++];
					} else {
						throw new IllegalAccessException();
					}
				}
				
				else {
					if (Integer.class.isInstance(m.invoke(array[leftPos])))
					{
						if ((Integer) m.invoke(array[leftPos]) > (Integer) m.invoke(array[rightPos]))
							tmpArray[tmpPos++] = array[leftPos++];
						else
							tmpArray[tmpPos++] = array[rightPos++];
					}
					else if (Long.class.isInstance(m.invoke(array[leftPos])))
					{
						if ((Long) m.invoke(array[leftPos]) > (Long) m.invoke(array[rightPos]))
							tmpArray[tmpPos++] = array[leftPos++];
						else
							tmpArray[tmpPos++] = array[rightPos++];
					}
					else if (Double.class.isInstance(m.invoke(array[leftPos])))
					{
						if ((Double) m.invoke(array[leftPos]) > (Double) m.invoke(array[rightPos]))
							tmpArray[tmpPos++] = array[leftPos++];
						else
							tmpArray[tmpPos++] = array[rightPos++];
					}
					else if (String.class.isInstance(m.invoke(array[leftPos])))
					{
						if (((String) m.invoke(array[leftPos])).compareTo((String) m.invoke(array[rightPos])) > 0)
							tmpArray[tmpPos++] = array[leftPos++];
						else
							tmpArray[tmpPos++] = array[rightPos++];
					} else {
						throw new IllegalAccessException();
					}
				}
			} catch (IllegalArgumentException e) {
				break;
			} catch (IllegalAccessException e) {
				break;
			} catch (InvocationTargetException e) {
				break;
			}

		while (leftPos <= leftEnd)
			tmpArray[tmpPos++] = array[leftPos++];

		while (rightPos <= rightEnd)
			tmpArray[tmpPos++] = array[rightPos++];

		for (int i = 0; i < numElements; i++, rightEnd--)
			array[rightEnd] = tmpArray[rightEnd];
	}
}