/**
 * Copyright (c) 2018 Araf Karsh Hamid

 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.

 * This program and the accompanying materials are dual-licensed under
 * either the terms of the Eclipse Public License v1.0 as published by
 * the Eclipse Foundation

 *   or (per the licensee's choosing)

 * under the terms of the Apache 2 License version 2.0
 * as published by the Apache Software Foundation.
 */
package java08.lambda;

import java.util.Arrays;
import java.util.IntSummaryStatistics;
import java.util.List;
import java.util.function.Predicate;

/**
 * Java 8 Examples
 * 
 * Lambda & Streams
 *
 * @author: Araf Karsh Hamid
 * @version:
 * @date:
 */
public class LambdaExample {

	private static List<Integer> intArray = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 13, 27, 32, 98, 113);
	private static List<String> languages = Arrays.asList( "Haskell", "Lisp", "Python", "Java", "Scala", "C", "C++", "C#", 
															"Perl", "Ruby", "Fortran", "Visual-Basic", "Pascal", "Basic",
															"JavaScript", "VBScript", "Ada", "JRuby", "Jython"); 
	
	public static void main(String[] args) {
		 
			System.out.println("== LAMBDA Expressions Examples ==================\n");
			lambdaExamples();

			System.out.println("\n\n== LAMBDA Expressions (FILTERS) Examples ========");
			lambdaExamples2();
			
			System.out.println("\n\n== Streams (Map & Reduce) Examples =============");
	        map();
	        mapReduce();
	        mapReduce2();
	        
			System.out.println("\n\n== LAMBDA Expressions Combining Conditions Examples ===");
			lambdaExamples3();

			System.out.println("\n\n== Streams (Statistics) Examples =============\n");
			streamAggregates();
	    }
		
		public static void lambdaExamples() {
	        System.out.print("Print ALL Numbers: \t");
	        functionReference(intArray, (n)->true);
	 
	        System.out.print("\nPrint NO Numbers: \t");
	        functionReference(intArray, (n)->false);
	 
	        System.out.print("\nPrint EVEN Numbers: \t");
	        functionReference(intArray, (n)-> n%2 == 0 );
	 
	        System.out.print("\nPrint ODD Numbers: \t");
	        functionReference(intArray, (n)-> n%2 == 1 );
	 
	        System.out.print("\nPrint Numbers > 5: \t");
	        functionReference(intArray, (n)-> n > 5 );			
		}

	    public static void functionReference(List<Integer> iArray, Predicate<Integer> predicate) {
	        for(Integer n: iArray)  {
	            if(predicate.test(n)) {
	                System.out.print(n + " ");
	            }
	        }
	    }
	    
		public static void lambdaExamples2() {

			System.out.print("\nLanguages which STARTS with J: \t"); 
			filter(languages, (str)->str.startsWith("J")); 
			System.out.print("\nLanguages which ENDS with a: \t"); 
			filter(languages, (str)->str.endsWith("a")); 
			System.out.print("\nPrint ALL languages: \t\t"); 
			filter(languages, (str)->true); 
			System.out.print("\nPrint NO languag: \t"); 
			filter(languages, (str)->false); 
			System.out.print("\nPrint language - LENGTH > 4: \t"); 
			filter(languages, (str)->str.length() > 4);
			System.out.print("\nPrint language - LENGTH = 4: \t"); 
			filter(languages, (str)->str.length() == 4);
			System.out.print("\nPrint language - LENGTH < 4: \t"); 
			filter(languages, (str)->str.length() < 4);
		}
		
	    
	    public static void filter(List<String> names, Predicate<String> condition) { 
		    	// OLD Way
		    	/**
		    	for(String name: names) { 
		    		if(condition.test(name)) { 
		    			System.out.print(name + " "); 
		    		} 
		    	} 
		    	*/
		    	// NEW Way
		    	names.stream()
		    		.filter((name) -> (condition.test(name)))
		    		.forEach((name) -> { System.out.print(name + " "); });	
	    }
	    
		public static void lambdaExamples3() {

			System.out.print("\nLanguages which STARTS with J and Length == 4: \t"); 
			filter2(languages, (str)->str.startsWith("J"), (str)->str.length() == 4);
		}
		
	    /**
	     * Predicate allows you to combine two or more Predicate into one. It provides 
	     * methods similar to logical operator AND and OR named as and(), or() and xor(), 
	     * which can be used to combine the condition you are passing to filter() method. 
	     * For example, In order to get all languages, which starts with J and are four 
	     * character long, you can define two separate Predicate instance covering each 
	     * condition and then combine them using Predicate.and() method, as shown in 
	     * below example:
	     */
	    
	    public static void filter2(List<String> names, Predicate<String> condition1, Predicate<String> condition2) {
		    	names.stream() 
		    		.filter(condition1.and(condition2))
		    		.forEach((n) -> System.out.print(n + " "));
	    }
	    
	    public static void map() {
		    	//Old way:
		    	System.out.print("\nSquaring Elements in an Integer Array OLD Way: ");
		    	for(Integer n : intArray) {
		    	    int x = n * n;
		    	    System.out.print(x);
		    	}
		    	 
		    	//New way:
		    	System.out.print("\nSquaring Elements in an Integer Array NEW Way: ");
		    	intArray.stream().map((x) -> x*x).forEach(System.out::print);
	    }
	 
	    public static void mapReduce() {
		    	//Old way:
		    	int sum1 = 0;
		    	for(Integer n : intArray) {
		    	    int x = n * n;
		    	    sum1 = sum1 + x;
		    	}
		    	System.out.print("\n\nSquare and Sum OLD Way = "+sum1);
		    	 
		    	//New way:
		    	int sum2 = intArray.stream().map(x -> x*x).reduce((x,y) -> x + y).get();
		    	System.out.print("\nSquare and Sum NEW Way = "+sum2);
	    }
	    
	    public static void mapReduce2() {
		    	// Applying 12.7% VAT on each purchase 
		    	// Old way: 
		    	double vat = 0.127;
		    	double surcharge = 0.10;
		    	List<Integer> costBeforeTax = Arrays.asList(100, 200, 300, 400, 500, 600, 700, 800, 900); 
		    	double total = 0; 
		    	for (Integer cost : costBeforeTax) { 
		    		double price = cost + (vat * cost); 
		    		total = total + price; 
		    	} 
		    	total = total + (total * surcharge);
		    	System.out.print("\n\nTotal 12.7% VAT + 10.0% Surcharge OLD way = " + total); 
		    	
		    	// New way: 
		    	double costAfterTax = costBeforeTax.stream().map((c) -> c + (vat * c)).reduce((s, c) -> s + c).get(); 
		    	costAfterTax = costAfterTax + (costAfterTax * surcharge);
		    	System.out.println("\nTotal 12.7% VAT + 10.0% Surcharge NEW way = " + costAfterTax);
	    }

	    /**
	     * Calculating Maximum, Minimum, Sum and Average of List elements
	     * 
	     * There is a very useful method called summaryStattics() in stream classes like 
	     * IntStream, LongStream and DoubleStream. Which returns returns an IntSummaryStatistics, 
	     * LongSummaryStatistics or DoubleSummaryStatistics describing various summary data about 
	     * the elements of this stream. In following example, we have used this method to calculate 
	     * maximum and minimum number in a List. It also has getSum() and getAverage() which can 
	     * give sum and average of all numbers from List.
	     */
	    public static void streamAggregates() {
		    	//Get count, min, max, sum, and average for numbers 
		    	
		    	List<Integer> primes = Arrays.asList(3, 5, 7, 11, 13, 17, 19, 23, 29,
		    			 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 709, 1051, 2503, 3877); 
		    	
		    	IntSummaryStatistics stats = primes.stream().mapToInt((x) -> x).summaryStatistics(); 
		    	
		    	System.out.println("Highest PRIME number in List = " + stats.getMax()); 
		    	System.out.println("Lowest PRIME number in List  = " + stats.getMin()); 
		    	System.out.println("Sum of ALL PRIME numbers     = " + stats.getSum()); 
		    	System.out.println("Average of ALL PRIME numbers = " + stats.getAverage());
	    }
}