import java.util.ArrayList;
import java.util.Stack;

public class Logica<T extends Comparable> {

	private T[] a;
	private T[] b;
	private T[] u;
	private int indiceUnion = 0;

	public Logica(T[] a, T[] b) {
		this.a = a;
		this.b = b;
	}

	public double getMediaIterativo(T[] a1, T[] a2, int i) {
		double acumulado = 0; //Alternativamente se puede utilizar una pila, pero no es necesario ya que únicamente tenemos que sumar elemento a elemento.
		int total = ( a1.length + a2.length);
		while (i>=0) {

			if(a1[0] instanceof Integer){
				if (i < a1.length) {
					double t = (Integer) a1[i];
					Double temp = t/total;
					acumulado+=temp;
				}
				if (i < a2.length) {
					double t2 = (Integer) a2[i];
					double temp2 = t2/total;
					acumulado+=temp2;
				}
			} // FIN CASO INTEGER



			if(a1[0] instanceof Double){
				if (i < a1.length) {
					double t = (Double) a1[i];
					Double temp = t/total;
					acumulado+=temp;
				}
				if (i < a2.length) {
					double t2 = (Double) a2[i];
					double temp2 = t2/total;
					acumulado+=temp2;
				}
			}//FIN CASO DOUBLE



			if(a1[0] instanceof Float){
				if (i < a1.length) {
					Float t = (Float) a1[i];
					Float temp = t/total;
					acumulado+=temp;
				}
				if (i < a2.length) {
					Float t2 = (Float) a2[i];
					Float temp2 = t2/total;
					acumulado+=temp2;
				}
			}//FIN CASO Float

			if(a1[0] instanceof String){
				if (i < a1.length) {
					String first = (String) a1[i];
					double temp = (double)first.charAt(0)/total;
					acumulado+=temp;
				}
				if (i < a2.length) {
					String first2 = (String) a2[i];
					double temp = (double)first2.charAt(0)/total;
					acumulado+=temp;
				}
			}//FIN CASO String

			i--;

		}

			return acumulado;
		}

	/**
	 * Método que calcula la media de dos arrays, además, junta estos en un array
	 * auxiliar que posteriormente se utiliza en el método getMediana(), que calcula
	 * la mediana del array combinado.Esto está hecho para optimizar la ejecución
	 * del programa. En caso de que queramos calcular la mediana sin calcular la
	 * media previamente, hay que llamar al metodo unirArrays() previamente.
	 *
	 * @param a1
	 * @param a2
	 * @param i
	 * @return
	 */
	public double getMedia(T[] a1, T[] a2, int i) {

		double ac1 = 0;
		double ac2 = 0;
		int mitad = (a1.length + a2.length);

		// CASO DOUBLE
		if (a1[0] instanceof Double) {
			if (i < a1.length) {
				if (u == null)
					u = (T[]) new Double[a1.length + b.length];
				ac1 = (Double) a1[i] / ((double) a1.length + (double) a2.length);
				u[indiceUnion] = a1[i];
				indiceUnion++;
			}

			if (i < a2.length) {
				if (u == null)
					u = (T[]) new Double[a1.length + b.length];
				ac2 = (Double) a2[i] / ((double) a1.length + (double) a2.length);
				u[indiceUnion] = a2[i];
				indiceUnion++;
			}

			if (i != 0) {
				return ac1 + ac2 + getMedia(a1, a2, i - 1);
			} else {
				return ac1 + ac2;
			}
		} else if (a1[0] instanceof Integer) {

			if (i < a1.length) {
				if (u == null)
					u = (T[]) new Integer[a1.length + b.length];
				double temp = (Integer) a1[i];
				ac1 = Double.valueOf(temp / mitad);
				u[indiceUnion] = a1[i];
				indiceUnion++;
			}

			if (i < a2.length) {
				if (u == null)
					u = (T[]) new Integer[a1.length + b.length];
				double temp2 = (Integer) a2[i];
				ac2 = Double.valueOf(temp2 / mitad);
				u[indiceUnion] = a2[i];
				indiceUnion++;
			}
			if (i != 0) {
				return ac1 + ac2 + getMedia(a1, a2, i - 1);
			} else {
				return ac1 + ac2;
			}

		} // CASO FLOAT
		else if (a1[0] instanceof Float) {

			if (i < a1.length) {
				if (u == null)
					u = (T[]) new Float[a1.length + b.length];
				Float temp = (Float) a1[i];
				ac1 = (temp / mitad);
				u[indiceUnion] = a1[i];
				indiceUnion++;
			}

			if (i < a2.length) {
				if (u == null)
					u = (T[]) new Float[a1.length + b.length];
				Float temp2 = (Float) a2[i];
				ac2 = Double.valueOf(temp2 / mitad);
				u[indiceUnion] = a2[i];
				indiceUnion++;
			}
			if (i != 0) {
				return ac1 + ac2 + getMedia(a1, a2, i - 1);
			} else {
				return ac1 + ac2;
			}

		} // CASO STRING
		else if (i < a1.length) {
			if (u == null)
				u = (T[]) new String[a1.length + b.length];
			String first = (String) a1[i];
			ac1 = ((double) first.charAt(0) / mitad);
			u[indiceUnion] = a1[i];
			indiceUnion++;
		}

		if (i < a2.length) {
			if (u == null)
				u = (T[]) new String[a1.length + b.length];
			String first = (String) a2[i];
			ac2 = ((double) first.charAt(0) / mitad);
			u[indiceUnion] = a2[i];
			indiceUnion++;
		}
		if (i != 0) {
			return ac1 + ac2 + getMedia(a1, a2, i - 1);
		} else {
			return ac1 + ac2;
		}

	}

