🕹 Level 1. 로또 미션 코드 리뷰 정리

public class LottoNumber implements Comparable<LottoNumber> {
    public static final int MIN_LOTTO_NUMBER = 1;
    public static final int MAX_LOTTO_NUMBER = 45;
    private static final Pattern NUMBER_PATTERN = Pattern.compile("^[0-9]*$");

public class LottoTicket {
    public static final int LOTTO_TICKET_SIZE = 6;

import static lotto.domain.LottoNumber.MAX_LOTTO_NUMBER;
import static lotto.domain.LottoNumber.MIN_LOTTO_NUMBER;
import static lotto.domain.LottoTicket.LOTTO_TICKET_SIZE;
import static lotto.domain.Money.LOTTO_PRICE;

public class LottoTicketFactory {
    private static final int START_INDEX = 0;

    public static Prize getPrizeType(int matchCount, boolean isBonusBall) {
        if (isMatchCountEqualsPivot(matchCount) && isBonusBall) {
            return SECOND_PRIZE;
        }
        return Arrays.stream(values())
                .filter(s -> s.matchCount == matchCount)
                .findFirst()
                .orElse(NO_PRIZE);
    }

    private static boolean isMatchCountEqualsPivot(int matchCount) {
        return matchCount == BONUS_CHECK_PIVOT;
    }

    public static double calculatePrizeMoneySum(List<Prize> lottoResults, Money money) {
        Money moneySum = Money.ZERO;
        for (Prize prize : Prize.values()) {
            Money perPrizeMoneySum = prize.prizeMoney
                    .multiple(getCountByPrizeType(lottoResults, prize));
            moneySum = moneySum.plus(perPrizeMoneySum);
        }
        return moneySum.getRate(money);
    }

    public static int getCountByPrizeType(List<Prize> lottoResults, Prize prize) {
        return (int) lottoResults.stream()
                .filter(p -> p.equals(prize))
                .count();
    }

public class LottoResult {
    private final List<Prize> lottoResults;

    public LottoResult(List<Prize> lottoResults) {
        this.lottoResults = new ArrayList<>(lottoResults);
    }

    public double calculateProfitRate(Money money) {
        return Prize.calculatePrizeMoneySum(lottoResults, money);
    }

    public int getCountPerPrizeType(Prize prize) {
        return Prize.getCountByPrizeType(lottoResults,prize);
    }
}

    public Money getTotalProfit() {
        Money totalProfit = Money.ZERO;
        for (Prize prize : lottoResults) {
            totalProfit = totalProfit.plus(prize.getPrizeMoney());
        }
        return totalProfit;
    }

public Prize matchPrize(LottoTicket lottoTicket) {
    int matchCount = getMatchingCount(lottoTicket);
    boolean isBonusNumber = isContainBonusNumber(lottoTicket);
    return Prize.findPrize(matchCount, isBonusNumber);
}

private int getMatchingCount(LottoTicket lottoTicket) {
    return (int) lottoTicket.lottoTicket().stream()
            .filter(winningTicket.lottoTicket()::contains)
            .count();
}

private boolean isContainBonusNumber(LottoTicket lottoTicket) {
    return lottoTicket.lottoTicket()
            .stream()
            .anyMatch(lottoNumber -> lottoNumber.equals(bonusNumber));
}

public static Prize findPrize(int matchCount, boolean isBonusNumber) {
    if (isMatchCountEqualsPivot(matchCount) && isBonusNumber) {
        return SECOND_PRIZE;
    }

    return Arrays.stream(values())
            .filter(s -> s.matchCount == matchCount)
            .findFirst()
            .orElse(NO_PRIZE);
}

private static boolean isMatchCountEqualsPivot(int matchCount) {
    return matchCount == BONUS_CHECK_PIVOT;
}

public Money getPrizeMoney() {
    return prizeMoney;
}

public int getMatchCount() {
    return matchCount;
}

public class LottoCount {
    private final int manualCount;
    private final int autoCount;

