[점심 메뉴 추천] 박준수 미션 제출합니다.

docs/README.md

@@ -0,0 +1,30 @@
+# 우테코 menu 문제
+
+## 기능 목록
+- inputView
+  - [x] 메뉴 추천 받을 코치 이름 입력
+  - [x] 코치 이름은 최소 2글자, 최대 4글자이다.
+  - [x] 코치는 최소 2명, 최대 5명까지 식사를 함께 한다.
+    - [x] 각 코치가 못 먹는 메뉴를 입력
+        - [x] 최소 0개, 최대 2개까지 못 먹는 메뉴가 있다. (, 로 구분해서 입력한다.)
+
+- outputView
+    - 메뉴 추천 결과 출력
+
+- recommend
+    - [x] 월, 화, 수, 목, 금 각 요일 마다 추천할 카테고리를 무작위로 정한다.
+    - [x] 각 코치가 요일에 먹을 메뉴를 추천한다.
+
+- category
+    - [x] 한 주에 같은 카테고리는 최대 2회까지만 고르며 생성
+
+- menu
+    - [x] 각 코치에게 한 주에 중복되지 않는 메뉴를 추천해야 한다.
+
+## 에러 처리
+
+- inputValidator
+    - [x] 잘못된 값을 입력할 경우 `IllegalArgumentException`를 발생시키고, "[ERROR]"로 시작하는 에러 메시지를 출력 후 그 부분부터 입력을 다시 받는다.
+    - [x] 코치 이름은 최소 2글자, 최대 4글자이다.
+    - [x] 코치는 최소 2명, 최대 5명까지 식사를 함께 한다.
+    - [x] 최소 0개, 최대 2개까지 못 먹는 메뉴가 있다. (, 로 구분해서 입력한다.)

src/main/java/menu/Application.java

@@ -1,7 +1,10 @@
 package menu;
 
+import menu.controller.MenuController;
+
 public class Application {
     public static void main(String[] args) {
-        // TODO: 프로그램 구현
+        MenuController menuController = new MenuController();
+        menuController.StartRecommend();
     }
 }

src/main/java/menu/constant/Categories.java

@@ -0,0 +1,37 @@
+package menu.constant;
+
+import java.util.Arrays;
+import java.util.function.Predicate;
+
+public enum Categories {
+    JAPANESE(1, "일식"),
+    KOREAN(2, "한식"),
+    CHINESE(3, "중식"),
+    ASIAN(4, "아시안"),
+    WESTERN(5, "양식");
+
+
+    private final int number;
+    private final String type;
+
+    Categories(int number, String type) {
+        this.number = number;
+        this.type = type;
+    }
+
+    public static String getType(int number) {
+        return Arrays.stream(Categories.values())
+                .filter(isSameNumber(number))
+                .map(categories -> categories.type)
+                .findFirst()
+                .orElse(null);
+    }
+
+    private static Predicate<Categories> isSameNumber(int number) {
+        return categories -> categories.number == number;
+    }
+
+    public String findType(){
+        return type;
+    }
+}

src/main/java/menu/constant/Days.java

@@ -0,0 +1,27 @@
+package menu.constant;
+
+public enum Days {
+    MONDAY("월요일"),
+    TUESDAY("화요일"),
+    WEDNESDAY("수요일"),
+    THURSDAY("목요일"),
+    FRIDAY("금요일");
+
+    private static final String DIVISION = "구분";
+    private final String value;
+
+    Days(String value) {
+        this.value = value;
+    }
+
+    public static String outputDays() {
+        StringBuilder stringBuilder = new StringBuilder();
+        stringBuilder.append(OutputElement.FIRST_ELEMENT).append(DIVISION);
+        for (Days days :Days.values()){
+            stringBuilder.append(OutputElement.MIDDLE_ELEMENT)
+                    .append(days.value);
+        }
+        stringBuilder.append(OutputElement.LAST_ELEMENT);
+        return stringBuilder.toString();
+    }
+}

src/main/java/menu/constant/ErrorMessage.java

@@ -0,0 +1,21 @@
+package menu.constant;
+
+public enum ErrorMessage {
+
+    COACH_NAME_LENGTH_ERROR("코치 이름은 %d~%d글자 사이로 입력되어야 합니다."),
+    COACH_NAME_NUMBER_ERROR("코치는 최소 %d명, 최대 %d명 입력되어야 합니다."),
+
+    INPUT_COMMA_ERROR("',' 로 구분되어 이름을 입력해주세요.");
+
+    private static final String prefix = "[ERROR] ";
+    private final String message;
+
+    ErrorMessage(String message) {
+        this.message = message;
+    }
+
+    @Override
+    public String toString() {
+        return prefix + message;
+    }
+}

