南昌航空大学面对向程序设计21207230-袁荣皓第二次blog作业

import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.*;
import java.util.regex.Pattern;

/**
 * 菜品类
 */
class Dish {
    String name = "";
    String price;
    boolean isSpecialtyDishes;
    boolean isVanished = false;

    public Dish() {
    }

    public Dish(String name, String price, boolean isSpecialtyDishes) {
        this.name = name;
        this.price = price;
        this.isSpecialtyDishes = isSpecialtyDishes;
    }

    /**
     * 获取菜品价格
     */
    int getPrice(int portion) {
        if (isVanished) {
            return 0;
        }
        int price;
        try {
            price = Integer.parseInt(this.price);
        } catch (Exception e) {
            return 0;
        }
        switch (portion) {
            // 小份
            case 1:
                return price;
            // 中份
            case 2:
                return (int) Math.round(price * 1.5);
            // 大份
            case 3:
                return price * 2;
            default:
                return 0;
        }
    }
}

/**
 * 订单记录类
 */
class Record {
    String id = "-99";
    Dish dish;
    int portion;
    int num;
    String isForOthers = "-99";
    String name;
    String isDelId = "-99";
    boolean isAbandonment = false;
    boolean isVanished = false;
    boolean isError = false;

    public Record() {
    }

    public Record(String isDelId) {
        this.isDelId = isDelId;
    }

    public Record(String id, Dish dish, String name, int portion, int num, String isForOthers) {
        this.id = id;
        this.dish = dish;
        this.name = name;
        this.portion = portion;
        this.num = num;
        this.isForOthers = isForOthers;
        this.isDelId = "-99";
    }

    /**
     * 获取订单的价格
     */
    int getPrice() {
        if (dish == null) {
            return 0;
        }
        return dish.getPrice(portion) * num;
    }
}

/**
 * 订单类
 */
class Order {
    List<Record> records = new ArrayList<>();

    /**
     * 获取订单的总价
     */
    int getTotalPrice() {
        int total;
        long temp = 0;
        for (Record record : records) {
            if (!record.isAbandonment && record.dish != null) {
                temp += record.getPrice();
            }
        }
        total = (int) temp;
        return total;
    }

    /**
     * 获取订单的总价
     */
    int getDiscountTotalPrice(LocalDateTime dateTime) {
        int total;
        long temp = 0;
        for (Record record : records) {
            if (!record.isAbandonment && record.dish != null) {
                if (record.dish.isSpecialtyDishes) {
                    temp += Math.round(record.getPrice() * Utils.getSpecialtyDiscount(dateTime));
                } else {
                    temp += Math.round(record.getPrice() * Utils.getDiscount(dateTime));
                }
            }
        }
        total = (int) temp;
        return total;
    }

    /**
     * 添加订单记录
     */
    void addRecord(String id, Dish dish, String name, int portion, int num, String isForOthers) {
        records.add(new Record(id, dish, name, portion, num, isForOthers));
    }

    void addRecord(String delId) {
        records.add(new Record(delId));
    }

    void addRecord(Record record) {
        records.add(record);
    }

    /**
     * 通过订单编号删除订单记录
     */
    boolean delRecordById(String id) {
        return findRecordById(id) != null;
    }

    /**
     * 通过订单编号查找订单记录
     */
    Record findRecordById(String id) {
        for (Record r : records) {
            if (id.equals(r.id)) {
                return r;
            }
        }
        return null;
    }
}

/**
 * 菜单类
 */
class Menu {
    List<Dish> dishes = new ArrayList<>();

    /**
     * 搜索菜品
     */
    Dish searchDish(String dishName) {
        Optional<Dish> result = dishes.stream()
                .filter(dish -> dish.name.equals(dishName))
                .findFirst();
        if (result.isPresent()) {
            try {
                Dish dish = result.get();
                Integer.parseInt(dish.price);
            } catch (Exception e) {
                return null;
            }
        }
        return result.orElse(null);
    }

    /**
     * 向菜单中添加菜品
     */
    void addDish(String dishName, String price, boolean isSpecialtyDishes) {
        dishes.add(new Dish(dishName, price, isSpecialtyDishes));
    }

