/*
 * Copyright (c) 2013 Oracle and/or its affiliates. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *   - Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *
 *   - Redistributions in binary form must reproduce the above copyright
 *     notice, this list of conditions and the following disclaimer in the
 *     documentation and/or other materials provided with the distribution.
 *
 *   - Neither the name of Oracle nor the names of its
 *     contributors may be used to endorse or promote products derived
 *     from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
 * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

/*
 * This source code is provided to illustrate the usage of a given feature
 * or technique and has been deliberately simplified. Additional steps
 * required for a production-quality application, such as security checks,
 * input validation and proper error handling, might not be present in
 * this sample code.
 */
package stream;

import stream.data.Customer;
import stream.data.Order;
import java.util.Map;
import java.util.function.Function;
import static java.util.stream.Collectors.toConcurrentMap;

public class Selection extends DemoHelper {

    /**
     * Mapping customer to its total order price, only customer whose total
     * order price is bigger than bigValue will be put into the map
     *
     * @param bigValue customer's total price low limit
     * @return a map which map customer to its order price
     */
    public static Map<Customer, Double> bigOrderCustomers(double bigValue) {
        Function<Customer, Double> orderTotal
                = c -> c.getOrders().stream().
                //map order to order price
                mapToDouble(Order::getTotal).
                //calculate total price
                sum();
        Map<Customer, Double> customersToBigOrder = customers.stream().
                //grouping customer to a Map which key is customer, value is
                //total order price
                collect(toConcurrentMap(Function.identity(),
                                orderTotal));
        customersToBigOrder.forEach((customer, totalAmount) -> {
            //Remove all customer whose total order amount is not greater than
            //bigValue
            if (totalAmount <= bigValue) {
                customersToBigOrder.remove(customer);
            }
        });
        return customersToBigOrder;
    }
}