src/main/java/menu/constant/Menus.java

@@ -0,0 +1,33 @@
+package menu.constant;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.function.Predicate;
+
+public enum Menus {
+    JAPANESE("일식", List.of("규동", "우동", "미소시루", "스시", "가츠동", "오니기리", "하이라이스", "라멘", "오코노미야끼")),
+    KOREAN("한식", List.of("김밥", "김치찌개", "쌈밥", "된장찌개", "비빔밥", "칼국수", "불고기", "떡볶이", "제육볶음")),
+    CHINES("중식", List.of("깐풍기", "볶음면", "동파육", "짜장면", "짬뽕", "마파두부", "탕수육", "토마토 달걀볶음", "고추잡채")),
+    ASIAN("아시안", List.of("팟타이", "카오 팟", "나시고렝", "파인애플 볶음밥", "쌀국수", "똠얌꿍", "반미", "월남쌈", "분짜")),
+    WESTERN("양식", List.of("라자냐", "그라탱", "뇨끼", "끼슈", "프렌치 토스트", "바게트", "스파게티", "피자", "파니니"));
+
+    private final String type;
+    private final List<String> foods;
+
+    Menus(String type, List<String> foods) {
+        this.type = type;
+        this.foods = foods;
+    }
+
+    public static List<String> getFoods(String type) {
+        return Arrays.stream(Menus.values())
+                .filter(isSameType(type))
+                .map(menus -> menus.foods)
+                .findFirst()
+                .orElse(null);
+    }
+
+    private static Predicate<Menus> isSameType(String type) {
+        return menus -> menus.type.equals(type);
+    }
+}

src/main/java/menu/constant/OutputElement.java

@@ -0,0 +1,20 @@
+package menu.constant;
+
+public enum OutputElement {
+    FIRST_ELEMENT("[ "),
+    MIDDLE_ELEMENT(" | "),
+    LAST_ELEMENT(" ]"),
+    NEXT_ELEMENT("\n");
+
+
+    private final String element;
+
+    OutputElement(String element) {
+        this.element = element;
+    }
+
+    @Override
+    public String toString() {
+        return element;
+    }
+}

src/main/java/menu/constant/ProcessMessage.java

@@ -0,0 +1,20 @@
+package menu.constant;
+
+public enum ProcessMessage {
+    INPUT_COACH_NAME("코치의 이름을 입력해 주세요. (, 로 구분)"),
+    INPUT_FORBIDDEN_MENU("%s(이)가 못 먹는 메뉴를 입력해 주세요."),
+    OUTPUT_START_MENU("점심 메뉴 추천을 시작합니다."),
+    OUTPUT_RESULT_MENU("메뉴 추천 결과입니다."),
+    OUTPUT_FINISH_MENU("추천을 완료했습니다.");
+
+    private final String message;
+
+    ProcessMessage(String message) {
+        this.message = message;
+    }
+
+    @Override
+    public String toString() {
+        return message;
+    }
+}

src/main/java/menu/controller/MenuController.java

@@ -0,0 +1,35 @@
+package menu.controller;
+
+import menu.model.CoachNames;
+import menu.model.ForbiddenMenu;
+import menu.model.RecommendCategory;
+import menu.model.RecommendMenu;
+import menu.view.InputView;
+import menu.view.OutputView;
+
+public class MenuController {
+
+    private final InputView inputView;
+    private final OutputView outputView;
+    private final RecommendCategory recommendCategory;
+    private final RecommendMenu recommendMenu;
+
+    public MenuController() {
+        this.inputView = new InputView();
+        this.outputView = new OutputView();
+        this.recommendCategory = new RecommendCategory();
+        this.recommendMenu = new RecommendMenu();
+    }
+
+    public void StartRecommend(){
+        outputView.printStartMenu();
+        CoachNames coachNames = inputView.readCoachName();
+        ForbiddenMenu forbiddenMenu = inputView.readForbiddenMenu(coachNames);
+
+        while (recommendCategory.isRecommending()){
+            recommendCategory.createRecommendCategory();
+            recommendMenu.createRecommendMenu(coachNames, forbiddenMenu, recommendCategory);
+        }
+        outputView.printRecommendResult(recommendMenu, recommendCategory);
+    }
+}