	public double getMediana() {
		if (u.length == 1)
			return (double) u[0];
		int longitud = u.length;

		// Comprueba si es impar, en cuyo caso tiene elemento central
		if ((longitud) % 2 != 0) {
			if (u[0] instanceof Integer)
				return (Integer) quickSort(u, 0, longitud - 1, longitud / 2);
			if (u[0] instanceof Double)
				return (Double) quickSort(u, 0, longitud - 1, longitud / 2);
			if (u[0] instanceof Float)
				return (Float) quickSort(u, 0, longitud - 1, longitud / 2);
			else
				return 0;
		}

		// Si no tiene elemento central, calcula la media de los dos elementos del
		// medio.
		else if (u[0] instanceof Integer) {
			double aux1 = (Integer) quickSort(u, 0, longitud - 1, longitud / 2 - 1);
			double aux2 = (Integer) quickSort(u, 0, longitud - 1, (longitud / 2));
			double resultado = (aux1 + aux2) / 2;
			return resultado;
		}
		if (u[0] instanceof Double) {
			Double aux1 = (Double) quickSort(u, 0, longitud - 1, longitud / 2 - 1);
			Double aux2 = (Double) quickSort(u, 0, longitud - 1, (longitud / 2));
			return ((aux1 + aux2) / 2);
		}
		if (u[0] instanceof Float) {
			Float aux1 = (Float) quickSort(u, 0, longitud - 1, longitud / 2 - 1);
			Float aux2 = (Float) quickSort(u, 0, longitud - 1, (longitud / 2));
			return ((aux1 + aux2) / 2);
		} else
			return 0;

	}

	private T quickSort(T[] array, int i, int j, int objetivo) {
		int indice = partition(array, i, j);
		if (indice == objetivo)
			return array[indice];
		else if (indice < objetivo)
			return quickSort(array, indice + 1, j, objetivo);
		else
			return quickSort(array, i, indice - 1, objetivo);
	}

	/**
	 * Método auxiliar para unir los dos arrays, únicamente se utiliza si se quiere
	 * calcular la mediana sin haber calculado la media con anterioridad.
	 *
	 * @param a1 Lista 1
	 * @param a2 Lista 2
	 */
	private void unirArrays(T[] a1, T[] a2) {
		int size = a1.length + a2.length;
		int max = Integer.max(a1.length, a2.length);
		ArrayList<T> aux = new ArrayList();
		for (int i = 0; i < max; i++) {
			aux.add(a1[i]);
			aux.add(a2[i]);
		}
		u = (T[]) aux.toArray();

	}

	private int partition(T[] arr, int low, int high) {
		T pivot = arr[high];
		int i = (low - 1);
		for (int j = low; j < high; j++) {
			if (arr[j].compareTo(pivot) <= 0) {
				i++;
				T temp = arr[i];
				arr[i] = arr[j];
				arr[j] = temp;

			}
		}
		T temp = arr[i + 1];
		arr[i + 1] = arr[high];
		arr[high] = temp;

		return i + 1;
	}

}