НП - Лаб 3-1 Пицерија

/*
Треба да се развие систем за електронска нарачка од пицерија. Менито на пицеријата се состои од следново:

Pizza:

Standard: 10$
Pepperoni: 12$
Vegetarian: 8$
Extra

Ketchup 3$
Coke 5$
За да го претставите менито, секоја ставка треба да имплементира interface Item која опишува една ставка од менито и ги дефинира следниве методи:

getPrice():int - ја дава цената за конкретната ставка
Следно, дефинирајте две класи ExtraItem и PizzaItem за да може да правите разлика меѓу пици и останатите работи во нарачката. И двете класи треба да имаат еден конструктор кој прима еден String аргумент.

ExtraItem(String type) - валидни вредности за type се { "Coke", "Ketchup" }
PizzaItem(String type) - валидни вредности за type се { Standard , Pepperoni , Vegetarian }
Ако за type се проследи некоја невалидна вредност (која ја нема на менито) треба да се фрли исклучок InvalidExtraTypeException, односно InvalidPizzaTypeException.

Последно имплементирајте ја класата Order. Таа треба да ги нуди следните функционалности:

Order() - креира нова празна нарачка
addItem(Item item, int count) - соодветната ставка се додава во нарачката (count означува колку примероци сакаме од дадената ставка). Aко count е поголем од 10 се фрла исклучок ItemOutOfStockException(item). Доколку во нарачката веќе ја има соодветната ставка Item тогаш истата се заменува со нова. Следниот код резултира со нарачка со една стандардна пица:

Order order = new Order(); order.addItem(new PizzaItem("Standard"), 2); order.addItem(new PizzaItem("Standard"), 1);

getPrice():int - ја враќа вкупната цена на нарачката

displayOrder() - ја печати содржината на нарачката со соодветни редни броеви пред секоја ставка, името, количината и збирна сума на ставката, како и вкупна сума за целата нарачка. За редниот број се резервирани 3 места порамнети во десно, за имињата на ставките се резервирани 15 места со порамнување од лево, за кардиналноста две места порамнети во десно и за цената на една ставка 5 места порамнети во десно. За "Total:" се резервирани 22 места со порамнување од лево и за вкупната цена 5 места порамнети во десно. Пример:
  1.Standard       x 2   20$
  2.Vegetarian     x 1    8$
  3.Coke           x 3   15$
Total:                   43$
Редоследот по кој се печатат ставките е оној по кој тие се внесувани во нарачката. Доколку некоја ставка се внесе повторно нејзиното место не се менува.

removeItem(int idx) - се отстранува нарачката со даден индекс (сите нарачки со поголеми индекси се поместуваат во лево). Доколку не постои нарачка со таков индекс треба да се фрли исклучок ArrayIndexOutOfBоundsException(idx)
lock() - ја заклучува нарачката. За да може нарачката да се заклучи треба истата да има барем една ставка, во спротивно фрлете исклучок EmptyOrderException.
Откако ќе се заклучи нарачката треба веќе да не може да се менува со методите removeItem, addItem. Повикот на овие методи резултира со исклучок од типот OrderLockedException.
*/
import java.util.*;

class Order{
    List<Item> items;
    List<Integer> kolicini;
    boolean locked;
    public Order() {
        items = new ArrayList<>();
        kolicini = new ArrayList<>();
        locked = false;
    }
    public void addItem(Item item, int count) throws ItemOutOfStockException, OrderLockedException {
        if(locked)
            throw new OrderLockedException();
        if(count > 10)
            throw new ItemOutOfStockException(item.toString());
        int idx = findIndex(item);
        if(idx == -1) {
            items.add(item);
            kolicini.add(count);
        }else {
            kolicini.set(idx, count);
        }
    }
    public int findIndex(Item i) {
        int idx = -1;
        for (Item item : items) {
            if(item.toString().equals(i.toString()))
                idx = items.indexOf(item);
        }
        return idx;
    }
    public int getPrice() {
        int suma = 0;
        for (Item item : items) {
            suma += item.getPrice() * kolicini.get(items.indexOf(item));
        }
        return suma;
    }
    public void displayOrder() {
        for (Item item : items) {
            String s="";
            int i = items.indexOf(item);
            int kolicina = kolicini.get(i);
            int total = kolicina * item.getPrice();
            String name = item.toString();
            s = String.format("%3d.%-15sx%2d%5d$", i+1, name, kolicina, total);
            System.out.println(s);
        }
        System.out.println(String.format("%-22s%5d$", "Total:", getPrice()));
    }
    public void removeItem(int idx) throws ArrayIndexOutOfBoundsException, OrderLockedException {
        if(locked)
            throw new OrderLockedException();
        if(idx < 0 || idx >= items.size())
            throw new ArrayIndexOutOfBoundsException(idx);
         items.remove(idx);
    }
    public void lock() throws EmptyOrder {
        if(items.size() == 0)
            throw new EmptyOrder();
        locked = true;
    }
}

