[🚀 사이클2 - 미션 (블랙잭 배팅)] 달수 미션 제출합니다.

src/main/java/blackjack/Application.java

@@ -1,10 +1,12 @@
 package blackjack;
 
+import blackjack.config.AppConfig;
 import blackjack.controller.BlackjackController;
 
 public class Application {
     public static void main(String[] args) {
-        BlackjackController blackjackController = new BlackjackController();
+        AppConfig config = new AppConfig();
+        BlackjackController blackjackController = config.blackjackController();
         blackjackController.run();
     }
 }

src/main/java/blackjack/config/AppConfig.java

@@ -0,0 +1,11 @@
+package blackjack.config;
+
+import blackjack.controller.BlackjackController;
+import blackjack.view.InputView;
+import blackjack.view.OutputView;
+
+public class AppConfig {
+    public BlackjackController blackjackController(){
+        return new BlackjackController(new InputView(), new OutputView());
+    }
+}

src/main/java/blackjack/controller/BlackjackController.java

@@ -1,85 +1,60 @@
 package blackjack.controller;
 
-import blackjack.domain.MatchResult;
-import blackjack.domain.Player;
+import blackjack.domain.BlackjackGame;
+import blackjack.domain.vo.GameResult;
 import blackjack.dto.DealResultDto;
 import blackjack.dto.GameResultDto;
-import blackjack.dto.PlayerHandDto;
-import blackjack.domain.BlackjackGame;
 import blackjack.util.Parser;
+import blackjack.view.InputView;
+import blackjack.view.OutputView;
 
+import java.math.BigDecimal;
 import java.util.Collections;
 import java.util.List;
-import java.util.Map;
 
 import static blackjack.util.Parser.splitDelimiter;
