Step2

src/main/java/BowlingMain.java

@@ -1,8 +1,7 @@
 import domain.Player;
 import view.InputView;
-import view.OutputView;
 
-import static view.InputView.getScore;
+import static view.InputView.getPinNum;
 
 public class BowlingMain {
 
@@ -15,8 +14,11 @@ public static void main(String[] args) {
 
     private static void doGame(Player player) {
         try {
-            player.recordScore(getScore(player.getCurrentFrameNum()));
-            OutputView.printResult(player);
+            player.roll(getPinNum(player.getCurrentFrameNum()));
+            /*
+                FrameResults results = player.makeResults();
+                OutputView.printResult(results); 결과 객체를 넘겨야해
+            */
         } catch (IllegalArgumentException e) {
             InputView.printMessage(e.getMessage());
             doGame(player);

src/main/java/domain/Player.java

@@ -1,37 +1,25 @@
 package domain;
 
 import domain.frame.Frames;
-import domain.frame.result.FrameResults;
 
 public class Player {
     private PlayerName name;
     private Frames frames;
-    private FrameResults results;
 
     public Player(String name) throws IllegalArgumentException {
         this.name = new PlayerName(name);
         frames = new Frames();
-        results = new FrameResults();
     }
 
-    public String getName() {
-        return name.getName();
+    public void roll(int num) throws IllegalArgumentException {
+        frames.roll(num);
     }
 
     public boolean isFinish() {
         return frames.isFinish();
     }
 
-    public FrameResults recordScore(int score) {
-        results.addResult(frames.getCurrentFrameIdx(), frames.recordScore(score));
-        return results;
-    }
-
     public int getCurrentFrameNum() {
-        return frames.getCurrentFrameNum();
-    }
-
-    public FrameResults getResults() {
-        return results;
+        return frames.getFrameNum();
     }
 }

src/main/java/domain/frame/Frame.java

@@ -1,10 +1,59 @@
 package domain.frame;
 
-public interface Frame {
+public abstract class Frame {
+    public static final int REGULAR_COUNT = 2;
+    public final int frameNum;
+    private FrameScore score;
 
-    String addScore(int score) throws IllegalArgumentException;
+    public Frame(int frameNum) {
+        this.frameNum = frameNum;
+        score = new FrameScore(REGULAR_COUNT);
+    }
 
-    boolean isFinish();
+    public static Frame of(int frameNum) {
+        if (Frames.isLimit(frameNum)) {
+            return new LastFrame(frameNum);
+        }
+        return new NormalFrame(frameNum);
+    }
 
-    String convertScore(int score);
+    public Frame roll(int num) throws IllegalArgumentException {
+        return doRecord(score, num);
+    }
+
+    public void bonusRoll(int num) throws IllegalArgumentException {
+        if (score.isRegularFinish() && score.isBonusFinish()) {
+            score.roll(num);
+        }
+    }
+
+    public FrameScore getScore() throws RuntimeException {
+        return score.get();
+    }
+
+    public String getScoreMessage() {
+        return score.getScoreMessage();
+    }
+
+    abstract Frame doRecord(FrameScore score, int num) throws IllegalArgumentException;
+
+    public boolean isFinish() {
+        return doCheckFinish(score);
+    }
+
+    public boolean isBonusFinish() {
+        return score.isBonusFinish();
+    }
+
+    abstract boolean doCheckFinish(FrameScore score);
+
+    public abstract boolean isLast();
+
+    public int getFrameNum() {
+        return frameNum;
+    }
+
+    public boolean isDiffFrame(Frame ohterFrame) {
+        return this != ohterFrame;
+    }
 }

src/main/java/domain/frame/FrameScore.java

@@ -0,0 +1,86 @@
+package domain.frame;
+
+import domain.frame.status.FrameStatus;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static java.util.stream.Collectors.joining;
+
+public class FrameScore {
+    private FrameStatus status;
+    private List<Pin> pins = new ArrayList<>();
+    private int leftNumber;
+
+    public FrameScore(int leftNumber) {
+        status = FrameStatus.getInitStatus();
+        this.leftNumber = leftNumber;
+    }
+
+    public void roll(int num) throws IllegalArgumentException {
+        if (isOverRecordPin(num)) {
+            throw new IllegalArgumentException("한 프레임에 정규 투구 기록할 수 있는 개수는 " + Pin.MAX + "개 입니다.");
+        }
+        pins.add(new Pin(num));
+        leftNumber--;
+        if (!status.isFinish()) {
+            status = status.changeStatus(getSum(), leftNumber);
+        }
+    }
+
+    public boolean isOverRecordPin(int num) {
+        return !status.isFinish() && pins.size() != 0 && pins.get(0).isOverRecordPin(num);
+    }
+
+    public FrameScore get() {
+        if (!isBonusFinish()) {
+            // TODO : 예외처리 해줘야함(사용자정의 예외로 변경?)
+            throw new RuntimeException("완료되지않은 프레임의 점수는 조회할 수 없습니다.");
+        }
+        return this;
+    }
+
+    public int getScore() {
+        return getSum();
+    }
+
+    public String getScoreMessage() {
+        if (!isBeforeBonusRoll()) {
+            return status.convertScore(pins) + ScoreMessage.getMessage(ScoreMessage.MODIFIER) + makeBonusPinMessage();
+        }
+        return status.convertScore(pins);
+    }
+
+    private String makeBonusPinMessage() {
+        if (status.isStrike()) {
+            return pins.stream().filter(pin -> pins.indexOf(pin) >= Frame.REGULAR_COUNT - 1).map(pin -> ScoreMessage.convertMessage(pin.getNum())).collect(joining(ScoreMessage.getMessage(ScoreMessage.MODIFIER)));
+        }
+
+        return pins.stream().filter(pin -> pins.indexOf(pin) >= Frame.REGULAR_COUNT).map(pin -> ScoreMessage.convertMessage(pin.getNum())).collect(joining(ScoreMessage.getMessage(ScoreMessage.MODIFIER)));
+    }
+
+    private int getSum() {
+        return pins.stream().mapToInt(Pin::getNum).sum();
+    }
+
+    public boolean isRegularFinish() {
+        return status.isFinish();
+    }
+
+    public boolean isBonusFinish() {
+        return leftNumber == 0;
+    }
+
+    public void increaseLeftCount() {
+        if (status.isBonus()) {
+            leftNumber += 1;
+        }
+    }
+
+    public boolean isBeforeBonusRoll() {
+        if (!status.isBonus()) {
+            return true;
+        }
+        return status.isBonus() && status.isRightThrewNum(pins.size());
+    }
+}

src/main/java/domain/frame/Frames.java

@@ -1,52 +1,38 @@
 package domain.frame;
 
-import utils.FrameFactory;
-
 import java.util.ArrayList;
 import java.util.List;
 
 public class Frames {
-    public static final int LIMIT_NUM = 10;
-    private List<Frame> frames;
-    private int nextFrameIdx;
+    public static final int LIMIT = 10;
+    private List<Frame> frames = new ArrayList<>();
+    private Frame currentFrame;
 
     public Frames() {
-        frames = new ArrayList<>();
-        nextFrameIdx = 0;
+        currentFrame = Frame.of(1);
     }
 
-    public String recordScore(int score) {
-        Frame currentFrame = getCurrentFrame();
-        String convertedScore = currentFrame.addScore(score);
-        if (currentFrame.isFinish()) {
-            nextFrameIdx++;
+    public void roll(int num) throws IllegalArgumentException {
+        if (!frames.contains(currentFrame)) {
+            frames.add(currentFrame);
         }
-        return convertedScore;
-    }
 
-    public Frame getCurrentFrame() {
-        try {
-            return frames.get(nextFrameIdx);
-        } catch (IndexOutOfBoundsException e) {
-            int frameNum = nextFrameIdx + 1;
-            frames.add(FrameFactory.of(frameNum));
-            return frames.get(nextFrameIdx);
+        Frame frame = currentFrame.roll(num);
+        // 보너스 요청 자리
+        if (currentFrame.isDiffFrame(frame)) {
+            currentFrame = frame;
         }
     }
 
-    public int getCurrentFrameIdx() {
-        return nextFrameIdx;
-    }
-
-    public int getCurrentFrameNum() {
-        return nextFrameIdx + 1;
+    public static boolean isLimit(int frameNum) {
+        return frameNum == LIMIT;
     }
 
     public boolean isFinish() {
-        return frames.size() == LIMIT_NUM && frames.stream().allMatch(Frame::isFinish);
+        return currentFrame.isLast() && currentFrame.isFinish();
     }
 
-    public static boolean isLast(int frameNum) {
-        return frameNum == LIMIT_NUM;
+    public int getFrameNum() {
+        return currentFrame.getFrameNum();
     }
 }