Mini-challenge: Sales report với stream pipeline

record Sale(String region, String product, String customer, double amount, LocalDate date) { }

import java.time.LocalDate;
import java.util.*;
import java.util.stream.*;

public class SalesReport {

    public record Sale(String region, String product, String customer, double amount, LocalDate date) { }

    // Helper: generate fake data
    public static List<Sale> generate(int count) {
        String[] regions = {"VN", "US", "JP", "DE", "BR"};
        String[] products = {"Pen", "Book", "Laptop", "Phone", "Desk", "Chair"};
        Random rnd = new Random(42);
        LocalDate base = LocalDate.of(2025, 1, 1);

        return IntStream.range(0, count)
            .mapToObj(i -> new Sale(
                regions[rnd.nextInt(regions.length)],
                products[rnd.nextInt(products.length)],
                "user" + rnd.nextInt(1000),
                Math.round(rnd.nextDouble() * 1000 * 100.0) / 100.0,
                base.plusDays(rnd.nextInt(365))))
            .toList();
    }

    // TODO: implement 8 methods below

    public static double totalRevenue(List<Sale> sales) {
        return 0;
    }

    public static Map<String, Double> revenueByRegion(List<Sale> sales) {
        return Map.of();
    }

    public static Map<String, Long> orderCountByProduct(List<Sale> sales) {
        return Map.of();
    }

    public static Optional<Sale> topSale(List<Sale> sales) {
        return Optional.empty();
    }

    public static List<String> topNProducts(List<Sale> sales, int n) {
        return List.of();
    }

    public static Map<String, Map<String, Double>> revenueByRegionThenProduct(List<Sale> sales) {
        return Map.of();
    }

    public static double averageOrderInRegion(List<Sale> sales, String region) {
        return 0;
    }

    public static List<Sale> salesInLastNDays(List<Sale> sales, int days, LocalDate today) {
        return List.of();
    }

    public static void main(String[] args) {
        List<Sale> sales = generate(10_000);

        System.out.printf("Total revenue: %.2f%n", totalRevenue(sales));
        System.out.println("Revenue by region: " + revenueByRegion(sales));
        System.out.println("Order count by product: " + orderCountByProduct(sales));
        topSale(sales).ifPresent(s -> System.out.println("Top sale: " + s));
        System.out.println("Top 3 products: " + topNProducts(sales, 3));
        System.out.println("Revenue by region -> product (VN only): "
            + revenueByRegionThenProduct(sales).get("VN"));
        System.out.printf("VN average order: %.2f%n", averageOrderInRegion(sales, "VN"));
        System.out.println("Last 7 days count: "
            + salesInLastNDays(sales, 7, LocalDate.of(2025, 12, 31)).size());
    }
}

javac SalesReport.java
java SalesReport

public static double totalRevenue(List<Sale> sales) {
    return sales == null ? 0 : sales.stream().mapToDouble(Sale::amount).sum();
}

long t1 = System.nanoTime();
double r1 = sales.stream().mapToDouble(Sale::amount).sum();
long t2 = System.nanoTime();
double r2 = sales.parallelStream().mapToDouble(Sale::amount).sum();
long t3 = System.nanoTime();

System.out.printf("Sequential: %d us%n", (t2 - t1) / 1000);
System.out.printf("Parallel:   %d us%n", (t3 - t2) / 1000);

record Stats(long count, double sum, double min, double max) {
    double average() { return count == 0 ? 0 : sum / count; }
}

Collector<Sale, ?, Stats> statsCollector = Collectors.teeing(
    Collectors.summarizingDouble(Sale::amount),
    Collectors.counting(),
    (summary, count) -> new Stats(count, summary.getSum(), summary.getMin(), summary.getMax())
);

Stats stats = sales.stream().collect(statsCollector);

Map<String, Map<String, Double>> grid = revenueByRegionThenProduct(sales);
grid.forEach((region, byProduct) -> {
    System.out.println("== " + region + " ==");
    byProduct.entrySet().stream()
        .sorted(Map.Entry.<String, Double>comparingByValue().reversed())
        .forEach(e -> System.out.printf("  %-10s %,.2f%n", e.getKey(), e.getValue()));
});