-import static blackjack.view.InputView.readPlayNames;
-import static blackjack.view.InputView.readYesOrNo;
-import static blackjack.view.OutputView.printCurrentPlayerHand;
-import static blackjack.view.OutputView.printDealResult;
-import static blackjack.view.OutputView.printDealerDrawMessage;
-import static blackjack.view.OutputView.printEmptyLine;
-import static blackjack.view.OutputView.printFinalResult;
-import static blackjack.view.OutputView.printGameResult;
 
 public class BlackjackController {
-    public void run() {
-        List<String> names = inputNames();
-        BlackjackGame blackjackGame = BlackjackGame.create(names, Collections::shuffle);
-
-        DealResultDto dealResultDto = deal(blackjackGame);
-        printDealResult(dealResultDto);
+    private final InputView inputView;
+    private final OutputView outputView;
 
-        playPlayerTurn(blackjackGame);
-        playDealerTurn(blackjackGame);
-
-        GameResultDto gameResultDto = blackjackGame.generateGameResult();
-        printGameResult(gameResultDto);
-
-        Map<Player, MatchResult> playerFinalResult = blackjackGame.getPlayerFinalResult();
-        Map<String, Long> dealerFinalResult = blackjackGame.getDealerFinalResult(playerFinalResult);
-        printFinalResult(playerFinalResult, dealerFinalResult);
+    public BlackjackController(InputView inputView, OutputView outputView) {
+        this.inputView = inputView;
+        this.outputView = outputView;
     }
 
-    private List<String> inputNames() {
-        String input = readPlayNames();
-        Parser.notEmpty(input);
-        return splitDelimiter(input);
-    }
+    public void run() {
+        List<String> names = inputNames();
+        outputView.printEmptyLine();
+        BlackjackGame game = BlackjackGame.create(names, Collections::shuffle);
 
-    private DealResultDto deal(BlackjackGame blackjackGame) {
-        blackjackGame.deal();
-        return DealResultDto.from(blackjackGame.getPlayers(), blackjackGame.getDealer());
-    }
+        game.betPlayers(name -> {
+            String amount = inputView.readBetAmount(name);
+            outputView.printEmptyLine();
+            return amount;
+        });
 
-    private void playPlayerTurn(BlackjackGame blackjackGame) {
-        for (int i = 0; i < blackjackGame.playerCount(); i++) {
-            playTurn(blackjackGame, i);
-        }
-    }
+        game.deal();
+        outputView.printDealResult(DealResultDto.from(game));
 
-    private void playTurn(BlackjackGame blackjackGame, int index) {
-        while (blackjackGame.canPlayerHit(index) && wantsToHit(blackjackGame, index)) {
-            hitAndPrintHand(blackjackGame, index);
-        }
-        printEmptyLine();
-    }
+        game.playPlayerTurns(
+                name -> Parser.parseDrawInput(inputView.readYesOrNo(name)).isHit(),
+                outputView::printPlayerHand
+        );
+        outputView.printEmptyLine();
 
-    private boolean wantsToHit(BlackjackGame blackjackGame, int index) {
-        String answer = readYesOrNo(blackjackGame.playerNameByIndex(index));
-        DrawCommand drawCommand = Parser.parseDrawInput(answer);
-        return drawCommand.isHit();
-    }
+        game.playDealerTurn();
+        outputView.printDealerDrawMessage();
+
+        outputView.printGameResult(GameResultDto.from(game));
 
-    private void hitAndPrintHand(BlackjackGame blackjackGame, int index){
-        PlayerHandDto playerHandDto = PlayerHandDto.from(blackjackGame.playerDraw(index));
-        printCurrentPlayerHand(playerHandDto);
+        List<GameResult> gameResults = game.calculatePlayerProfits();
+        BigDecimal dealerProfit = game.calculateDealerProfit(gameResults);
+        outputView.printFinalResult(gameResults, dealerProfit);
     }
 
-    private void playDealerTurn(BlackjackGame blackjackGame){
-        while (blackjackGame.canDealerHit()) {
-            printDealerDrawMessage();
-            blackjackGame.dealerDraw();
-        }
+    private List<String> inputNames() {
+        String input = inputView.readPlayNames();
+        return splitDelimiter(input);
     }
 }

src/main/java/blackjack/domain/Bet.java

@@ -0,0 +1,43 @@
+package blackjack.domain;
+
+import java.math.BigDecimal;
+import java.util.Objects;
+
+public class Bet {
+    private final BigDecimal amount;
+
+    private Bet(BigDecimal amount) {
+        validate(amount);
+        this.amount = amount;
+    }
+
+    private void validate(BigDecimal amount) {
+        Objects.requireNonNull(amount, "배팅 금액은 null일 수 없습니다.");
+        if (amount.compareTo(BigDecimal.ZERO) < 0) {
+            throw new IllegalArgumentException("배팅 금액은 음수가 나올 수 없습니다.");
+        }
+    }
+
+    public static Bet init(){
+        return new Bet(BigDecimal.ZERO);
+    }
+
+    public static Bet of(String amount){
+        return new Bet(new BigDecimal(amount));
+    }
+
+    public BigDecimal getAmount() {
+        return amount;
+    }
+
+    @Override
+    public final boolean equals(Object o) {
+        if (!(o instanceof Bet bet)) return false;
+        return Objects.equals(amount, bet.amount);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hashCode(amount);
+    }
+}

src/main/java/blackjack/domain/BetDecision.java

@@ -0,0 +1,6 @@
+package blackjack.domain;
+
+@FunctionalInterface
+public interface BetDecision {
+    String decideBet(String name);
+}

src/main/java/blackjack/domain/BlackjackGame.java

@@ -1,14 +1,16 @@
 package blackjack.domain;
 
-import blackjack.dto.GameResultDto;
+import blackjack.domain.participant.Dealer;
+import blackjack.domain.participant.Player;
+import blackjack.domain.vo.GameResult;
+import blackjack.domain.vo.Payoff;
 
-import java.util.LinkedHashMap;
+import java.math.BigDecimal;
+import java.util.ArrayList;
 import java.util.List;
-import java.util.Map;
 import java.util.Objects;
 import java.util.stream.Collectors;
 
-
 public class BlackjackGame {
     private final Dealer dealer;
     private final Players players;
@@ -40,52 +42,68 @@ private static Players generatePlayers(List<String> names) {
                 .collect(Collectors.collectingAndThen(Collectors.toList(), Players::of));
     }
 
-    public void deal() {
-        players.receiveCards(deck);
-        dealer.receiveCards(deck.drawSecondTimes());
-    }
-
-    public int playerCount() {
-        return players.count();
-    }
-
-    public boolean canPlayerHit(int index) {
-        return players.playerAt(index).canHit();
+    public void betPlayers(BetDecision decision) {
+        players.forEach(player -> {
+            String amount = decision.decideBet(player.getName());
+            player.placeBet(amount);
+        });
     }
 
-    public String playerNameByIndex(int index) {
-        return players.playerAt(index).name();
+    public void deal() {
+        players.forEach(
+                player -> {
+                    player.hit(deck.deal());
+                    player.hit(deck.deal());
+                });
+        dealer.hit(deck.deal());
+        dealer.hit(deck.deal());
     }
 
-    public Player playerDraw(int index) {
-        TrumpCard drawn = deck.draw();
-        players.playerAt(index).receiveCard(drawn);
-        return players.playerAt(index);
+    public void playPlayerTurns(HitDecision decision, TurnDisplay display) {
+        players.forEach(player -> {
+            playerTurn(player, decision, display);
+        });
     }
 
-    public boolean canDealerHit() {
-        return dealer.shouldHit();
+    private void playerTurn(Player player, HitDecision decision, TurnDisplay display) {
+        boolean playing = true;
+        while (player.canHit() && playing) {
+            playing = processHit(player, decision, display);
+        }
     }
 
-    public void dealerDraw() {
-        TrumpCard drawn = deck.draw();
-        dealer.receive(drawn);
+    private boolean processHit(Player player, HitDecision decision, TurnDisplay display) {
+        if (!decision.wantsHit(player.getName())) {
+            display.show(player.getName(), player.getCardNames());
+            return false;
+        }
+        player.hit(deck.deal());
+        display.show(player.getName(), player.getCardNames());
+        return true;
     }
 
-    public GameResultDto generateGameResult() {
-        return GameResultDto.from(players, dealer);
+    public void playDealerTurn() {
+        while (dealer.canHit()) {
+            dealer.hit(deck.deal());
+        }
     }
 
-    public Map<Player, MatchResult> getPlayerFinalResult() {
-        Map<Player, MatchResult> playerResult = new LinkedHashMap<>();
-        for (Player player : players.getPlayers()) {
-            playerResult.put(player, MatchResult.playerResult(player, dealer));
-        }
-        return playerResult;
+    public List<GameResult> calculatePlayerProfits(){
+        List<GameResult> results = new ArrayList<>();
+        players.forEach(player -> {
+            BigDecimal profit = Payoff.playerResult(player, dealer)
+                    .calculateProfit(player.getBet().getAmount());
+            results.add(GameResult.from(player.getName(), profit));
+                }
+        );
+        return results;
     }
 
-    public Map<String, Long> getDealerFinalResult(Map<Player, MatchResult> playerResult) {
-        return MatchResult.dealerResult(playerResult);
+    public BigDecimal calculateDealerProfit(List<GameResult> gameResults) {
+        return gameResults.stream()
+                .map(GameResult::profit)
+                .reduce(BigDecimal.ZERO, BigDecimal::add)
+                .negate();
     }
 
     public Players getPlayers() {