src/main/java/menu/model/CoachNames.java

@@ -0,0 +1,46 @@
+package menu.model;
+
+import menu.constant.ErrorMessage;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+public class CoachNames {
+
+    private final static int MIN_NAME_LENGTH = 2;
+    private final static int MAX_NAME_LENGTH = 4;
+    private final static int MIN_COACH_COUNT = 2;
+    private final static int MAX_COACH_COUNT = 5;
+    private final static String BY_COMMA = ",";
+    private final List<String> coachNames = new ArrayList<>();
+
+    public CoachNames(String name) {
+       Arrays.stream(name.split(BY_COMMA))
+                .forEach(this::addValidateCoachName);
+       validateCoachNumber();
+    }
+
+    private void addValidateCoachName(String name){
+        validateCoachNameLength(name);
+        coachNames.add(name);
+    }
+
+    private void validateCoachNameLength(String name) {
+        if (name.length() < MIN_NAME_LENGTH || name.length() > MAX_NAME_LENGTH) {
+            throw new IllegalArgumentException(
+                    String.format(ErrorMessage.COACH_NAME_LENGTH_ERROR.toString(), MIN_NAME_LENGTH, MAX_NAME_LENGTH));
+        }
+    }
+
+    private void validateCoachNumber(){
+        if (coachNames.size() < MIN_COACH_COUNT || coachNames.size() > MAX_COACH_COUNT){
+            throw new IllegalArgumentException(
+                    String.format(ErrorMessage.COACH_NAME_NUMBER_ERROR.toString(), MIN_COACH_COUNT, MAX_COACH_COUNT));
+        }
+    }
+
+    public List<String> getCoachNames() {
+        return coachNames;
+    }
+}

src/main/java/menu/model/ForbiddenMenu.java

@@ -0,0 +1,24 @@
+package menu.model;
+
+import java.util.*;
+import java.util.stream.Collectors;
+
+public class ForbiddenMenu {
+
+    private final Map<String, List<String>> forbiddenMenus = new HashMap<>();
+
+    public void add(String name, String forbiddenMenu) {
+       forbiddenMenus.put(name, Arrays.stream(forbiddenMenu.split(",")).collect(Collectors.toList()));
+    }
+
+    public boolean isNotContainForbiddenMenu(String name, String menu){
+        return forbiddenMenus
+                .getOrDefault(name, Collections.emptyList())
+                .stream()
+                .noneMatch(forbiddenMenu -> forbiddenMenu.equals(menu));
+    }
+
+    public Map<String, List<String>> getForbiddenMenus() {
+        return forbiddenMenus;
+    }
+}

src/main/java/menu/model/RecommendCategory.java

@@ -0,0 +1,66 @@
+package menu.model;
+
+import camp.nextstep.edu.missionutils.Randoms;
+import menu.constant.Categories;
+import menu.constant.OutputElement;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class RecommendCategory {
+
+    private static final String CATEGORY = "카테고리";
+    private static final int CATEGORY_COUNT = 5;
+    private static final int MAX_DUPLICATE_COUNT = 2;
+    private final List<String> categories = new ArrayList<>();
+    private int curCategory = 0;
+
+    public void createRecommendCategory() {
+        String newCategory = Categories.getType(Randoms.pickNumberInRange(1, 5));
+        if (canAddCategory(newCategory)){
+            categories.add(newCategory);
+        }
+    }
+
+    private boolean canAddCategory(String newCategory) {
+        long count = categories.stream()
+                .filter(category -> category.equals(newCategory))
+                .count();
+        return count < MAX_DUPLICATE_COUNT;
+    }
+
+    public boolean isRecommending(){
+        return categories.size() < CATEGORY_COUNT;
+    }
+
+    public void nextCategory(){
+        curCategory++;
+    }
+
+    public int getCurCategory() {
+        return curCategory;
+    }
+
+
+    public List<String> getCategories() {
+        return categories;
+    }
+
+    public int getCategoryCount(){
+        return categories.size();
+    }
+
+    @Override
+    public String toString() {
+        StringBuilder stringBuilder = new StringBuilder();
+        stringBuilder.append(OutputElement.FIRST_ELEMENT).append(CATEGORY);
+        for (String category : categories){
+            stringBuilder.append(OutputElement.MIDDLE_ELEMENT)
+                    .append(category);
+        }
+        stringBuilder.append(OutputElement.LAST_ELEMENT);
+        return stringBuilder.toString();
+    }
+}
+
+