import java.util.Iterator;
import java.util.Map;
import java.util.TreeMap;
import java.util.TreeSet;
import java.util.Map.Entry;
import java.util.NavigableMap;
import java.util.NavigableSet;
import java.util.SortedMap;
import java.util.SortedSet;

/**
 * {@link <a href=
 * "https://[Log in to view URL]"
 * target= "_blank">Primitive TreeMap<K, V></a>}
 * 
 * @author itammb ( Italia Massimiliano Buscati )
 * @version JDK 1.15
 *
 */

class Main {

	public static enum Game {
		CRICKET, HOCKEY, TENNIS, FOOTBALL, VOLLEY, SWIMMING, CYCLING, RUNNING
	}
	
	private static class UniTestTreeMap {		
		/**
		 * @see TreeMap#firstEntry()
		 * @see TreeMap#lastEntry()
		 * 
		 */
		public void applayHeadAndTail_Element(NavigableMap<Game, Short>  buffer) {
			applayIterator(buffer);

			System.out.println(buffer.firstEntry());
			System.out.println(buffer.lastEntry());
		}
		
		/**
		 * @see TreeMap#higherEntry(Object)
		 * @see TreeMap#lowerEntry(Object)
		 * 
		 */
		public void applayHigherAndLower_Element(NavigableMap<Game, Short> buffer) {
			applayIterator(buffer);

			System.out.println(buffer.higherEntry(Game.RUNNING)); // null
			System.out.println(buffer.higherEntry(Game.CYCLING));
			System.out.println(buffer.higherEntry(Game.SWIMMING));
			System.out.println(buffer.higherEntry(Game.VOLLEY)); // il minore

			System.out.println(buffer.lowerEntry(Game.CRICKET)); // null
			System.out.println(buffer.lowerEntry(Game.VOLLEY));
			System.out.println(buffer.lowerEntry(Game.CYCLING));
			System.out.println(buffer.lowerEntry(Game.RUNNING));
		}
	
		/**
		 * @see TreeMap#floorEntry(Object)
		 * @see TreeMap#ceilingEntry(Object)
		 * 
		 */
		public void applayFloorAndCeiling_Element(NavigableMap<Game, Short> buffer) {
			applayIterator(buffer);
			buffer.remove(Game.CRICKET);
			buffer.remove(Game.RUNNING);
			applayIterator(buffer);
			
			 
			System.out.println(buffer.floorEntry(Game.RUNNING));  // minore (possibile) o uguale
			System.out.println(buffer.floorEntry(Game.FOOTBALL)); // se stesso
			System.out.println(buffer.floorEntry(Game.HOCKEY));   // se stesso
			System.out.println(buffer.floorEntry(Game.CRICKET));  // null

			System.out.println(buffer.ceilingEntry(Game.CRICKET)); // maggiore (possibile) o uguale
			System.out.println(buffer.ceilingEntry(Game.HOCKEY));  // se stesso
			System.out.println(buffer.ceilingEntry(Game.CYCLING)); // se stesso
			System.out.println(buffer.ceilingEntry(Game.RUNNING)); // null
		}	
		
		/**
		 * @see TreeMap#pollFirstEntry()
		 * @see TreeMap#pollLastEntry()
		 * 
		 */
		public void applayPoolHeadTail_Element(NavigableMap<Game, Short> buffer) {
			applayIterator(buffer);

			System.out.println(buffer.pollFirstEntry());
			System.out.println(buffer.pollLastEntry());

			applayIterator(buffer);
		}
		
		/**
		 * @see TreeMap#headMap(Object)
		 * @see SortedMap
		 * 
		 */
		public void applayHeadSet_Sorted(NavigableMap<Game, Short> buffer) {
			applayIterator(buffer);

			SortedMap<Game, Short> sorted = buffer.headMap(Game.RUNNING);
			applayIterator(sorted);

			sorted = buffer.headMap(Game.FOOTBALL);
			applayIterator(sorted);

			sorted.remove(Game.CRICKET);
			applayIterator(buffer);
		}
		
		/**
		 * @see TreeMap#headSet(Object, boolean)
		 * @see NavigableMap
		 * 
		 */
		public void applayHeadSet_Navigable(NavigableMap<Game, Short> buffer) {
			applayIterator(buffer);

			NavigableMap<Game, Short>  navigable = buffer.headMap(Game.FOOTBALL, true);
			applayIterator(navigable);

			navigable = buffer.headMap(Game.FOOTBALL, false);
			applayIterator(navigable);
			applayIterator(navigable.descendingMap());

			navigable.remove(Game.CRICKET);
			applayIterator(buffer);
		}
		
		/**
		 * @see TreeSet#tailSet(Object)
		 * @see SortedSet
		 * 
		 */
		public void applayTailSet_Sorted(NavigableMap<Game, Short> buffer) {
			applayIterator(buffer);

			SortedMap<Game, Short> sorted = buffer.tailMap(Game.FOOTBALL);
			applayIterator(sorted);

			sorted = buffer.tailMap(Game.VOLLEY);
			applayIterator(sorted);

			sorted.remove(Game.RUNNING);
			applayIterator(buffer);
		}
		