    /**
     * 向菜单中添加菜品
     */
    void addDish(Dish dish) {
        dishes.add(dish);
    }
}

class Table {
    String id;
    Order order = new Order();
    String time;
    boolean isVanished = false;
}

class Utils {
    /**
     * 是否为营业时间
     */
    public static boolean isBusinessHours(LocalDateTime dateTime) {
        // 获取当前日期的星期数
        int dayOfWeek = dateTime.getDayOfWeek().getValue();
        // 获取当前日期的小时数
        int hour = dateTime.getHour();
        // 如果当前日期是1-5
        if (dayOfWeek >= 1 && dayOfWeek <= 5) {
            // 如果当前小时数大于等于10且小于14，或者当前小时数等于14且当前分钟数小于等于30
            if ((hour >= 10 && hour < 14) || (hour == 14 && dateTime.getMinute() <= 30)) {
                // 返回true
                return true;
            } else {
                // 否则，如果当前小时数大于等于17且小于20，或者当前小时数等于20且当前分钟数小于等于30
                return (hour >= 17 && hour < 20) || (hour == 20 && dateTime.getMinute() <= 30);
            }
        } else if (dayOfWeek == 6 || dayOfWeek == 7) {
            // 如果当前日期是6或7
            // 返回当前小时数大于等于9且小于21，或者当前小时数等于21且当前分钟数小于等于30
            return hour >= 9 && hour < 21 || (hour == 21 && dateTime.getMinute() <= 30);
        }
        // 否则，返回false
        return false;
    }

    /**
     * 获取特色菜折扣
     */
    public static double getSpecialtyDiscount(LocalDateTime dateTime) {
        // 获取星期数
        int dayOfWeek = dateTime.getDayOfWeek().getValue();
        // 判断是否在营业时间
        if (dayOfWeek >= 1 && dayOfWeek <= 5) {
            return 0.7;
        }
        // 不在营业时间，折扣为1
        return 1;
    }

    /**
     * 获取折扣
     */
    public static double getDiscount(LocalDateTime dateTime) {
        // 获取星期数
        int dayOfWeek = dateTime.getDayOfWeek().getValue();
        // 获取小时数
        int hour = dateTime.getHour();
        // 判断是否在营业时间
        if (dayOfWeek >= 1 && dayOfWeek <= 5) {
            // 判断是否在营业时间
            if ((hour >= 10 && hour < 14) || (hour == 14 && dateTime.getMinute() <= 30)) {
                // 在营业时间，折扣为0.6
                return 0.6;
            } else if ((hour >= 17 && hour < 20) || (hour == 20 && dateTime.getMinute() <= 30)) {
                // 在营业时间，折扣为0.8
                return 0.8;
            }
        }
        // 不在营业时间，折扣为1
        return 1;
    }
}

class Main {
    private static final Pattern NUMBER_PATTERN = Pattern.compile("^\\d+$");
    private static final Scanner INPUT = new Scanner(System.in);
    private static final Menu MENU = new Menu();
    private static final List<Table> TABLES = new ArrayList<>();

    public static Table findTable(String id) {
        for (Table t : TABLES) {
            if (id.equals(t.id)) {
                return t;
            }
        }
        return null;
    }

