import java.util.ArrayList;
import java.util.List;
import java.util.stream.DoubleStream;
import java.util.stream.Stream;
import java.util.Optional;
import java.util.function.BinaryOperator;

/**
 * {@link <a href=
 * "https://[Log in to view URL]"
 * target= "_blank"></a>}
 * 
 * @author itammb ( Italia Massimiliano Buscati )
 * @version JDK 1.15
 *
 */
class Main {
	private static class Product {
		private int id;
		private String name;
		private float price;

		@Override
		public String toString() {
			return "Product [id=" + id + ", name=" + name + ", price=" + price + "]";
		}

		private Product(int id, String name, float price) {
			this.id = id;
			this.name = name;
			this.price = price;
		}
	}

	private static class UniTest {
		/**
		 * @see Stream#count()
		 * @see Stream#mapToDouble(java.util.function.ToDoubleFunction)
		 * @see DoubleStream#sum()
		 *
		 */
		public void terminal_operation_reduce(List<Product> source) {
			// somma
			double sumPrice = source.stream().mapToDouble(p -> p.price).sum();
			System.out.println(sumPrice);

			// conteggio
			long count = source.stream().count();
			System.out.println(count);
		}

		/**
		 * @see Stream#max(java.util.Comparator)
		 * @see Stream#min(java.util.Comparator)
		 * @see Optional#get()
		 *
		 */
		public void terminal_operation_reduce_with_comparator(List<Product> source) {
			Product max = source.stream().max((p1, p2) -> p1.price > p2.price ? 1 : -1).get();
			System.out.println(max.price);

			Product min = source.stream().min((p1, p2) -> p1.price > p2.price ? 1 : -1).get();
			System.out.println(min.price);
		}

		/**
		 * @see Stream#map(java.util.function.Function)
		 * @see Stream#reduce(Object, BinaryOperator)
		 */
		public void terminal_operation_reduce_with_accumulator(List<Product> source) {
			float sumPrice = source.stream().map(p -> p.price).reduce(0.0f, Float::sum);
			System.out.println(sumPrice);

			// BinaryOperator (accumulatore :: due elementi :: un risultato parziale)

			// T result = identity;
			// for (T element : this stream)
			// result = accumulator.apply(result, element)
			// return result;

			sumPrice = source.stream().map(p -> p.price).reduce(0.0f, (x, y) -> x + y);
			System.out.println(sumPrice);
		}

		/**
		 * @see Stream#map(java.util.function.Function)
		 * @see Stream#reduce(Object, java.util.function.BiFunction, BinaryOperator)
		 */
		public void terminal_operation_reduce_with_combinator(List<Product> source) {
			// BiFunction (combinatore :: due risultati parziali :: un risultato parziale)
			float sumPrice = source.stream().map(p -> p.price).reduce(0.0f, (temp1, temp2) -> temp1 + temp2,
					Float::sum);
			System.out.println(sumPrice);
		}

		public static List<Product> createTest() {
			// elementi in serie
			return new ArrayList<Product>() {
				private static final long serialVersionUID = -69L;

				{
					add(new Product(1, "HP Laptop", 25000f));
					add(new Product(2, "Dell Laptop", 30000f));
					add(new Product(3, "Lenevo Laptop", 28000f));
					add(new Product(4, "Sony Laptop", 28000f));
					add(new Product(5, "Apple Laptop", 90000f));
				}
			};
		}
	}

	public static void main(String args[]) {
		// Unit test - riduzione tramite operazione terminale 'somma, conteggio'
		new UniTest().terminal_operation_reduce(UniTest.createTest());
		// Unit test - riduzione tranite comparatore e operazione terminale 'massimo,
		// minimo'
		new UniTest().terminal_operation_reduce_with_comparator(UniTest.createTest());
		// Unit test - riduzione tranite accumulatore 'somma'
		new UniTest().terminal_operation_reduce_with_accumulator(UniTest.createTest());
		// Unit test - riduzione tranite accumulatore/combinatore 'somma'
		new UniTest().terminal_operation_reduce_with_combinator(UniTest.createTest());
	}
}