interface Item{
    public int getPrice();
}

class PizzaItem implements Item{
    String type;
    public PizzaItem(String type) throws InvalidPizzaTypeException {
        if(type.equals("Standard") || type.equals("Pepperoni") || type.equals("Vegetarian"))
            this.type = type;
        else
            throw new InvalidPizzaTypeException();
    }

    @Override
    public int getPrice() {
        if(type.equals("Standard"))
            return 10;
        if(type.equals("Vegetarian"))
            return 8;
        return 12;
    }
    @Override
    public String toString() {
        return type;
    }
}
class ExtraItem implements Item{
    String type;
    public ExtraItem(String type) throws InvalidExtraTypeException {
        if(type.equals("Coke") || type.equals("Ketchup"))
            this.type = type;
        else
            throw new InvalidExtraTypeException();
    }
    @Override
    public int getPrice() {
        if(type.equals("Coke"))
            return 5;
        return 3;
    }
    @Override
    public String toString() {
        return type;
    }
}
class InvalidPizzaTypeException extends Exception{
    public InvalidPizzaTypeException() {
        super("Invalid pizza type");
    }
}
class InvalidExtraTypeException extends Exception{
    public InvalidExtraTypeException() {
        super("Invalid extra type");
    }
}
class ItemOutOfStockException extends Exception{
    public ItemOutOfStockException(String item) {
        super(item);
    }
}
class ArrayIndexOutOfBoundsException extends Exception{
    public ArrayIndexOutOfBoundsException(int idx) {
        super(idx + "");
    }
}
class EmptyOrder extends Exception{
    public EmptyOrder() {
        super("Empty Order");
    }
}
class OrderLockedException extends Exception {
    public OrderLockedException() {
        super("Order locked");
    }
}

public class PizzaOrderTest {

    public static void main(String[] args) {
        Scanner jin = new Scanner(System.in);
        int k = jin.nextInt();
        if (k == 0) { //test Item
            try {
                String type = jin.next();
                String name = jin.next();
                Item item = null;
                if (type.equals("Pizza")) item = new PizzaItem(name);
                else item = new ExtraItem(name);
                System.out.println(item.getPrice());
            } catch (Exception e) {
                System.out.println(e.getClass().getSimpleName());
            }
        }
        if (k == 1) { // test simple order
            Order order = new Order();
            while (true) {
                try {
                    String type = jin.next();
                    String name = jin.next();
                    Item item = null;
                    if (type.equals("Pizza")) item = new PizzaItem(name);
                    else item = new ExtraItem(name);
                    if (!jin.hasNextInt()) break;
                    order.addItem(item, jin.nextInt());
                } catch (Exception e) {
                    System.out.println(e.getClass().getSimpleName());
                }
            }
            jin.next();
            System.out.println(order.getPrice());
            order.displayOrder();
            while (true) {
                try {
                    String type = jin.next();
                    String name = jin.next();
                    Item item = null;
                    if (type.equals("Pizza")) item = new PizzaItem(name);
                    else item = new ExtraItem(name);
                    if (!jin.hasNextInt()) break;
                    order.addItem(item, jin.nextInt());
                } catch (Exception e) {
                    System.out.println(e.getClass().getSimpleName());
                }
            }
            System.out.println(order.getPrice());
            order.displayOrder();
        }
        if (k == 2) { // test order with removing
            Order order = new Order();
            while (true) {
                try {
                    String type = jin.next();
                    String name = jin.next();
                    Item item = null;
                    if (type.equals("Pizza")) item = new PizzaItem(name);
                    else item = new ExtraItem(name);
                    if (!jin.hasNextInt()) break;
                    order.addItem(item, jin.nextInt());
                } catch (Exception e) {
                    System.out.println(e.getClass().getSimpleName());
                }
            }
            jin.next();
            System.out.println(order.getPrice());
            order.displayOrder();
            while (jin.hasNextInt()) {
                try {
                    int idx = jin.nextInt();
                    order.removeItem(idx);
                } catch (Exception e) {
                    System.out.println(e.getClass().getSimpleName());
                }
            }
            System.out.println(order.getPrice());
            order.displayOrder();
        }
        if (k == 3) { //test locking & exceptions
            Order order = new Order();
            try {
                order.lock();
            } catch (Exception e) {
                System.out.println(e.getClass().getSimpleName());
            }
            try {
                order.addItem(new ExtraItem("Coke"), 1);
            } catch (Exception e) {
                System.out.println(e.getClass().getSimpleName());
            }
            try {
                order.lock();
            } catch (Exception e) {
                System.out.println(e.getClass().getSimpleName());
            }
            try {
                order.removeItem(0);
            } catch (Exception e) {
                System.out.println(e.getClass().getSimpleName());
            }
        }
    }

}