[NP] Cake Shop

import java.io.*;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;
import java.util.Arrays;

abstract class Item {
    private String name;
    private int price;
    private ItemType itemType;

    public abstract ItemType getType();


    public Item(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getPrice() {
        return price;
    }

    public void setPrice(int price) {
        this.price = price;
    }

    @Override
    public String toString() {
        return name + " " + price;
    }
}

class Cake extends Item{

    public Cake(String name) {
        super(name);
    }

    @Override
    public ItemType getType() {
        return ItemType.CAKE;
    }
}

class Pie extends Item{
    public static int PRICE_INCREASE=50;

    @Override
    public ItemType getType() {
        return ItemType.PIE;
    }

    public Pie(String name) {
        super(name);
    }

    @Override
    public int getPrice(){

        return super.getPrice()+PRICE_INCREASE;
    }
}

enum ItemType {
    CAKE,
    PIE
}


class Order implements Comparable<Order> {
    private long id;
    private List<Item> items;

    public Order(long id) {
        this.id = id;
        this.items = new ArrayList<>();
    }

    public Order(long id,List<Item> items) {
        this.id = id;
        this.items = items;
    }

    public static Order createOrder(String line,int minItemsPerOrder) throws OrderNotValidException {
        String[] parts = line.split("\\s+");
        Long id = Long.parseLong(parts[0]);
        List<Item> items = new ArrayList<>();
        Arrays.stream(parts)
                .skip(1)
                .forEach(i -> {
                    if(!Character.isDigit(i.charAt(0))){
                        if(i.charAt(0)=='C')
                            items.add(new Cake(i));
                        else
                            items.add(new Pie(i));
                    }
                    else
                        items.get(items.size()-1).setPrice(Integer.parseInt(i));

                });
        if(items.size()<minItemsPerOrder)
            throw new OrderNotValidException(id);

        return new Order(id,items);

    }
    public int totalItems(){
        return (int)items.stream().count();
    }

    public int totalPriceCost(){
        return items.stream().mapToInt(i -> i.getPrice()).sum();
    }

    public int totalCakes(){
        return (int)items.stream()
                .filter(i -> i.getType()==ItemType.CAKE)
                .count();
    }

    public int totalPies(){
        return (int)items.stream()
                .filter(i -> i.getType()==ItemType.PIE)
                .count();
    }

//    @Override
//    public String toString() {
//        return String.format("%d %d",id,totalItems());
//    }

    @Override
    public String toString() {
        return String.format("%d %d %d %d %d",id,totalItems(),totalCakes(),totalPies(),totalPriceCost());
    }

    @Override
    public int compareTo(Order other) {
        return Integer.compare(this.totalPriceCost(),other.totalPriceCost());
    }


//    @Override
//    public int compareTo(Order other) {
////        return Integer.compare(this.totalItems(),other.totalItems());
//        return Comparator.comparing(Order::totalItems).compare(this,other);
//    }


}

class CakeShop {

    private int minItemsPerOrder;
    private List<Order> orders;

    public CakeShop(int minItemsPerOrder) {
        this.minItemsPerOrder = minItemsPerOrder;
        this.orders= new ArrayList<>();
    }


    public void readCakeOrders(InputStream in) {
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(in));
        this.orders= bufferedReader.lines()
                .map(i -> {
                    try {
                        return Order.createOrder(i,minItemsPerOrder);
                    } catch (OrderNotValidException e) {
                        System.out.println(e.getMessage());
                        return null;
                    }
                })
                .filter(Objects::nonNull)
                .collect(Collectors.toList());

    }
    public int totalNumberOfItems(){
        return this.orders.stream().mapToInt(i -> i.totalItems()).sum();
    }

//    public void printLongestOrder(PrintStream out) {
//        PrintWriter printWriter = new PrintWriter(out);
//
//        orders.stream().max(Comparator.naturalOrder()).ifPresent(printWriter::println);
//
//        printWriter.flush();
//    }

    public void printAllOrders(PrintStream out){
        PrintWriter printWriter = new PrintWriter(out);

        orders.stream().sorted(Comparator.reverseOrder()).forEach(i -> printWriter.println(i));

        printWriter.flush();
    }
}

public class CakeShopTest {

    public static void main(String[] args) {
        CakeShop cakeShop = new CakeShop(4);

        System.out.println("---READ FROM INPUT STRING---");
        cakeShop.readCakeOrders(System.in);

//        System.out.println("---PRINTING LARGEST ORDER TO OUTPUT STREAM---");
//        cakeShop.printLongestOrder(System.out);

        System.out.println("---PRINTING ALL ORDERS---");
        cakeShop.printAllOrders(System.out);
    }
}