Mini-challenge: Sales report với stream pipeline

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) { }

    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(); // Tra ve immutable list
    }

    public static double totalRevenue(List<Sale> sales) {
        // Toi uu: dung primitive DoubleStream de tranh boxing Double
        return sales.stream().mapToDouble(Sale::amount).sum();
    }

    public static Map<String, Double> revenueByRegion(List<Sale> sales) {
        // Toi uu: dung summingDouble de tranh gom nhom boxed
        return sales.stream()
            .collect(Collectors.groupingBy(
                Sale::region,
                Collectors.summingDouble(Sale::amount)));
    }

    public static Map<String, Long> orderCountByProduct(List<Sale> sales) {
        return sales.stream()
            .collect(Collectors.groupingBy(Sale::product, Collectors.counting()));
    }

    public static Optional<Sale> topSale(List<Sale> sales) {
        return sales.stream().max(Comparator.comparingDouble(Sale::amount));
    }

    public static List<String> topNProducts(List<Sale> sales, int n) {
        return sales.stream()
            .collect(Collectors.groupingBy(Sale::product, Collectors.summingDouble(Sale::amount)))
            .entrySet().stream()
            .sorted(Map.Entry.<String, Double>comparingByValue().reversed())
            .limit(n)
            .map(Map.Entry::getKey)
            .toList(); // Bao toan tinh bat bien cua ket qua
    }

    public static Map<String, Map<String, Double>> revenueByRegionThenProduct(List<Sale> sales) {
        return sales.stream()
            .collect(Collectors.groupingBy(
                Sale::region,
                Collectors.groupingBy(
                    Sale::product,
                    Collectors.summingDouble(Sale::amount))));
    }

    public static double averageOrderInRegion(List<Sale> sales, String region) {
        return sales.stream()
            .filter(s -> s.region().equals(region))
            .mapToDouble(Sale::amount)
            .average()
            .orElse(0);
    }

    public static List<Sale> salesInLastNDays(List<Sale> sales, int days, LocalDate today) {
        LocalDate cutoff = today.minusDays(days);
        return sales.stream()
            .filter(s -> !s.date().isBefore(cutoff) && !s.date().isAfter(today))
            .toList(); // Tra ve immutable list
    }

    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());
    }
}