		/**
		 * @see TreeSet#tailSet(Object, boolean)
		 * @see NavigableSet
		 * 
		 */
		public void applayTailSet_Navigable(NavigableMap<Game, Short> buffer) {
			applayIterator(buffer);

			NavigableMap<Game, Short> navigable = buffer.tailMap(Game.FOOTBALL, true);
			applayIterator(navigable);

			navigable = buffer.tailMap(Game.FOOTBALL, false);
			applayIterator(navigable);
			applayIterator(navigable.descendingMap());

			navigable.remove(Game.SWIMMING);
			applayIterator(buffer);
		}
		
		/**
		 * @see TreeSet#descendingIterator()
		 * @see Iterator
		 * 
		 */
		public void applayDescendingIterator(NavigableMap<Game, Short> buffer) {
			
			System.out.println(" ------------------- ");
			
			if (buffer.isEmpty())
				System.out.print("[]");
			else
				for (Iterator<Entry<Game, Short>> itr = buffer.descendingMap().entrySet().iterator(); itr.hasNext();)
					System.out.print("e=" + itr.next() + " ");

			System.out.println();
		}	
			
		/**
		 * @see Map#entrySet()
		 * @see Iterator
		 * 
		 */
		public void applayIterator(Map<Game, Short> buffer) {
			if (buffer.isEmpty())
				System.out.print("[]");
			else
				for (Iterator<Entry<Game, Short>> itr = buffer.entrySet().iterator(); itr.hasNext();)
					System.out.print(itr.next() + " ");

			println();
		}

		private static void println() {
			System.out.println();
		}

		/**
		 * @see Map#ofEntries(Entry...)
		 *
		 */
		public static TreeMap<Game, Short> createTest() {
			Map<Game, Short> source = Map.ofEntries(					
					Map.entry(Game.CRICKET, Short.valueOf("1")),
					Map.entry(Game.HOCKEY, Short.valueOf("2")), 
					Map.entry(Game.TENNIS, Short.valueOf("3")),
					Map.entry(Game.FOOTBALL, Short.valueOf("4")),
					Map.entry(Game.VOLLEY, Short.valueOf("5")), 
					Map.entry(Game.SWIMMING, Short.valueOf("6")),
					Map.entry(Game.CYCLING, Short.valueOf("7")),
					Map.entry(Game.RUNNING, Short.valueOf("8")));

			TreeMap<Game, Short> buffer = new TreeMap<Game, Short>(source);

			return buffer;
		}
	}

	public static void main(String args[]) throws Exception {

		// Unit test - restituisce l'elemento più piccolo (first) / grande (last) 
		new UniTestTreeMap().applayHeadAndTail_Element(UniTestTreeMap.createTest());

		// Unit test - restituisce l'elemento contiguo inferiore (lower) /superiore (higher)
		new UniTestTreeMap().applayHigherAndLower_Element(UniTestTreeMap.createTest());
		
		// Unit test - restituisce l'elemento minore o uguale (floor) / maggiore o uguale
		// (ceiling)
		new UniTestTreeMap().applayFloorAndCeiling_Element(UniTestTreeMap.createTest());
		
		// Unit test - elimina un elemento in testa/coda e lo restituisce
		new UniTestTreeMap().applayPoolHeadTail_Element(UniTestTreeMap.createTest());
		
		// Unit test - restituisce una view navigabile in ordine crescente a partire
		// dalla testa della struttura:
		// escluso l'elemento di check ( le operazioni di mutazione sulla view
		// modificano la sorgente )
		new UniTestTreeMap().applayHeadSet_Sorted(UniTestTreeMap.createTest());

		// Unit test - restituisce una view navigabile in ordine crescente o decrescente
		// a partire
		// dalla testa della struttura:
		// con/senza l'elemento di check ( le operazioni di mutazione sulla view
		// modificano la sorgente )
		new UniTestTreeMap().applayHeadSet_Navigable(UniTestTreeMap.createTest());

		// Unit test - restituisce una view navigabile in ordine crescentea verso
		// la coda della struttura:
		// incluso l'elemento di check ( le operazioni di mutazione sulla view
		// modificano la sorgente )
		new UniTestTreeMap().applayTailSet_Sorted(UniTestTreeMap.createTest());

		// Unit test - restituisce una view navigabile in ordine crescente o decrescente
		// verso
		// dalla coda ordinata della struttura:
		// con/senza l'elemento di check ( le operazioni di mutazione sulla view
		// modificano la sorgente )
		new UniTestTreeMap().applayTailSet_Navigable(UniTestTreeMap.createTest());

		// Unit test - attraversa in modo crescente una struttura con l'ausilio di
		// un'interfaccia
		// Iteretor<E>
		new UniTestTreeMap().applayIterator(UniTestTreeMap.createTest());
		
		// Unit test - attraversa in modo decrescente una struttura ordinata con
		// l'ausilio di un'interfaccia
		// Iteretor<E>
		new UniTestTreeMap().applayDescendingIterator(UniTestTreeMap.createTest());
	} 
}