    public static void receiverData() {
        Table tempTable = null;
        String line;
        String[] tokens;
        while (true) {
            line = INPUT.nextLine().trim();
            tokens = line.split(" ");
            // 当行以 "table" 开头时，开始新的订单并记录餐桌和时间
            if ("end".equals(line) || line.startsWith("table")) {
                break;
            }
            // 当输入有两个令牌时，将新菜品添加到菜单中
            else if (tokens.length == 2) {
                String dishName = tokens[0];
                String price = tokens[1];
                Dish dish = MENU.searchDish(dishName);
                if (dish == null) {
                    MENU.addDish(dishName, price, false);
                } else {
                    dish.price = price;
                }
            }
            // 当输入有三个令牌时，将新菜品添加到菜单中
            else if (line.contains("T")) {
                String dishName = tokens[0];
                String price = tokens[1];
                MENU.addDish(dishName, price, true);
            } else {
                Dish dish = new Dish();
                dish.isVanished = true;
                MENU.addDish(dish);
            }
        }
        while (true) {
            tokens = line.split(" ");
            if ("end".equals(line)) {
                break;
            }

            // 当行以 "table" 开头时，开始新的订单并记录餐桌和时间
            if (line.startsWith("table")) {
                if (tempTable != null) {
                    TABLES.add(tempTable);
                }
                tempTable = new Table();
                // 获取餐桌号
                String tableNum = tokens[1];
                String dateStr = tokens[2];
                String timeStr = tokens[3];
                dateStr = formatDateString(dateStr);

                tempTable.id = tableNum;
                tempTable.time = dateStr + " " + timeStr;
            }

            // 当行包含 "delete" 时，记录需要删除的订单号
            else if (line.contains("delete")) {
                String delId = tokens[0];
                assert tempTable != null;
                tempTable.order.addRecord(delId);
                Record recordById = tempTable.order.findRecordById(delId);
                if (recordById != null) {
                    recordById.isAbandonment = true;
                }
            }
            // 当输入有两个令牌时，将新菜品添加到菜单中
            else if (tokens.length == 2 || tokens.length == 3) {
                assert tempTable != null;
                Record record = new Record();
                record.isVanished = true;
                tempTable.order.addRecord(record);
            }
            // 当输入有五个令牌时，向指定的餐桌添加一个为其他餐桌支付的记录
            else if (tokens.length >= 5) {
                try {
                    String tableNum = tokens[0];
                    String recordId = tokens[1];
                    String dishName = tokens[2];
                    int portion = Integer.parseInt(tokens[3]);
                    int num = Integer.parseInt(tokens[4]);

                    assert tempTable != null;
                    tempTable.order.addRecord(recordId, MENU.searchDish(dishName), dishName, portion, num, tableNum);
                } catch (Exception e) {
                    assert tempTable != null;
                    Record record = new Record();
                    record.isError = true;
                    tempTable.order.addRecord(record);
                }
            }

            // 当输入有四个令牌时，向当前餐桌的订单中添加记录
            else {
                String recordId = tokens[0];
                String dishName = tokens[1];
                int portion = Integer.parseInt(tokens[2]);
                int num = Integer.parseInt(tokens[3]);

                assert tempTable != null;
                tempTable.order.addRecord(recordId, MENU.searchDish(dishName), dishName, portion, num, "-99");
            }
            line = INPUT.nextLine().trim();
        }
        if (tempTable != null) {
            TABLES.add(tempTable);
        }
    }

    public static void verifyMenu() {
        List<Dish> dishes = MENU.dishes;
        for (Dish dish : dishes) {
            try {
                Integer.parseInt(dish.price);
            } catch (Exception e) {
                System.out.println("wrong format");
                continue;
            }
            if (dish.isVanished) {
                System.out.println("wrong format");
                continue;
            }
            if (Integer.parseInt(dish.price) > 300) {
                dish.isVanished = true;
                System.out.println(dish.name + " price out of range " + dish.price);
            }
        }
    }

    public static String formatDateString(String input) {
        String[] parts = input.split("/");
        if (parts.length < 3) {
            // 输入的字符串格式不正确
            throw new IllegalArgumentException("Input string is not a valid date format.");
        }

        // 月份部分
        if (parts[1].length() == 1) {
            parts[1] = "0" + parts[1];
        }

        // 日期部分
        if (parts[2].length() == 1) {
            parts[2] = "0" + parts[2];
        }

        // 重新拼接字符串
        return parts[0] + "/" + parts[1] + "/" + parts[2];
    }

    public static boolean isValidDateTime(String dateTimeString) {
        final DateFormat sdf = new SimpleDateFormat("yyyy/MM/dd HH/mm/ss");
        sdf.setLenient(false);
        try {
            // 解析日期字符串
            sdf.parse(dateTimeString);
            return true;
        } catch (ParseException e) {
            return false;
        }
    }