    public LottoCount(int manualCount, int totalCount) {
        validateLottoCount(manualCount, totalCount);
        this.manualCount = manualCount;
        this.autoCount = totalCount - this.manualCount;
    }

    private void validateLottoCount(int manualCount, int totalCount) {
        if (manualCount > totalCount || manualCount < 0) {
            throw new IllegalArgumentException("[ERROR] 구매 가능한 로또 개수 범위가 아닙니다.");
        }
    }

    public int getManualCount() {
        return manualCount;
    }

    public int getAutoCount() {
        return autoCount;
    }
}

private LottoTickets buyLottoTickets(LottoCount lottoCount) {
    List<List<LottoNumber>> lottoNumbersGroup = new ArrayList<>();
    lottoNumbersGroup.addAll(createAllManualLottoTicket(lottoCount.getManualLottoCount()));
    lottoNumbersGroup.addAll(createAutoNumbers(lottoCount.getAutoLottoCount()));
    return new LottoTickets(lottoNumbersGroup);
}

private List<List<LottoNumber>> createAllManualLottoTicket(int manualLottoCount) {
    OutputView.printInputManualLottoNumbers();
    return IntStream.range(0, manualLottoCount)
            .mapToObj(i -> InputView.inputNumbers()
                    .stream()
                    .map(input -> LottoNumber.valueOf(ParseUtil.parseInt(input)))
                    .collect(Collectors.toList()))
            .collect(Collectors.toList());
}

public static LottoTicket auto() {
    return new LottoTicket(LottoNumbersFactory.generateAutoLottoNumbers());
}

public static LottoTicket manual(List<String> lottoNumberStrings) {
    return lottoNumberStrings.stream()
            .map(i -> LottoNumber.valueOf(ParseUtil.parseInt(i)))
            .collect(collectingAndThen(toList(), LottoTicket::new));
}

public static LottoTickets auto(int count) {
    return Stream.generate(LottoTicket::auto)
            .limit(count)
            .collect(collectingAndThen(toList(), LottoTickets::new));
}

private LottoTickets buyLottoTickets(LottoCount lottoCount) {
    LottoTickets lottoTickets = createManualLottoTickets(lottoCount.getManualCount());
    lottoTickets.combine(LottoTickets.auto(lottoCount.getAutoCount()));
    return lottoTickets;
}

private LottoTickets createManualLottoTickets(int manualCount) {
    OutputView.printInputManualLottoNumbers();
    return Stream.generate(() -> LottoTicket.manual(InputView.inputNumbers()))
                .limit(manualCount)
                .collect(collectingAndThen(toList(), LottoTickets::new));
}

private final List<LottoTicket> lottoTickets;

public LottoTickets(List<List<LottoNumber>> lottoNumbersGroup) {
    this.lottoTickets = new ArrayList<>(createLottoTickets(lottoNumbersGroup));
}

public List<LottoTicket> lottoTickets() {
    return Collections.unmodifiableList(lottoTickets);
}

private List<LottoTicket> createLottoTickets(List<List<LottoNumber>> lottoNumbersGroup) {
    return lottoNumbersGroup.stream()
            .map(LottoTicket::new)
            .collect(Collectors.toList());
}

public LottoResult checkPrizes(LottoTickets lottoTickets) {
    return lottoTickets.lottoTickets().stream()
            .map(this::matchPrize)
            .collect(collectingAndThen(toList(), LottoResult::new));
}

public Prize matchPrize(LottoTicket lottoTicket) {
    int matchCount = getMatchingCount(lottoTicket);
    boolean isBonusNumber = isContainBonusNumber(lottoTicket);
    return Prize.findPrize(matchCount, isBonusNumber);
}

private int getMatchingCount(LottoTicket lottoTicket) {
    return (int) lottoTicket.lottoTicket().stream()
                .filter(winningTicket.lottoTicket()::contains)
                .count();
}

    private boolean isContainBonusNumber(LottoTicket lottoTicket) {
    return lottoTicket.lottoTicket()
                .stream()
                .anyMatch(lottoNumber -> lottoNumber.equals(bonusNumber));
}