import java.util.Iterator;
import java.util.NavigableSet;
import java.util.Set;
import java.util.SortedSet;
import java.util.TreeSet;

/**
 * {@link <a href=
 * "https://[Log in to view URL]"
 * target= "_blank">Primitive TestTreeSet<E></a>}
 * 
 * @author itammb ( Italia Massimiliano Buscati )
 * @version JDK 1.15
 *
 */
class Main {
	private static class UniTestTreeSet {
		/**
		 * @see TreeSet#first()
		 * @see TreeSet#last()
		 * 
		 */
		public void applayHeadAndTail_Element(NavigableSet<Integer> buffer) {
			applayIterator(buffer);

			System.out.println(buffer.first());
			System.out.println(buffer.last());
		}

		/**
		 * @see TreeSet#lower(Object)
		 * @see TreeSet#higher(Object)
		 * 
		 */
		public void applayHigherAndLower_Element(NavigableSet<Integer> buffer) {
			applayIterator(buffer);

			System.out.println(buffer.higher(6)); // null
			System.out.println(buffer.higher(5));
			System.out.println(buffer.higher(1));
			System.out.println(buffer.higher(0)); // il minore

			System.out.println(buffer.lower(0)); // null
			System.out.println(buffer.lower(4));
			System.out.println(buffer.lower(6));
			System.out.println(buffer.lower(7));
		}

		/**
		 * @see TreeSet#floor(Object)
		 * @see TreeSet#ceiling(Object)
		 * 
		 */
		public void applayFloorAndCeiling_Element(NavigableSet<Integer> buffer) {
			applayIterator(buffer);

			System.out.println(buffer.floor(8)); // minore (possibile) o uguale
			System.out.println(buffer.floor(6)); // se stesso
			System.out.println(buffer.floor(1)); // se stesso
			System.out.println(buffer.floor(0)); // null

			System.out.println(buffer.ceiling(0)); // maggiore (possibile) o uguale
			System.out.println(buffer.ceiling(1)); // se stesso
			System.out.println(buffer.ceiling(6)); // se stesso
			System.out.println(buffer.ceiling(7)); // null
		}

		/**
		 * @see TreeSet#pollFirst()
		 * @see TreeSet#pollLast()
		 * 
		 */
		public void applayPoolHeadTail_Element(NavigableSet<Integer> buffer) {
			applayIterator(buffer);

			System.out.println(buffer.pollFirst());
			System.out.println(buffer.pollLast());

			applayIterator(buffer);
		}

		/**
		 * @see TreeSet#headSet(Object)
		 * @see SortedSet
		 * 
		 */
		public void applayHeadSet_Sorted(NavigableSet<Integer> buffer) {
			applayIterator(buffer);

			SortedSet<Integer> sorted = buffer.headSet(5);
			applayIterator(sorted);

			sorted = buffer.headSet(3);
			applayIterator(sorted);

			sorted.remove(1);
			applayIterator(buffer);
		}

		/**
		 * @see TreeSet#headSet(Object, boolean)
		 * @see NavigableSet
		 * 
		 */
		public void applayHeadSet_Navigable(NavigableSet<Integer> buffer) {
			applayIterator(buffer);

			NavigableSet<Integer> navigable = buffer.headSet(5, true);
			applayIterator(navigable);

			navigable = buffer.headSet(5, false);
			applayIterator(navigable);
			applayIterator(navigable.descendingSet());

			navigable.remove(1);
			applayIterator(buffer);
		}

		/**
		 * @see TreeSet#tailSet(Object)
		 * @see SortedSet
		 * 
		 */
		public void applayTailSet_Sorted(NavigableSet<Integer> buffer) {
			applayIterator(buffer);

			SortedSet<Integer> sorted = buffer.tailSet(5);
			applayIterator(sorted);

			sorted = buffer.tailSet(3);
			applayIterator(sorted);

			sorted.remove(3);
			applayIterator(buffer);
		}

		/**
		 * @see TreeSet#tailSet(Object, boolean)
		 * @see NavigableSet
		 * 
		 */
		public void applayTailSet_Navigable(NavigableSet<Integer> buffer) {
			applayIterator(buffer);

			NavigableSet<Integer> navigable = buffer.tailSet(5, true);
			applayIterator(navigable);

			navigable = buffer.tailSet(5, false);
			applayIterator(navigable);
			applayIterator(navigable.descendingSet());

			navigable.remove(6);
			applayIterator(buffer);
		}

		/**
		 * @see NavigableSet#descendingIterator()
		 * @see Iterator
		 * 
		 */
		public void applayDescendingIterator(NavigableSet<Integer> buffer) {
			if (buffer.isEmpty())
				System.out.print("[]");
			else
				for (Iterator<Integer> itr = buffer.descendingIterator(); itr.hasNext();)
					System.out.print("e=" + itr.next() + " ");

			System.out.println();
		}

		/**
		 * @see Set#iterator()
		 * @see Iterator
		 * 
		 */
		public void applayIterator(Set<Integer> buffer) {
			if (buffer.isEmpty())
				System.out.print("[]");
			else
				for (Iterator<Integer> itr = buffer.iterator(); itr.hasNext();)
					System.out.print("e=" + itr.next() + " ");

			System.out.println();
		}

		public static TreeSet<Integer> createTest() {
			// insieme ordinato di elementi NON duplicati
			return new TreeSet<Integer>() {
				private static final long serialVersionUID = -69L;

				{
					add((Integer) 1);
					add((Integer) 5);
					add((Integer) 3);
					add((Integer) 6);
					add((Integer) 4);
					add((Integer) 1);
					add((Integer) 2);
				}
			};
		}
	}

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

		// Unit test - restituisce elemento più piccolo/grande della struttura
		new UniTestTreeSet().applayHeadAndTail_Element(UniTestTreeSet.createTest());

		// Unit test - restituisce elemento contiguo inferiore/superiore
		new UniTestTreeSet().applayHigherAndLower_Element(UniTestTreeSet.createTest());

		// Unit test - restituisce elemento minore o uguale (floor) / maggiore o uguale
		// (ceiling)
		new UniTestTreeSet().applayFloorAndCeiling_Element(UniTestTreeSet.createTest());

		// Unit test - elimina un elemento in testa/coda e lo restituisce
		new UniTestTreeSet().applayPoolHeadTail_Element(UniTestTreeSet.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 UniTestTreeSet().applayHeadSet_Sorted(UniTestTreeSet.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 UniTestTreeSet().applayHeadSet_Navigable(UniTestTreeSet.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 UniTestTreeSet().applayTailSet_Sorted(UniTestTreeSet.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 UniTestTreeSet().applayTailSet_Navigable(UniTestTreeSet.createTest());

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