[LBP] 김준 사다리 5단계 제출합니다.

src/main/java/LadderApplication.java

@@ -1,10 +1,14 @@
 import controller.LadderController;
 
 public class LadderApplication {
-    public static void main(String[] args) {
-        LadderController ladderController = LadderController.getInstance();
 
-        ladderController.run();
+    public static void main(String[] args) {
+        try {
+            LadderController ladderController = LadderController.getInstance();
+            ladderController.run();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
     }
 
 }

src/main/java/controller/LadderController.java

@@ -1,19 +1,23 @@
 package controller;
 
+import dto.LadderResultDto;
 import dto.LineDto;
-import model.Ladder;
-import model.Line;
+import model.*;
+import view.LadderInputView;
 import view.LadderOutputView;
 
+import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.List;
 
 public class LadderController {
-    private static final int DEFAULT_LADDER_HEIGHT = 4;
-    private static final int DEFAULT_LADDER_WIDTH = 4;
+
+    private static final String PRINT_EVERY_RESULT = "all";
 
     private static final LadderController ladderController = new LadderController();
 
-    private final LadderOutputView ladderOutputView = LadderOutputView.getInstance();
+    private static final LadderOutputView ladderOutputView = LadderOutputView.getInstance();
+    private static final LadderInputView ladderInputView = LadderInputView.getInstance();
 
     private LadderController() {
     }
@@ -23,14 +27,82 @@ public static LadderController getInstance() {
     }
 
     public void run() {
-        Ladder ladder = new Ladder(DEFAULT_LADDER_WIDTH, DEFAULT_LADDER_HEIGHT);
-        List<Line> lines = ladder.getLines();
+        LadderUsers ladderUsers = getLadderUsers();
+        String[] resultValues = ladderInputView.getResultValues();
+        int height = ladderInputView.getHeight();
+
+        Ladder ladder = new Ladder(ladderUsers.size(), height);
+        LadderResultCalculator ladderResultCalculator = new LadderResultCalculator(ladderUsers, resultValues);
+        printLadderShape(ladder, ladderUsers, resultValues);
+
+        printLadderResultUntilPrintEveryResult(ladder, ladderResultCalculator, ladderUsers);
+    }
+
+    private LadderUsers getLadderUsers() {
+        String[] names = ladderInputView.getNames();
+
+        List<LadderUser> ladderUsers = Arrays.stream(names)
+                .map(LadderUser::new)
+                .toList();
 
-        ladderOutputView.printResultHeader();
+        return new LadderUsers(ladderUsers);
+    }
+
+    private void printLadderShape(Ladder ladder, LadderUsers ladderUsers, String[] resultValues) {
+        ladderOutputView.printLadderResultHeader();
+        ladderOutputView.printNames(ladderUsers.getNames());
+
+        List<Line> lines = ladder.getLines();
         for (Line line : lines) {
             LineDto lineDto = LineDto.from(line);
             ladderOutputView.printLine(lineDto);
         }
+
+        ladderOutputView.printResultValues(resultValues);
+    }
+
+    private void printLadderResultUntilPrintEveryResult(
+            Ladder ladder,
+            LadderResultCalculator ladderResultCalculator,
+            LadderUsers ladderUsers
+    ) {
+        String targetName = ladderInputView.getTargetName();
+
+        while (shouldPrintSingleResult(targetName)) {
+            printSingleLadderResult(targetName, ladder, ladderResultCalculator);
+            targetName = ladderInputView.getTargetName();
+        }
+
+        printEveryLadderResult(ladder, ladderResultCalculator, ladderUsers);
+    }
+
+    private boolean shouldPrintSingleResult(String targetName) {
+        return !targetName.equals(PRINT_EVERY_RESULT);
+    }
+
+    private void printSingleLadderResult(
+            String targetName,
+            Ladder ladder,
+            LadderResultCalculator ladderResultCalculator
+    ) {
+        String result = ladderResultCalculator.calculate(targetName, ladder);
+
+        ladderOutputView.printLadderResult(result);
+    }
+
+    private void printEveryLadderResult(
+            Ladder ladder,
+            LadderResultCalculator ladderResultCalculator,
+            LadderUsers ladderUsers
+    ) {
+        List<LadderResultDto> ladderResultDtos = new ArrayList<>();
+
+        for (String name : ladderUsers.getNames()) {
+            String result = ladderResultCalculator.calculate(name, ladder);
+            ladderResultDtos.add(new LadderResultDto(name, result));
+        }
+
+        ladderOutputView.printLadderResults(ladderResultDtos);
     }
 
 }

src/main/java/dto/LadderResultDto.java

@@ -0,0 +1,4 @@
+package dto;
+
+public record LadderResultDto(String name, String resultValue) {
+}

src/main/java/dto/LineDto.java

@@ -1,12 +1,13 @@
 package dto;
 
 import model.Line;
-import model.Link;
-import model.LinkStatus;
 
 import java.util.List;
 
+import static model.LinkStatus.PRESENT;
+
 public class LineDto {
+
     private final List<Boolean> linkExistCollection;
 
     private LineDto(List<Boolean> linkExistCollection) {
@@ -15,15 +16,14 @@ private LineDto(List<Boolean> linkExistCollection) {
 
     public static LineDto from(Line line) {
         List<Boolean> linkExistCollection = line.getLinks().stream()
-                .map(Link::getLinkstatus)
-                .map(LinkStatus::isPresent)
+                .map(link -> link.getLinkstatus() == PRESENT)
                 .toList();
 
         return new LineDto(linkExistCollection);
     }
 
     public List<Boolean> getLinkExistCollection() {
-        return List.copyOf(linkExistCollection);
+        return linkExistCollection;
     }
 
 }

src/main/java/model/DetachedRandomLinksGenerator.java

@@ -0,0 +1,98 @@
+package model;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Random;
+
+import static model.LinkStatus.PRESENT;
+
+public class DetachedRandomLinksGenerator implements LinksGenerator {
+
+    private static final Random random = new Random();
+
+    private final int linksSize;
+
+    public DetachedRandomLinksGenerator(int linksSize) {
+        this.linksSize = linksSize;
+    }
+
+    public List<Link> generate() {
+        List<Link> links = getUndefinedLinks(linksSize);
+        resolveUndefinedLinks(links);
+
+        return Collections.unmodifiableList(links);
+    }
+
+    private List<Link> getUndefinedLinks(int linksSize) {
+        List<Link> links = new ArrayList<>();
+        for (int i = 0; i < linksSize; i++) {
+            links.add(Link.getUndefinedLink());
+        }
+
+        return links;
+    }
+
+    private void resolveUndefinedLinks(List<Link> links) {
+        int index = getRandomStartIndex(links);
+
+        while (containsUndefined(links)) {
+            boolean connectDecider = getConnectDecider();
+            boolean connectable = isConnectable(index, links);
+
+            links.set(index, Link.getDefinedLink(connectDecider, connectable));
+
+            index = getNextIndex(index, links);
+        }
+    }
+
+    private int getRandomStartIndex(List<Link> links) {
+        return random.nextInt(links.size());
+    }
+
+    private boolean containsUndefined(List<Link> links) {
+        return links.stream()
+                .anyMatch(Link::isUndefined);
+    }
+
+    private boolean getConnectDecider() {
+        return random.nextBoolean();
+    }
+
+    private boolean isConnectable(int index, List<Link> links) {
+        return isLeftNotPresent(index, links) && isRightNotPresent(index, links);
+    }
+
+    private boolean isLeftNotPresent(int index, List<Link> links) {
+        if (isFirstIndex(index)) {
+            return true;
+        }
+
+        Link leftLink = links.get(index - 1);
+
+        return leftLink.getLinkstatus() != PRESENT;
+    }
+
+    private boolean isRightNotPresent(int index, List<Link> links) {
+        if (isLastIndex(index, links)) {
+            return true;
+        }
+
+        Link rightLink = links.get(index + 1);
+
+        return rightLink.getLinkstatus() != PRESENT;
+    }
+
+    private boolean isFirstIndex(int index) {
+        return index == 0;
+    }
+
+    private boolean isLastIndex(int index, List<Link> links) {
+        return index == links.size() - 1;
+    }
+
+    private int getNextIndex(int index, List<Link> linkStatuses) {
+        return (index + 1) % linkStatuses.size();
+    }
+
+}

src/main/java/model/Ladder.java

@@ -5,19 +5,52 @@
 import java.util.List;
 
 public class Ladder {
+
+    private static final int MINIMUM_WIDTH = 2;
+    private static final int MINIMUM_HEIGHT = 1;
+
     private final List<Line> lines;
 
     public Ladder(int width, int height) {
+        validateSize(width, height);
+
+        this.lines = createLines(width, height);
+    }
+
+    public List<Line> getLines() {
+        return lines;
+    }
+
+    public int getEndPoint(int startPoint) {
+        int point = startPoint;
+
+        for (Line line : lines) {
+            point = line.getNextPoint(point);
+        }
+
+        return point;
+    }
+
+    private List<Line> createLines(int width, int height) {
+        int linksSize = width - 1;
+        DetachedRandomLinksGenerator linksGenerator = new DetachedRandomLinksGenerator(linksSize);
+
         List<Line> lines = new ArrayList<>();
         for (int i = 0; i < height; i++) {
-            lines.add(new Line(width));
+            Line line = new Line(linksGenerator);
+            lines.add(line);
         }
 
-        this.lines = Collections.unmodifiableList(lines);
+        return Collections.unmodifiableList(lines);
     }
 
-    public List<Line> getLines() {
-        return lines;
+    private void validateSize(int width, int height) {
+        if (width < MINIMUM_WIDTH) {
+            throw new IllegalArgumentException("사다리의 너비는 " + MINIMUM_WIDTH + "보다 짧을 수 없습니다. 전달된 값: " + width);
+        }
+        if (height < MINIMUM_HEIGHT) {
+            throw new IllegalArgumentException("사다리의 높이는 " + MINIMUM_HEIGHT + "보다 짧을 수 없습니다. 전달된 값: " + height);
+        }
     }
 
 }

src/main/java/model/LadderResultCalculator.java

@@ -0,0 +1,37 @@
+package model;
+
+import java.util.Arrays;
+import java.util.List;
+
+public class LadderResultCalculator {
+
+    private final LadderUsers ladderUsers;
+    private final List<String> resultValues;
+
+    public LadderResultCalculator(LadderUsers ladderUsers, String[] resultValues) {
+        validateSize(ladderUsers, resultValues);
+
+        this.ladderUsers = ladderUsers;
+        this.resultValues = Arrays.stream(resultValues)
+                .toList();
+    }
+
+    public String calculate(String name, Ladder ladder) {
+        int index = ladderUsers.findIndexOfUserByName(name)
+                .orElseThrow(() -> new IllegalArgumentException("존재하지 않는 이름입니다."));
+        int endPoint = ladder.getEndPoint(index);
+
+        return findResultByIndex(endPoint);
+    }
+
+    private void validateSize(LadderUsers ladderUsers, String[] resultValues) {
+        if (ladderUsers.size() != resultValues.length) {
+            throw new IllegalArgumentException("참여자의 수와 실행 결과의 수가 일치하지 않습니다.");
+        }
+    }
+
+    private String findResultByIndex(int index) {
+        return resultValues.get(index);
+    }
+
+}