package be.kdg.cryptomuntproject.generics;

import java.util.Comparator;
import java.util.LinkedList;
import java.util.TreeMap;


/**
 * Deze klasse maakt gebruik van een treemap met als key een Integer en als value een lijst van generic elementen.
 * @param <T> generic
 * @author Jonathan Peers
 * @version generics_module_2
 */
public class PriorityQueue<T> implements FIFOQueue<T> {

    private TreeMap<Integer, LinkedList<T>> queue;

    /**
     * We gaan in de constructor de treemap initialiseren. We geven een Comparator methode mee (reverseOrder()) in de constructor van de treemap.
     */
    public PriorityQueue() {
        queue = new TreeMap<>(Comparator.reverseOrder());
    }

    /**
     * Deze methode laat ons elementen toevoegen aan één van de lijsten in de treemap (queue)
     * @param element een element van het type generic.
     * @param priority een getal van 1 tot 5. Geeft gewicht aan het element en bepaalt aan welke lijst het wordt toegevoegd in de treemap.
     * @return geeft terug of het element correct is toegevoegd aan de queue.
     */
    public boolean enqueue(T element, int priority) {
        //check element
        for (LinkedList<T> ts : queue.values()) {
            if (ts.contains(element)) return false;
        }

        if (!queue.containsKey(priority)) {
            queue.put(priority, new LinkedList<T>());
        }

        return queue.get(priority).add(element);
    }

    /**
     * Deze methode geeft het element terug dat zich vooraan bevindt in de hoogste prioriteitsreeks
     * @return geeft een element terug van het type Generic.
     */
    @Override
    public T dequeue() {
//        Retourneer het element dat zich vooraan bevindt in de hoogste prioriteitsreeks
        for (Integer i : queue.keySet()) {
            if (!queue.get(i).isEmpty()) {
                return queue.get(i).pop();
            }
        }

       /* KAN OOK OP DEZE MANIER
        for (LinkedList<T> ts : queue.values()) {
            if (ts.size() > 0) {
                return ts.remove(0);
            }
        }*/

        return null;
    }

    /**
     * Deze methode zoekt naar een bepaald element in de queue.
     * @param element generic
     * @return integer
     */
    @Override
    public int search(T element) {
        int i = 0;
        for (LinkedList<T> ts : queue.values()) { //queue zit vol met lijsten van cryptomunten
            for (T t : ts) { // lijst van munten
                if (t.equals(element)) { //munt == element?
                    return i;
                }
                i++;
            }
        }
        return -1;
    }

    /**
     * Deze methode geeft het aantal elementen in de queue terug.
     * @return grootte van de queue in de vorm van een integer.
      */
    @Override
    public int getSize() {
        int totaal = 0;
        for (LinkedList<T> ts : queue.values()) {
            totaal += ts.size();
        }
        return totaal;

    }

    /**
     * Deze methode geeft de be.kdg.cryptomuntproject.data van deze klasse terug in een geformateerde string.
     * @return een geformateerde string.
     */
    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        for (Integer integer : queue.keySet()) {
            for (T t : queue.get(integer)) {
                sb.append(String.format("%d: %s\n", integer, t));
            }
        }
        return sb.toString();
    }
}