[НП] лаб3.1 Пицерија

/*Исклучоци и File I/O (3)
Пицерија Problem 1 (0 / 0)
Треба да се развие систем за електронска нарачка од пицерија. Менито на пицеријата се состои од следново:

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.

Sample input
0 Extra Ketchup

Sample output
3
*/


import java.util.Scanner;

interface Item {
    public int getPrice();
    public  String getType();
}

class InvalidExtraTypeException extends Exception {}

class InvalidPizzaTypeException extends Exception {}

class ItemOutOfStockException extends Exception {
    public ItemOutOfStockException(Item item){
        super(String.format("%s out of stock!", item));
    }
}

class OrderLockedException extends Exception {}

class EmptyOrder extends Exception {
    public EmptyOrder(){
        super("EmptyOrder");
    }
}


class ExtraItem implements Item {
    private String type;

    public ExtraItem(String type) throws InvalidExtraTypeException {
        if (type.equals("Coke") || type.equals("Ketchup"))
            this.type = type;
        else throw new InvalidExtraTypeException();
    }

    @Override
    public String getType() {
        return type;
    }

    @Override
    public int getPrice() {
        if (type.equals("Coke"))
            return 5;
        return 3;
    }
}

class PizzaItem implements Item {
    private 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 String getType() {
        return type;
    }

    @Override
    public int getPrice() {
        if (type.equals("Standard"))
            return 10;
        if (type.equals("Pepperoni"))
            return 12;
        return 8;
    }
}

class Order {
    private Item[] items;
    private int[] counts;
    private boolean isLocked;

    public Order() {
        items = new Item[0];
        counts = new int[0];
        isLocked = false;
    }

    public void addItem(Item item, int count) throws ItemOutOfStockException, OrderLockedException{
        if (isLocked)
            throw new OrderLockedException();
        if (count > 10)
            throw new ItemOutOfStockException(item);
        if (alreadyInOrder(item) == -1){
            Item[] tmpI = new Item[items.length+1];
            int[] tmpC = new int[counts.length+1];
            for (int i=0; i<items.length; i++){
                tmpC[i] = counts[i];
                tmpI[i] = items[i];
            }
            tmpI[items.length] = item;
            tmpC[items.length] = count;
            items = tmpI;
            counts = tmpC;
        }
        else {
            int index = alreadyInOrder(item);
            counts[index] = count;
        }

    }

    public int alreadyInOrder(Item item){
        // ako vekje postoi vo narackata, vrati go indeksot, inaku vrati -1

        for (int i=0; i<items.length; i++) {
            if (items[i].getType().equals(item.getType()))
                return i;
        }
        return -1;
    }

    public int getPrice(){
        int sum = 0;
        for (int i=0; i<items.length; i++) {
            sum += getPriceEach(i);
        }
        return sum;
    }

    public int getPriceEach(int index){
        return items[index].getPrice() * counts[index];
    }

    public void displayOrder(){
        StringBuilder sb = new StringBuilder();
        for (int i=0; i<items.length; i++){
            sb.append(String.format("%3d.%-15sx%2d%5d$\n", i+1,items[i].getType(),counts[i],getPriceEach(i)));
        }
        sb.append(String.format("%-22s%5d$","Total:",getPrice()));
        System.out.println(sb.toString());
    }

    public void removeItem(int idx) throws ArrayIndexOutOfBoundsException, OrderLockedException{
        if (isLocked)
            throw new OrderLockedException();
        if (idx < 0 || idx >= counts.length)
            throw new ArrayIndexOutOfBoundsException(idx);
        Item[] tmpI = new Item[items.length-1];
        int[] tmpC = new int[counts.length-1];
        for (int i=0; i<idx; i++){
            tmpI[i] = items[i];
            tmpC[i] = counts[i];
        }
        for (int i=idx; i<items.length-1; i++){
            tmpI[i] = items[i+1];
            tmpC[i] = counts[i+1];
        }
        items = tmpI;
        counts = tmpC;
    }

    public void lock() throws EmptyOrder{
        if (items.length != 0)
            isLocked = true;
        else throw new EmptyOrder();
    }
}



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

}