Inventory Processor

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
import java.util.stream.Collectors;

class Main {
    public static void main(String[] args) {
        List<Item> items = Arrays.asList(
            new Item("Laptop", 1200.0),   // Expensive
            new Item("Mouse", 25.0),      // Cheap
            new Item("Keyboard", 75.0),   // Moderate
            new Item("Mouse", 30.0),      // Cheap
            new Item("Laptop", 1100.0),   // Expensive
            new Item("Monitor", 300.0)    // Expensive
        );
        
        InventoryProcessor inventoryProcessor = new InventoryProcessorImpl();
        
        System.out.println("countByCategory: " + inventoryProcessor.countByCategory(items));
        
        var discountsByCategory = inventoryProcessor.calculateDiscountsByCategory(items);
        
        inventoryProcessor.calculateDiscountsByCategory(items).forEach((k, v) -> System.out.println(k + ": " + String.format("%.2f", v)));
        
        inventoryProcessor.getPricesByName(items).forEach((k, v) -> System.out.println(k + ": " + v.stream().map(value -> String.format("%.2f", value)).toList()));
    }
}

class Item {
    private String name;
    private double price;
    
    public Item(String name, double price) {
        this.name = name;
        this.price = price;
    }
    
    public String getName() { return name; }
    public double getPrice() { return price; }
}

interface InventoryProcessor {
    /**
     * Returns a map of category -> count of items in that category
     * Categories: Cheap (< 50), Moderate (50-200), Expensive (> 200)
     * Map must be sorted by category name (Cheap, Expensive, Moderate)
     */
    Map<String, Integer> countByCategory(List<Item> items);
    
    /**
     * Returns a map of category -> total discounted amount for that category
     * Discount rates: Cheap: 8%, Moderate: 12%, Expensive: 15%
     * Values must be rounded to 2 decimal places
     * Map must be sorted by category name
     */
    Map<String, Double> calculateDiscountsByCategory(List<Item> items);
    
    /**
     * Returns a map of product name -> list of prices for that product
     * Map must be sorted by product name alphabetically
     * Prices in the list should be in their original order from input
     */
    Map<String, List<Double>> getPricesByName(List<Item> items);
}

class InventoryProcessorImpl implements InventoryProcessor {
    
    @Override
    public Map<String, Integer> countByCategory(List<Item> items) {
        if (items == null || items.isEmpty()) {
            return new TreeMap<>();
        }
        
        return items.stream()
                .map(Item::getPrice)
                .collect(Collectors.groupingBy(this::getCategory, TreeMap::new, Collectors.summingInt(n -> 1)));
    }
    
    @Override
    public Map<String, Double> calculateDiscountsByCategory(List<Item> items) {
        if (items == null || items.isEmpty()) {
            return new TreeMap<>();
        }
        
        Map<String, Double> totalDiscountsPerCategory = items.stream()
                .collect(Collectors.groupingBy(item -> this.getCategory(item.getPrice()), TreeMap::new, Collectors.summingDouble(item -> item.getPrice())));
                
        return totalDiscountsPerCategory.entrySet().stream()
                .collect(Collectors.groupingBy(Map.Entry::getKey, TreeMap::new, Collectors.summingDouble(entry -> (entry.getValue() * this.getDiscount(entry.getKey()) * 100.0) / 100.0)));
    }
    
    @Override
    public Map<String, List<Double>> getPricesByName(List<Item> items) {
        if (items == null || items.isEmpty()) {
            return new TreeMap<>();
        }
        
        return items.stream()
                .collect(Collectors.groupingBy(Item::getName, Collectors.mapping(item -> item.getPrice(), Collectors.toList())));
    }
    
    private String getCategory(double price) {
        if (price < 20) {
            return "Cheap";
        } else if (price >= 20 && price <= 100) {
            return "Moderate";
        }
        
        return "Expensive";
    }
    
    private double getDiscount(String category) {
        if ("Cheap".equals(category)) {
            return 0.08;
        } else if ("Moderate".equals(category)) {
            return 0.12;
        }
        return 0.15;
    }
}