    public static void dealWithDelData() {
        Set<String> delSet = new HashSet<>();
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy/M/d HH/mm/ss");
        String start = "2022/1/1 00/00/00";
        String end = "2023/12/31 00/00/00";
        LocalDateTime startDateTime = LocalDateTime.parse(start, formatter);
        LocalDateTime endDateTime = LocalDateTime.parse(end, formatter);
        LocalDateTime dateTime;
        // 遍历所有餐桌的订单
        for (Table table : TABLES) {
            delSet.clear();
            String tableNum = table.id;
            String time = table.time;

            // 使用适当的格式解析日期和时间
            try {
                dateTime = LocalDateTime.parse(time, formatter);
            } catch (Exception e) {
                System.out.println("wrong format");
                table.isVanished = true;
                continue;
            }

            if (!(dateTime.isAfter(startDateTime) && dateTime.isBefore(endDateTime))) {
                System.out.println("not a valid time period");
                table.isVanished = true;
                continue;
            }
            if (!isValidDateTime(time)) {
                System.out.println(tableNum + " date error");
                table.isVanished = true;
                continue;
            }
            boolean matches = NUMBER_PATTERN.matcher(tableNum).matches();
            if (tableNum.startsWith("0") || !matches) {
                System.out.println("wrong format");
                table.isVanished = true;
                continue;
            }

            if (!Utils.isBusinessHours(dateTime)) {
                System.out.println("table " + tableNum + " out of opening hours");
                table.isVanished = true;
                continue;
            }

            System.out.println("table " + tableNum + ": ");
            Order order = table.order;
            int maxRecordId = -99;
            // 遍历订单中的每个记录
            for (Record record : order.records) {
                if (!"-99".equals(record.isDelId)) {
                    if (delSet.contains(record.id)) {
                        System.out.println("deduplication " + record.isDelId);
                        continue;
                    }
                    if (!order.delRecordById(record.isDelId)) {
                        System.out.println("delete error;");
                    }
                    delSet.add(record.id);
                    continue;
                }

                // 检查订单是否为其他餐桌支付
                if ("-99".equals(record.isForOthers)) {
                    if (record.isError || record.id.startsWith("0")) {
                        System.out.println("wrong format");
                        record.isAbandonment = true;
                        continue;
                    }
                    if (record.isVanished) {
                        System.out.println("invalid dish");
                        continue;
                    }
                    if (record.dish == null || record.dish.isVanished) {
                        System.out.println(record.name + " does not exist");
                        record.isAbandonment = true;
                        continue;
                    }
                    // 显示订单详情
                    if (record.num > 15) {
                        System.out.println(record.id + " num out of range " + record.num);
                        record.isAbandonment = true;
                        continue;
                    }
                    if (record.portion > 3) {
                        System.out.println(record.id + " portion out of range " + record.portion);
                        record.isAbandonment = true;
                        continue;
                    }
                    int tempId = Integer.parseInt(record.id);
                    if (tempId > maxRecordId) {
                        maxRecordId = tempId;
                    } else {
                        System.out.println("record serial number sequence error");
                        record.isAbandonment = true;
                        continue;
                    }
                    if (record.dish != null) {
                        System.out.println(record.id + " " + record.dish.name + " " + record.getPrice());
                    }
                } else {
                    if (findTable(record.isForOthers) == null) {
                        System.out.println("Table number ：" + record.isForOthers + " does not exist");
                        record.isAbandonment = true;
                    } else {  // 显示哪个餐桌为其他餐桌支付
                        System.out.println(record.id + " table " + tableNum + " pay for table " + record.isForOthers + " " + record.getPrice());
                    }
                }
            }

            // 如果在营业时间内，则应用折扣；否则，提示营业时间外
            if (!Utils.isBusinessHours(dateTime)) {
                System.out.println("table " + tableNum + " out of opening hours");
            }
        }
        // 遍历所有餐桌的订单
        for (Table table : TABLES) {
            if (!table.isVanished) {
                delSet.clear();
                String tableNum = table.id;
                String time = table.time;
                dateTime = LocalDateTime.parse(time, formatter);

                // 如果在营业时间内，则应用折扣；否则，提示营业时间外
                if (Utils.isBusinessHours(dateTime)) {
                    System.out.println("table " + tableNum + ": " + table.order.getTotalPrice() + " " + table.order.getDiscountTotalPrice(dateTime));
                }
            }
        }
    }

    public static void main(String[] args) {
        receiverData();
        verifyMenu();
        dealWithDelData();
    }
}