import java.util.Comparator;
import java.util.HashMap;
import java.util.PriorityQueue;
import java.util.Vector;

/*
 * Autori: Serban Alexandru-Florian 
 * 		   Tanase Adrian-Ionut
 */
public class Main {

	public static void main(String[] args) {
		Vector<Complex> v;

		/* Citeste date de test. */
		v = Complex.readData(".date.in");
		System.out.println("Vectorul initial:");
		Complex.writeVector(v);

		/* Verifica sortarea. */
		Vector<Complex> sorted = getSorted(v);
		System.out.println("Vectorul sortat:");
		Complex.writeVector(sorted);

		/* Verifica maparea. */
		HashMap<Complex, Integer> mapping = getMapping(v);
		System.out.println("Maparea:");
		for (Complex element : sorted) {
			System.out.println(String.format("%s e pe pozitia %d", element,
					mapping.get(element)));
		}
	}

	private static class ComplexComparator implements Comparator<Complex> {

		/**
		 * Functie ce compara doua numere complexe: intai compara partea reala
		 * si daca ambele numere au aceeasi parte reala, atunci compara partea
		 * imaginara
		 */
		@Override
		public int compare(Complex a, Complex b) {
			return (int) ((a.r == b.r) ? -a.i + b.i : -a.r + b.r);
		}
	}

	/**
	 * Functie ce sorteaza crescator elementele unui vector de numere complexe
	 * 
	 * @param v
	 *            vectorul de numere complexe de intrare
	 * @return vectorul de numere complexe sortat descrescator
	 */
	private static Vector<Complex> getSorted(Vector<Complex> v) {
		Vector<Complex> res = new Vector<Complex>(); // vectorul rezultat
		PriorityQueue<Complex> q = new PriorityQueue<Complex>(
				new ComplexComparator());

		for (Complex element : v) {
			q.add(element);
		}

		while (!q.isEmpty()) {
			res.add(q.poll());
		}

		/*
		 * TODO Folosind PriorityQueue, adaugati elementele din v in ordine
		 * crescatoare. Pentru PriorityQueue folositi comparatorul definit mai
		 * sus
		 */

		return res;
	}

	/**
	 * Functie ce construieste un HashMap: pentru fiecare element complex
	 * atribuie pozitia sa in vectorul sortat
	 * 
	 * @param v
	 *            vectorul de elemente complexe, nesortat
	 * @return HashMap care atribuie pentru fiecare element pozitia sa in
	 *         vectorul sortat
	 */
	private static HashMap<Complex, Integer> getMapping(Vector<Complex> v) {
		HashMap<Complex, Integer> res = new HashMap<>();
		Vector<Complex> vec = getSorted(v);
		ComplexComparator cmp = new ComplexComparator();
		for (int i = 0; i < v.size(); i++) {
			for (int j = 0; j < vec.size(); j++) {

				if (cmp.compare(v.get(i), vec.get(j)) == 0) {
					res.put(v.get(i), i);
				}

			}
		}

		/*
		 * TODO Adaugati in map, pentru fiecare element din v, pozitia sa in
		 * vectorul sortat.
		 */

		return res;
	}
}