/*
    * Copyright (c) 2003-2008 by Cosylab d. d.
    *
    * This file is part of Java-Common.
    *
    * Java-Common is free software: you can redistribute it and/or modify
    * it under the terms of the GNU General Public License as published by
    * the Free Software Foundation, either version 3 of the License, or
    * (at your option) any later version.
   *
   * Java-Common is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   * GNU General Public License for more details.
   *
   * You should have received a copy of the GNU General Public License
   * along with Java-Common.  If not, see <http://www.gnu.org/licenses/>.
   */
  
  package com.cosylab.util;
  
  import java.lang.reflect.Array;
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.Enumeration;
  import java.util.Iterator;
  import java.util.List;
  
  /**
   * A class containing convenience methods for working with arrays.
   * 
   * @author <a href="mailto:miha.kadunc@cosylab.com">Miha Kadunc</a>
   * @version $id$
   */
  public final class ArrayHelper {
  
  	/**
  	 * Works on non sorted arrays
  	 */
  	public static int firstGreaterThan(double[] array, double key) {
  		return firstGreaterThan(array, key, 0, array.length - 1);
  	}
  
  	/**
  	 * Works on non sorted arrays
  	 */
  	public static int firstGreaterThan(double[] array, double key,
  			int rangeStart, int rangeEnd) {
  		for (int i = rangeStart; i < rangeEnd + 1; i++) {
  			if (array[i] > key)
  				return i;
  		}
  		return -1;
  	}
  
  	/**
  	 * Works fast on sorted arrays
  	 */
  	public static int firstGreaterThanInSorted(double[] array, double key) {
  		return firstGreaterThanInSorted(array, key, 0, array.length - 1);
  	}
  
  	/**
  	 * Works fast on sorted arrays
  	 */
  	public static int firstGreaterThanInSorted(double[] array, double key,
  			int startIndex, int endIndex) {
  		if (array.length < 1)
  			return -1;
  		if (array[startIndex] > key)
  			return startIndex;
  		if (endIndex - startIndex > 3) {
  			int mid = (startIndex + endIndex) / 2;
  			if (array[mid] <= key)
  				return firstGreaterThanInSorted(array, key, mid + 1, endIndex);
  			else
  				return firstGreaterThanInSorted(array, key, startIndex, mid);
  		} else
  			return firstGreaterThan(array, key, startIndex, endIndex);
  	}
  
  	public static int firstIndexOf(Object array, Object key) {
  		for (int i = 0; i < Array.getLength(array); i++) {
  			if (Array.get(array, i) != null && Array.get(array, i).equals(key))
  				return i;
  		}
  		return -1;
  	}
  
  	public static boolean contains(Object[] array, Object key) {
  		return firstIndexOf(array, key) != -1;
  	}
  
  	public static Object[] getArrayFromEnumeration(Enumeration e) {
  		assert (e != null);
  		ArrayList temp = new ArrayList();
  		while (e.hasMoreElements()) {
  			temp.add(e.nextElement());
  		}
 		Object[] retVal = new Object[temp.size()];
 		temp.toArray(retVal);
 		return retVal;
 	}
 
 	public static Object[] getArrayFromIterator(Iterator i) {
 		assert (i != null);
 		ArrayList temp = new ArrayList();
 		while (i.hasNext()) {
 			temp.add(i.next());
 		}
 		Object[] retVal = new Object[temp.size()];
 		temp.toArray(retVal);
 		return retVal;
 	}
 
 	public static void flip(Object array) {
 		if (array == null)
 			return;
 		Object v = null;
 		int size = Array.getLength(array);
 		if (size == 1)
 			return;
 		for (int i = 0; i < size / 2; i++) {
 			v = Array.get(array, i);
 			Array.set(array, i, Array.get(array, size - i - 1));
 			Array.set(array, size - i - 1, v);
 		}
 	}
 
 	public static double[] toDoubleArray(Object array) {
 		if (array instanceof double[])
 			return (double[]) array;
 		else if (array instanceof long[]) {
 			long[] lAr = (long[]) array;
 			double[] ret = new double[lAr.length];
 			for (int i = 0; i < lAr.length; i++) {
 				ret[i] = lAr[i];
 			}
 			return ret;
 		} else if (array instanceof float[]) {
 			float[] lAr = (float[]) array;
 			double[] ret = new double[lAr.length];
 			for (int i = 0; i < lAr.length; i++) {
 				ret[i] = (double) lAr[i];
 			}
 			return ret;
 		} else if (array instanceof int[]) {
 			int[] lAr = (int[]) array;
 			double[] ret = new double[lAr.length];
 			for (int i = 0; i < lAr.length; i++) {
 				ret[i] = lAr[i];
 			}
 			return ret;
 		} else if (array instanceof short[]) {
 			short[] lAr = (short[]) array;
 			double[] ret = new double[lAr.length];
 			for (int i = 0; i < lAr.length; i++) {
 				ret[i] = lAr[i];
 			}
 			return ret;
 		} else if (array instanceof byte[]) {
 			byte[] lAr = (byte[]) array;
 			double[] ret = new double[lAr.length];
 			for (int i = 0; i < lAr.length; i++) {
 				ret[i] = lAr[i];
 			}
 			return ret;
 		} else if (array instanceof Number[]) {
 			Number[] lAr = (Number[]) array;
 			double[] ret = new double[lAr.length];
 			for (int i = 0; i < lAr.length; i++) {
 				ret[i] = lAr[i].doubleValue();
 			}
 			return ret;
 		}
 		return null;
 	}
 
 	public static Object trim(Object[] array) {
 		int end = firstIndexOf(array, null);
 		if (end == -1)
 			return array;
 		// System.out.println("Trimming at" + end);
 		Object ret = Array
 				.newInstance(array.getClass().getComponentType(), end);
 		System.arraycopy(array, 0, ret, 0, end);
 		return ret;
 	}
 
 	public static Integer[] toIntegerArray(int[] input) {
 		Integer[] ret = new Integer[input.length];
 		for (int i = input.length - 1; i >= 0; i--) {
 			ret[i] = new Integer(input[i]);
 		}
 		return ret;
 	}
 
 	public static int[] toIntArray(Number[] input) {
 		int[] ret = new int[input.length];
 		for (int i = input.length - 1; i >= 0; i--) {
 			ret[i] = input[i].intValue();
 		}
 		return ret;
 	}
 
 	/**
 	 * Get a sub array of a list.
 	 * 
 	 * @param <T>
 	 *            Type of list's elements.
 	 * @param clazz
 	 *            The type of list's elements.
 	 * @param list
 	 *            The list.
 	 * @param offset
 	 *            Offset in the list that will be the first element of the
 	 *            resulting array.
 	 * @param length
 	 *            Number of elements in the list.
 	 * @return Subarray of the list.
 	 */
 	@SuppressWarnings("unchecked")
 	public static <T> T[] subArray(Class<T> clazz, List<T> list, int offset,
 			int length) {
 		int resultLen = list.size() - offset;
 		if (resultLen > length) {
 			resultLen = length;
 		}
 		if (resultLen < 0) {
 			resultLen = 0;
 		}
 		T[] result = (T[]) Array.newInstance(clazz, resultLen);
 		for (int i = 0; i < resultLen; ++i) {
 			if (offset + i >= 0) {
 				result[i] = list.get(offset + i);
 			}
 		}
 		return result;
 	}
 }