diff --git a/README.md b/README.md
index 15bb106b5..ef91dae48 100644
--- a/README.md
+++ b/README.md
@@ -1 +1,156 @@
 # javascript-lotto-precourse
+
+# 🔆 프로젝트 큰 흐름
+
+1. `InputView`를 통해 로또 구입 금액 문자열을 입력 받는다.
+   1. `PurchaseAmount` 모델을 생성하며 `PurchaseAmountValidator`를 통해 유효성 검사를 실행한다.
+   2. 유효성 검사에 실패하면 `[ERROR]` 메시지를 출력하고 해당 지점부터 다시 입력을 받는다.
+2. `LottoStore` 모델을 통해 `PurchaseAmount`만큼 로또(`Lotto` 인스턴스)를 구매한다.
+   1. `Random.pickUniqueNumbersInRange`를 사용해 로또 번호를 생성한다.
+3. `OutputView`를 통해 구매한 로또 개수와 번호 목록을 출력한다.
+4. `InputView`를 통해 당첨 번호 문자열을 입력 받는다.
+   1. `WinningLottoValidator`로 문자열 포맷(쉼표, 공백 등)을 검사한다.
+   2. `Lotto` 모델을 생성하며 `LottoValidator`로 6개의 번호에 대한 유효성(개수, 중복, 범위)을 검사한다.
+   3. 유효성 검사에 실패하면 `[ERROR]` 메시지를 출력하고 다시 입력을 받는다.
+5. `InputView`를 통해 보너스 번호 문자열을 입력 받는다.
+   1. `WinningLotto` 모델을 생성하며 `WinningLottoValidator`로 보너스 번호의 유효성(범위, 당첨 번호와 중복 여부)을 검사한다.
+   2. 유효성 검사에 실패하면 `[ERROR]` 메시지를 출력하고 다시 입력을 받는다.
+6. `LottoResult` 모델을 생성자에 구매한 로또 배열과 `WinningLotto`를 전달하여 생성한다.
+   1. `LottoResult`는 내부적으로 모든 로또를 `WinningLotto`와 비교하여 당첨 통계를 계산한다.
+   2. 당첨 통계를 바탕으로 총 수익률을 계산한다.
+7. `OutputView`를 통해 당첨 통계 헤더 문구를 출력한다.
+8. `OutputView`를 통해 등수별 당첨 개수와 수익률을 포맷에 맞게 출력한다.
+
+# 📁 프로젝트 구조
+
+```src
+├── App.js                  # 애플리케이션 실행 로직 (run)
+├── index.js                # App 인스턴스 생성 및 실행
+│
+├── controllers/
+│ └── LottoGameController.js  # Controller (메인 로직, 입출력 흐름 제어)
+│
+├── constants/              # Constants (상수 관리)
+│ ├── config.js             ## 로또 가격, 번호 범위, 당첨 랭킹 등
+│ └── messages.js           ## 입출력 및 에러 메시지
+│
+├── domain/                 # Model (핵심 로직 및 데이터 관리)
+│ ├── PurchaseAmount.js     ## 구입 금액 (1000원 단위 검증, 로또 개수 계산)
+│ ├── Lotto.js              ## 로또 1장 (번호 6개, 유효성 검증)
+│ ├── WinningLotto.js       ## 당첨 번호 (메인 6 + 보너스 1, 보너스 번호 검증)
+│ ├── LottoStore.js         ## 로또 생성 및 발급 (랜덤 번호 생성)
+│ └── LottoResult.js        ## 당첨 통계 및 수익률 계산
+│
+├── utils/                  # Utilities (보조 도구)
+│ └── Utils.js              ## 문자열 분리, 숫자 포매팅
+│
+├── validate/               # Validator (유효성 검증 로직)
+│ ├── Validator.js          ## 공통 검증 (빈 값, 양의 정수, 숫자 범위, 중복)
+│ ├── MoneyValidator.js     ## 금액 관련 검증 (1000원 단위, 최대 크기)
+│ ├── PurchaseAmountValidator.js ## 구입 금액 검증 조합
+│ ├── LottoValidator.js     ## 로또 번호 6개 배열 검증 (개수, 중복, 범위)
+│ └── WinningLottoValidator.js ## 당첨/보너스 번호 검증 (문자열 포맷, 중복)
+│
+├── view/                   # View (입출력 담당)
+│ ├── InputView.js          ## 사용자 입력 (readLineAsync)
+│ └── OuputView.js          ## 결과 출력 (print)
+│
+__tests__/                  # Test
+  ├── ApplicationTest.js    ## 기능 테스트 (통합)
+  ├── LottoTest.js          ## Lotto 클래스 단위 테스트
+  ├── PurchaseAmountTest.js ## PurchaseAmount 클래스 단위 테스트
+  ├── WinningLottoTest.js   ## WinningLotto 클래스 단위 테스트
+```
+
+# ✅ 구현할 기능 목록
+
+### [공통]
+
+- [x] `App.js`의 `run()` 메서드를 구현하여 프로그램 전체 흐름 제어
+- [x] `LottoGameController.js`의 `play()` 메서드에서 메인 로직 흐름 관리
+- [x] `constants` 폴더에 모든 입력/출력/에러 메시지와 설정을 정의
+- [x] 유효성 검사 실패 시 `[ERROR]`가 포함된 메시지를 출력하고 해당 입력부터 다시 받도록 구현
+
+### [View]
+
+- [x] `InputView`: 구입 금액을 입력 받는 기능 구현
+- [x] `InputView`: 당첨 번호를 입력 받는 기능 구현
+- [x] `InputView`: 보너스 번호를 입력 받는 기능 구현
+- [x] `OutputView`: 구매한 로또 개수와 번호 목록을 출력하는 기능 구현
+- [x] `OutputView`: 당첨 통계 헤더("당첨 통계\n---")를 출력하는 기능 구현
+- [x] `OutputView`: 각 등수별 당첨 결과를 포맷에 맞게 출력하는 기능 구현
+- [x] `OutputView`: 총 수익률을 소수점 둘째 자리에서 반올림하여 출력하는 기능 구현
+
+### [Validator]
+
+- [x] `Validator`: 입력값이 비어있지 않은지 검증
+- [x] `Validator`: 값이 양의 정수인지 검증
+- [x] `Validator`: 값이 1~45 사이의 숫자인지 검증
+- [x] `Validator`: 배열 내 중복된 숫자가 있는지 검증
+- [x] `MoneyValidator`: 구입 금액이 1,000원 단위인지 검증
+- [x] `MoneyValidator`: 구입 금액이 `Number.MAX_SAFE_INTEGER`를 넘지 않는지 검증
+- [x] `WinningLottoValidator`: 당첨 번호 문자열에 구분자(`,`)가 포함되어 있는지 검증
+- [x] `WinningLottoValidator`: 당첨 번호 문자열이 구분자(`,`)로 시작하거나 끝나지 않는지 검증
+- [x] `LottoValidator`: 로또 번호가 6개인지 검증
+- [x] `WinningLottoValidator`: 보너스 번호가 당첨 번호 6개와 중복되지 않는지 검증
+
+### [Model]
+
+- [x] **PurchaseAmount class**: 구입 금액을 관리
+- [x] **Lotto class**: 로또 1장의 정보를 가짐 (번호 6개)
+  - [x] `property`: `#numbers` (오름차순 정렬)
+  - [x] `method`: `getNumbers()`
+- [x] **WinningLotto class**: 당첨 번호와 보너스 번호를 가짐
+  - [x] `method`: `compare(lottoNumbers)` (로또 1장과 비교하여 {일치 개수, 보너스 일치 여부} 반환)
+- [x] **LottoStore class**: 로또를 발급
+  - [x] `method`: `buyLottos(purchaseAmount)` (구입 금액만큼 로또 생성)
+- [x] **LottoResult class**: 당첨 결과를 계산하고 통계를 가짐
+  - [x] `method`: `#calculateStats(...)` (모든 로또의 당첨 등수 계산)
+  - [x] `method`: `#calculateProfit(...)` (총 투자 대비 수익률 계산)
+  - [x] `method`: `getMatchCntInfo()`, `getProfitRate()`
+
+### [Utils]
+
+- [x] `Utils.js`: `splitBySeparator` (문자열을 구분자로 나누어 배열 반환)
+- [x] `Utils.js`: `formatNumber` (숫자를 1,000 단위 쉼표가 있는 문자열로 변환)
+- [x] `@woowacourse/mission-utils`: `Random.pickUniqueNumbersInRange`를 사용해 랜덤 번호 생성
+- [x] `@woowacourse/mission-utils`: `Console.readLineAsync`와 `Console.print`로 입출력 처리
+
+# ‼️ 예외 처리 고려 사항
+
+### 0. 공통
+
+- 값이 비어있지 않은지 검증
+  - [x] 값이 비어있다면 ERROR
+- 값이 올바른 양의 정수 숫자 형식인지 검증
+  - [x] 값이 양의 정수가 아니라면 ERROR
+- 값이 올바른 로또 번호 형식인지 검증
+  - [x] 값이 1부터 45 사이가 아니라면 ERROR
+  - [x] 기존 로또 번호와 중복이라면 ERROR
+
+### 1. 로또 구입 금액 (money)
+
+- [x] [공통] 값이 비어있지 않은지 검증
+- [x] [공통] 값이 올바른 양의 정수 숫자 형식인지 검증
+- [x] 값이 1000으로 나눠떨어지지 않는다면 ERROR
+- [x] 값이 너무 크다면 ERROR
+
+### 2. 당첨 번호 문자열 (winningNumberString)
+
+- [x] [공통] 값이 비어있지 않은지 검증
+- [x] 문자열에 구분자가 없다면 ERROR
+- [x] 문자열이 구분자로 시작하거나 구분자로 끝나면 ERROR
+
+### 3. 당첨 번호 배열 (winningNumbers)
+
+- 배열의 각 값에 대해서
+  - [x] [공통] 값이 비어있지 않은지 검증
+  - [x] [공통] 값이 올바른 양의 정수 숫자 형식인지 검증
+  - [x] [공통] 값이 올바른 로또 번호 형식인지 검증
+- [x] 배열의 길이가 6이 아니라면 ERROR
+
+### 4. 보너스 번호 (bonusNumber)
+
+- [x] [공통] 값이 비어있지 않은지 검증
+- [x] [공통] 값이 올바른 양의 정수 숫자 형식인지 검증
+- [x] [공통] 값이 올바른 로또 번호 형식인지 검증
diff --git a/__tests__/ApplicationTest.js b/__tests__/ApplicationTest.js
index 872380c9c..ff08e6d3d 100644
--- a/__tests__/ApplicationTest.js
+++ b/__tests__/ApplicationTest.js
@@ -1,12 +1,11 @@
-import App from "../src/App.js";
-import { MissionUtils } from "@woowacourse/mission-utils";
+import App from '../src/App.js';
+import { MissionUtils } from '@woowacourse/mission-utils';
 
 const mockQuestions = (inputs) => {
   MissionUtils.Console.readLineAsync = jest.fn();
 
   MissionUtils.Console.readLineAsync.mockImplementation(() => {
     const input = inputs.shift();
-
     return Promise.resolve(input);
   });
 };
@@ -19,79 +18,82 @@ const mockRandoms = (numbers) => {
 };
 
 const getLogSpy = () => {
-  const logSpy = jest.spyOn(MissionUtils.Console, "print");
+  const logSpy = jest.spyOn(MissionUtils.Console, 'print');
   logSpy.mockClear();
   return logSpy;
 };
 
-const runException = async (input) => {
+const runException = async (invalidInput, precedingInputs = []) => {
   // given
   const logSpy = getLogSpy();
-
   const RANDOM_NUMBERS_TO_END = [1, 2, 3, 4, 5, 6];
-  const INPUT_NUMBERS_TO_END = ["1000", "1,2,3,4,5,6", "7"];
+  const INPUTS_TO_END = ['1000', '1,2,3,4,5,6', '7'];
 
   mockRandoms([RANDOM_NUMBERS_TO_END]);
-  mockQuestions([input, ...INPUT_NUMBERS_TO_END]);
+  mockQuestions([...precedingInputs, invalidInput, ...INPUTS_TO_END]);
 
   // when
   const app = new App();
   await app.run();
 
   // then
-  expect(logSpy).toHaveBeenCalledWith(expect.stringContaining("[ERROR]"));
+  expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('[ERROR]'));
 };
 
-describe("로또 테스트", () => {
+describe('로또 애플리케이션 예외 검사', () => {
   beforeEach(() => {
     jest.restoreAllMocks();
   });
 
-  test("기능 테스트", async () => {
-    // given
-    const logSpy = getLogSpy();
-
-    mockRandoms([
-      [8, 21, 23, 41, 42, 43],
-      [3, 5, 11, 16, 32, 38],
-      [7, 11, 16, 35, 36, 44],
-      [1, 8, 11, 31, 41, 42],
-      [13, 14, 16, 38, 42, 45],
-      [7, 11, 30, 40, 42, 43],
-      [2, 13, 22, 32, 38, 45],
-      [1, 3, 5, 14, 22, 45],
-    ]);
-    mockQuestions(["8000", "1,2,3,4,5,6", "7"]);
+  describe('구입 금액 예외 검사', () => {
+    const cases = [
+      ['숫자가 아닌 경우', '1000j'],
+      ['1000원 단위가 아닌 경우', '1500'],
+      ['0원인 경우', '0'],
+      ['음수인 경우', '-1000'],
+      ['공백인 경우', ''],
+      ['소수인 경우', '1000.5'],
+    ];
 
-    // when
-    const app = new App();
-    await app.run();
+    test.each(cases)('%s: "%s" 입력 시 [ERROR] 출력', async (title, input) => {
+      await runException(input);
+    });
+  });
 
-    // then
-    const logs = [
-      "8개를 구매했습니다.",
-      "[8, 21, 23, 41, 42, 43]",
-      "[3, 5, 11, 16, 32, 38]",
-      "[7, 11, 16, 35, 36, 44]",
-      "[1, 8, 11, 31, 41, 42]",
-      "[13, 14, 16, 38, 42, 45]",
-      "[7, 11, 30, 40, 42, 43]",
-      "[2, 13, 22, 32, 38, 45]",
-      "[1, 3, 5, 14, 22, 45]",
-      "3개 일치 (5,000원) - 1개",
-      "4개 일치 (50,000원) - 0개",
-      "5개 일치 (1,500,000원) - 0개",
-      "5개 일치, 보너스 볼 일치 (30,000,000원) - 0개",
-      "6개 일치 (2,000,000,000원) - 0개",
-      "총 수익률은 62.5%입니다.",
+  describe('당첨 번호 예외 검사', () => {
+    const precedingInput = ['1000'];
+    const cases = [
+      ['숫자가 아닌 경우', '1,2,3,4,5,a'],
+      ['숫자 범위를 벗어난 경우 (46)', '1,2,3,4,5,46'],
+      ['숫자 범위를 벗어난 경우 (0)', '1,2,3,4,5,0'],
+      ['중복된 숫자가 있는 경우', '1,2,3,4,5,5'],
+      ['개수가 6개가 아닌 경우 (5개)', '1,2,3,4,5'],
+      ['개수가 6개가 아닌 경우 (7개)', '1,2,3,4,5,6,7'],
+      ['공백이 포함된 경우', '1,2,3,4,5, '],
+      ['쉼표로 시작하는 경우', ',1,2,3,4,5'],
+      ['쉼표로 끝나는 경우', '1,2,3,4,5,'],
+      ['쉼표가 없는 경우', '1 2 3 4 5 6'],
+      ['공백만 입력한 경우', ''],
     ];
 
-    logs.forEach((log) => {
-      expect(logSpy).toHaveBeenCalledWith(expect.stringContaining(log));
+    test.each(cases)('%s: "%s" 입력 시 [ERROR] 출력', async (title, input) => {
+      await runException(input, precedingInput);
     });
   });
 
-  test("예외 테스트", async () => {
-    await runException("1000j");
+  describe('보너스 번호 예외 검사', () => {
+    const precedingInputs = ['1000', '1,2,3,4,5,6'];
+    const cases = [
+      ['숫자가 아닌 경우', 'a'],
+      ['숫자 범위를 벗어난 경우 (46)', '46'],
+      ['숫자 범위를 벗어난 경우 (0)', '0'],
+      ['당첨 번호와 중복된 경우', '6'],
+      ['공백인 경우', ''],
+      ['소수인 경우', '7.5'],
+    ];
+
+    test.each(cases)('%s: "%s" 입력 시 [ERROR] 출력', async (title, input) => {
+      await runException(input, precedingInputs);
+    });
   });
 });
diff --git a/__tests__/LottoTest.js b/__tests__/LottoTest.js
index 409aaf69b..edd432aee 100644
--- a/__tests__/LottoTest.js
+++ b/__tests__/LottoTest.js
@@ -1,18 +1,59 @@
-import Lotto from "../src/Lotto";
+import Lotto from '../src/models/Lotto.js';
+import { ERROR_MESSAGE } from '../src/constants/messages.js';
 
-describe("로또 클래스 테스트", () => {
-  test("로또 번호의 개수가 6개가 넘어가면 예외가 발생한다.", () => {
-    expect(() => {
-      new Lotto([1, 2, 3, 4, 5, 6, 7]);
-    }).toThrow("[ERROR]");
-  });
+describe('Lotto 클래스 단위 테스트', () => {
+  describe('Lotto 번호 예외 검사', () => {
+    // cases
+    const INVALID_COUNT_CASE = [[[1, 2, 3, 4, 5, 6, 7]], [[1, 2, 3, 4, 5]]];
+
+    const LOTTO_NUMBER_OUT_OF_RANGE = [[[1, 2, 3, 4, 5, 0]], [[1, 2, 3, 4, 5, 46]]];
+
+    const INPUT_NOT_AN_POSITIVE_INTEGER_CASE = [
+      ['숫자가 아닌 값', ['1', '2', '3', '4', '5', 'a']],
+      ['공백 문자', ['1', '2', '3', '4', '5', ' ']],
+      ['소수', [1, 2, 3, 4, 5, 1.5]],
+    ];
+
+    // INVALID_COUNT_CASE
+    test.each(INVALID_COUNT_CASE)('로또 번호의 개수가 6개가 아니면 예외가 발생한다', (numbers) => {
+      expect(() => {
+        new Lotto(numbers);
+      }).toThrow(ERROR_MESSAGE.WINNING_NUMBERS.INVALID_COUNT);
+    });
 
-  // TODO: 테스트가 통과하도록 프로덕션 코드 구현
-  test("로또 번호에 중복된 숫자가 있으면 예외가 발생한다.", () => {
-    expect(() => {
-      new Lotto([1, 2, 3, 4, 5, 5]);
-    }).toThrow("[ERROR]");
+    // LOTTO_NUMBER_OUT_OF_RANGE
+    test.each(LOTTO_NUMBER_OUT_OF_RANGE)('로또 번호가 범위 안의 숫자가 아니면 예외가 발생한다.', (numbers) => {
+      expect(() => {
+        new Lotto(numbers);
+      }).toThrow(ERROR_MESSAGE.WINNING_NUMBERS.LOTTO_NUMBER_OUT_OF_RANGE);
+    });
+
+    // INPUT_NOT_AN_POSITIVE_INTEGER_CASE
+    test.each(INPUT_NOT_AN_POSITIVE_INTEGER_CASE)('%s: %p 입력 시 예외가 발생한다.', (title, numbers) => {
+      expect(() => {
+        new Lotto(numbers);
+      }).toThrow(ERROR_MESSAGE.COMMON.INPUT_NOT_AN_POSITIVE_INTEGER);
+    });
+
+    // LOTTO_NUMBER_DUPLICATED_CASE
+    test('로또 번호에 중복된 숫자가 있으면 예외가 발생한다.', () => {
+      expect(() => {
+        new Lotto([1, 2, 3, 4, 5, 5]);
+      }).toThrow(ERROR_MESSAGE.COMMON.LOTTO_NUMBER_DUPLICATED);
+    });
   });
 
-  // TODO: 추가 기능 구현에 따른 테스트 코드 작성
+  describe('Lotto 클래스 기능 검사', () => {
+    test('로또 번호가 오름차순으로 정렬되어 저장된다.', () => {
+      const numbers = [6, 5, 4, 3, 2, 1];
+      const lotto = new Lotto(numbers);
+      expect(lotto.getNumbers()).toEqual([1, 2, 3, 4, 5, 6]);
+    });
+
+    test('문자열 숫자를 입력해도 숫자로 변환되어 저장된다.', () => {
+      const numbers = ['6', '5', '4', '3', '2', '1'];
+      const lotto = new Lotto(numbers);
+      expect(lotto.getNumbers()).toEqual([1, 2, 3, 4, 5, 6]);
+    });
+  });
 });
diff --git a/__tests__/PurchaseAmountTest.js b/__tests__/PurchaseAmountTest.js
new file mode 100644
index 000000000..75f48cf23
--- /dev/null
+++ b/__tests__/PurchaseAmountTest.js
@@ -0,0 +1,33 @@
+import PurchaseAmount from '../src/models/PurchaseAmount.js';
+import { ERROR_MESSAGE } from '../src/constants/messages.js';
+
+describe('PurchaseAmount 클래스 단위 테스트', () => {
+  describe('구입 금액 예외 검사', () => {
+    const cases = [
+      [ERROR_MESSAGE.COMMON.INPUT_EMPTY, '빈 값', ''],
+      [ERROR_MESSAGE.COMMON.INPUT_NOT_AN_POSITIVE_INTEGER, '숫자가 아닌 값', 'abc'],
+      [ERROR_MESSAGE.COMMON.INPUT_NOT_AN_POSITIVE_INTEGER, '0', '0'],
+      [ERROR_MESSAGE.COMMON.INPUT_NOT_AN_POSITIVE_INTEGER, '음수', '-1000'],
+      [ERROR_MESSAGE.COMMON.INPUT_NOT_AN_POSITIVE_INTEGER, '소수', '1000.5'],
+      [ERROR_MESSAGE.MONEY.INVALID_UNIT, '1000원 단위가 아닌 값', '1500'],
+    ];
+
+    test.each(cases)('%s: "%s" 입력 시 예외 발생', (errorMsg, title, input) => {
+      expect(() => {
+        new PurchaseAmount(input);
+      }).toThrow(errorMsg);
+    });
+  });
+
+  describe('기능 검사', () => {
+    test('8000원 입력 시 로또 8개를 계산한다', () => {
+      const purchaseAmount = new PurchaseAmount('8000');
+      expect(purchaseAmount.calculateLottoCount()).toBe(8);
+    });
+
+    test('1000원 입력 시 로또 1개를 계산한다', () => {
+      const purchaseAmount = new PurchaseAmount('1000');
+      expect(purchaseAmount.calculateLottoCount()).toBe(1);
+    });
+  });
+});
diff --git a/__tests__/WinningLottoTest.js b/__tests__/WinningLottoTest.js
new file mode 100644
index 000000000..fdaf767d3
--- /dev/null
+++ b/__tests__/WinningLottoTest.js
@@ -0,0 +1,69 @@
+import WinningLotto from '../src/models/WinningLotto.js';
+import { ERROR_MESSAGE } from '../src/constants/messages.js';
+
+describe('WinningLotto 클래스 단위 테스트', () => {
+  const MAIN_NUMBERS = [1, 2, 3, 4, 5, 6];
+  const BONUS_NUMBER = '7';
+
+  describe('보너스 번호 예외 검사', () => {
+    const cases = [
+      [ERROR_MESSAGE.COMMON.INPUT_EMPTY, '빈 값', ''],
+      [ERROR_MESSAGE.COMMON.INPUT_NOT_AN_POSITIVE_INTEGER, '숫자가 아닌 값', 'a'],
+      [ERROR_MESSAGE.COMMON.INPUT_NOT_AN_POSITIVE_INTEGER, '0', '0'],
+      [ERROR_MESSAGE.COMMON.INPUT_NOT_AN_POSITIVE_INTEGER, '음수', '-10'],
+      [ERROR_MESSAGE.COMMON.INPUT_NOT_AN_POSITIVE_INTEGER, '소수', '1.5'],
+      [ERROR_MESSAGE.COMMON.LOTTO_NUMBER_OUT_OF_RANGE, '범위 밖의 값 (46)', '46'],
+      [ERROR_MESSAGE.COMMON.LOTTO_NUMBER_DUPLICATED, '당첨 번호와 중복된 값', '6'],
+    ];
+
+    test.each(cases)('%s: "%s" 입력 시 예외 발생', (errorMsg, title, bonusNumber) => {
+      expect(() => {
+        new WinningLotto(MAIN_NUMBERS, bonusNumber);
+      }).toThrow(errorMsg);
+    });
+  });
+
+  describe('기능 검사', () => {
+    test('정상 입력 시 WinningLotto 인스턴스가 생성된다', () => {
+      expect(() => {
+        new WinningLotto(MAIN_NUMBERS, BONUS_NUMBER);
+      }).not.toThrow();
+    });
+
+    test('compare 메서드: 6개 일치', () => {
+      const winningLotto = new WinningLotto(MAIN_NUMBERS, BONUS_NUMBER);
+      const myLotto = [1, 2, 3, 4, 5, 6];
+      expect(winningLotto.compare(myLotto)).toEqual({
+        matchCount: 6,
+        hasBonus: false,
+      });
+    });
+
+    test('compare 메서드: 5개 + 보너스 일치 (2등)', () => {
+      const winningLotto = new WinningLotto(MAIN_NUMBERS, BONUS_NUMBER);
+      const myLotto = [1, 2, 3, 4, 5, 7];
+      expect(winningLotto.compare(myLotto)).toEqual({
+        matchCount: 5,
+        hasBonus: true,
+      });
+    });
+
+    test('compare 메서드: 5개 일치 (3등)', () => {
+      const winningLotto = new WinningLotto(MAIN_NUMBERS, BONUS_NUMBER);
+      const myLotto = [1, 2, 3, 4, 5, 8];
+      expect(winningLotto.compare(myLotto)).toEqual({
+        matchCount: 5,
+        hasBonus: false,
+      });
+    });
+
+    test('compare 메서드: 3개 일치 (5등)', () => {
+      const winningLotto = new WinningLotto(MAIN_NUMBERS, BONUS_NUMBER);
+      const myLotto = [1, 2, 3, 8, 9, 10];
+      expect(winningLotto.compare(myLotto)).toEqual({
+        matchCount: 3,
+        hasBonus: false,
+      });
+    });
+  });
+});
diff --git a/src/App.js b/src/App.js
index 091aa0a5d..afc60666d 100644
--- a/src/App.js
+++ b/src/App.js
@@ -1,5 +1,15 @@
+import LottoGameController from './controllers/LottoGameController.js';
+import OutputView from './views/OuputView.js';
 class App {
-  async run() {}
+  async run() {
+    try {
+      const lottoGameController = new LottoGameController();
+      await lottoGameController.play();
+    } catch (error) {
+      OutputView.printMessage(error.message);
+      throw error;
+    }
+  }
 }
 
 export default App;
diff --git a/src/Lotto.js b/src/Lotto.js
deleted file mode 100644
index cb0b1527e..000000000
--- a/src/Lotto.js
+++ /dev/null
@@ -1,18 +0,0 @@
-class Lotto {
-  #numbers;
-
-  constructor(numbers) {
-    this.#validate(numbers);
-    this.#numbers = numbers;
-  }
-
-  #validate(numbers) {
-    if (numbers.length !== 6) {
-      throw new Error("[ERROR] 로또 번호는 6개여야 합니다.");
-    }
-  }
-
-  // TODO: 추가 기능 구현
-}
-
-export default Lotto;
diff --git a/src/constants/config.js b/src/constants/config.js
new file mode 100644
index 000000000..a9339a088
--- /dev/null
+++ b/src/constants/config.js
@@ -0,0 +1,37 @@
+export const LOTTO_NUMBER_SEPARATOR = ',';
+
+export const LOTTO_COST = 1000;
+
+export const LOTTO_INFO = Object.freeze({
+  RANGE_START: 1,
+  RANGE_END: 45,
+  TOTAL_LENGTH: 6,
+});
+
+export const LOTTO_RANK = Object.freeze({
+  '1st': Object.freeze({
+    matchCount: 6,
+    money: 2000000000,
+    requireBonus: false,
+  }),
+  '2nd': Object.freeze({
+    matchCount: 5,
+    money: 30000000,
+    requireBonus: true,
+  }),
+  '3rd': Object.freeze({
+    matchCount: 5,
+    money: 1500000,
+    requireBonus: false,
+  }),
+  '4th': Object.freeze({
+    matchCount: 4,
+    money: 50000,
+    requireBonus: false,
+  }),
+  '5th': Object.freeze({
+    matchCount: 3,
+    money: 5000,
+    requireBonus: false,
+  }),
+});
diff --git a/src/constants/messages.js b/src/constants/messages.js
new file mode 100644
index 000000000..2d3a83770
--- /dev/null
+++ b/src/constants/messages.js
@@ -0,0 +1,40 @@
+import { LOTTO_COST, LOTTO_INFO, LOTTO_NUMBER_SEPARATOR } from './config.js';
+
+export const PREFIX = Object.freeze({
+  ERROR: '[ERROR]',
+});
+
+export const INPUT_MESSAGE = Object.freeze({
+  MONEY: `구입금액을 입력해 주세요.\n`,
+  WINNING_NUMBER_STRING: `\n당첨 번호를 입력해 주세요.\n`,
+  BONUS_NUMBER: `\n보너스 번호를 입력해 주세요.\n`,
+});
+
+export const OUTPUT_MESSAGE = Object.freeze({
+  PURCHASE_RESULT: (purchaseCnt) => `\n${purchaseCnt}개를 구매했습니다.`,
+  WINNING_STATISTICS_HEADER: `\n당첨 통계\n---`,
+  WINNING_MATCH_COUNT_INFO: (matchCnt) => `${matchCnt}개 일치`,
+  WINNING_PRIZE_MONEY: (prizeMoney) => `(${prizeMoney}원)`,
+  WINNING_COUNT: (winningCnt) => `${winningCnt}개`,
+  PROFIT_RATE: (rate) => `총 수익률은 ${rate}%입니다.`,
+});
+
+export const ERROR_MESSAGE = Object.freeze({
+  COMMON: Object.freeze({
+    INPUT_EMPTY: `${PREFIX.ERROR} 입력값은 비어있을 수 없습니다.`,
+    INPUT_NOT_AN_POSITIVE_INTEGER: `${PREFIX.ERROR} 값은 양의 정수(자연수)만 입력되어야 합니다.`,
+    LOTTO_NUMBER_OUT_OF_RANGE: `${PREFIX.ERROR} 로또 번호는 ${LOTTO_INFO.RANGE_START}부터 ${LOTTO_INFO.RANGE_END} 사이의 숫자여야 합니다.`,
+    LOTTO_NUMBER_DUPLICATED: `${PREFIX.ERROR} 로또 번호는 중복될 수 없습니다.`,
+  }),
+  MONEY: Object.freeze({
+    INVALID_UNIT: `${PREFIX.ERROR} 구입 금액은 ${LOTTO_COST}원 단위로 입력해야 합니다.`,
+    TOO_LARGE: `${PREFIX.ERROR} 구입 금액이 너무 큽니다.`,
+  }),
+  WINNING_NUMBER_STRING: Object.freeze({
+    NO_SEPARATOR: `${PREFIX.ERROR} 당첨 번호는 '${LOTTO_NUMBER_SEPARATOR}' 기준으로 구분해야 합니다.`,
+    INVALID_FORMAT: `${PREFIX.ERROR} 잘못된 입력 형식입니다.`,
+  }),
+  WINNING_NUMBERS: Object.freeze({
+    INVALID_COUNT: `${PREFIX.ERROR} 당첨 번호는 ${LOTTO_INFO.TOTAL_LENGTH}개여야 합니다.`,
+  }),
+});
diff --git a/src/controllers/LottoGameController.js b/src/controllers/LottoGameController.js
new file mode 100644
index 000000000..e56167605
--- /dev/null
+++ b/src/controllers/LottoGameController.js
@@ -0,0 +1,102 @@
+import { INPUT_MESSAGE } from '../constants/messages.js';
+import { LOTTO_NUMBER_SEPARATOR, LOTTO_RANK } from '../constants/config.js';
+
+import { splitBySeparator } from '../utils/Utils.js';
+
+import InputView from '../views/InputView.js';
+import OutputView from '../views/OuputView.js';
+
+import PurchaseAmount from '../models/PurchaseAmount.js';
+import Lotto from '../models/Lotto.js';
+import LottoStore from '../models/LottoStore.js';
+import WinningLotto from '../models/WinningLotto.js';
+import LottoResult from '../models/LottoResult.js';
+
+import WinningLottoValidator from '../validates/WinningLottoValidator.js';
+
+class LottoGameController {
+  #lottos;
+  #winningLotto;
+
+  constructor() {
+    this.#lottos = [];
+  }
+
+  async play() {
+    const purchaseAmount = await this.#getValidPurchaseAmount();
+    this.#buyLottos(purchaseAmount);
+    this.#winningLotto = await this.#getValidWinningLotto();
+    this.#showResults();
+  }
+
+  async #readInputWithValidation(readMsg, validateFunc) {
+    while (true) {
+      try {
+        const input = await InputView.readStringWithMsg(readMsg);
+        return validateFunc(input.trim());
+      } catch (error) {
+        OutputView.printMessage(error.message);
+      }
+    }
+  }
+
+  async #getValidPurchaseAmount() {
+    return this.#readInputWithValidation(INPUT_MESSAGE.MONEY, (input) => new PurchaseAmount(input));
+  }
+
+  #buyLottos(purchaseAmount) {
+    const lottoStore = new LottoStore();
+    this.#lottos = lottoStore.buyLottos(purchaseAmount);
+
+    const lottoNumberArrays = this.#lottos.map((lotto) => lotto.getNumbers());
+    OutputView.printPurchasedLottos(lottoNumberArrays);
+  }
+
+  async #getValidWinningLotto() {
+    const mainNumbers = await this.#getValidWinningMainNumbers();
+
+    const winningLotto = await this.#readInputWithValidation(
+      INPUT_MESSAGE.BONUS_NUMBER,
+      (bonusInput) => new WinningLotto(mainNumbers.getNumbers(), bonusInput.trim())
+    );
+    return winningLotto;
+  }
+
+  async #getValidWinningMainNumbers() {
+    return this.#readInputWithValidation(INPUT_MESSAGE.WINNING_NUMBER_STRING, (input) => {
+      WinningLottoValidator.validateWinningNumberString(input);
+
+      const numbers = splitBySeparator(input, LOTTO_NUMBER_SEPARATOR);
+      return new Lotto(numbers);
+    });
+  }
+
+  #showResults() {
+    const lottoNumberArrays = this.#lottos.map((lotto) => lotto.getNumbers());
+    const lottoResult = new LottoResult(lottoNumberArrays, this.#winningLotto);
+
+    const matchCnt = lottoResult.getMatchCntInfo();
+    const profitRate = lottoResult.getProfitRate();
+    const resultData = this.#prepareResultData(matchCnt);
+
+    OutputView.printResult(resultData, profitRate);
+  }
+
+  #prepareResultData(matchCnt) {
+    const rankKeys = Object.keys(LOTTO_RANK).reverse();
+
+    return rankKeys.map((rankKey) => {
+      const { matchCount, money, requireBonus } = LOTTO_RANK[rankKey];
+      const count = matchCnt[rankKey];
+
+      return {
+        matchCount,
+        money,
+        requireBonus,
+        count,
+      };
+    });
+  }
+}
+
+export default LottoGameController;
diff --git a/src/index.js b/src/index.js
index 02a1d389e..9daefc93f 100644
--- a/src/index.js
+++ b/src/index.js
@@ -1,4 +1,4 @@
-import App from "./App.js";
+import App from './App.js';
 
 const app = new App();
 await app.run();
diff --git a/src/models/Lotto.js b/src/models/Lotto.js
new file mode 100644
index 000000000..a8912d97a
--- /dev/null
+++ b/src/models/Lotto.js
@@ -0,0 +1,19 @@
+import LottoValidator from '../validates/LottoValidator.js';
+
+class Lotto {
+  #numbers;
+
+  constructor(numbers) {
+    this.#validate(numbers);
+    this.#numbers = numbers.map(Number).sort((a, b) => a - b);
+  }
+  #validate(numbers) {
+    LottoValidator.validateLottoNumbers(numbers);
+  }
+
+  getNumbers() {
+    return this.#numbers;
+  }
+}
+
+export default Lotto;
diff --git a/src/models/LottoResult.js b/src/models/LottoResult.js
new file mode 100644
index 000000000..2b3a8f3b7
--- /dev/null
+++ b/src/models/LottoResult.js
@@ -0,0 +1,61 @@
+import { LOTTO_COST, LOTTO_RANK } from '../constants/config.js';
+
+class LottoResult {
+  #matchCntInfo;
+  #profitRate;
+
+  constructor(lottos, winningLotto) {
+    this.#matchCntInfo = this.#initMatchCntInfo();
+    this.#calculateResult(lottos, winningLotto);
+    this.#profitRate = this.#calculateProfit(lottos.length);
+  }
+
+  #initMatchCntInfo() {
+    return Object.keys(LOTTO_RANK).reduce((matchCnt, rankKey) => {
+      matchCnt[rankKey] = 0;
+      return matchCnt;
+    }, {});
+  }
+
+  #calculateResult(lottos, winningLotto) {
+    lottos.forEach((lotto) => {
+      const { matchCount, hasBonus } = winningLotto.compare(lotto);
+      const rankKey = this.#getRankKey(matchCount, hasBonus);
+
+      if (rankKey) this.#matchCntInfo[rankKey] += 1;
+    });
+  }
+
+  #getRankKey(matchCount, hasBonus) {
+    if (matchCount === 6) return '1st';
+    if (matchCount === 5 && hasBonus) return '2nd';
+    if (matchCount === 5 && !hasBonus) return '3rd';
+    if (matchCount === 4) return '4th';
+    if (matchCount === 3) return '5th';
+    return null;
+  }
+
+  #calculateProfit(totalLottoCount) {
+    let totalPrize = 0;
+    Object.entries(this.#matchCntInfo).forEach(([rankKey, count]) => {
+      totalPrize += LOTTO_RANK[rankKey].money * count;
+    });
+
+    const totalCost = totalLottoCount * LOTTO_COST;
+
+    if (totalCost === 0) return 0;
+
+    const profitRate = (totalPrize / totalCost) * 100;
+    return profitRate;
+  }
+
+  getMatchCntInfo() {
+    return this.#matchCntInfo;
+  }
+
+  getProfitRate() {
+    return this.#profitRate;
+  }
+}
+
+export default LottoResult;
diff --git a/src/models/LottoStore.js b/src/models/LottoStore.js
new file mode 100644
index 000000000..89b2a248c
--- /dev/null
+++ b/src/models/LottoStore.js
@@ -0,0 +1,28 @@
+import { Random } from '@woowacourse/mission-utils';
+import { LOTTO_INFO } from '../constants/config.js';
+import Lotto from './Lotto.js';
+
+class LottoStore {
+  buyLottos(purchaseAmount) {
+    const lottoCount = purchaseAmount.calculateLottoCount();
+
+    const lottos = this.#generateLottos(lottoCount);
+    return lottos;
+  }
+
+  #generateLottos(lottoCount) {
+    const lottos = [];
+
+    for (let _ = 0; _ < lottoCount; _++) {
+      const numbers = Random.pickUniqueNumbersInRange(
+        LOTTO_INFO.RANGE_START,
+        LOTTO_INFO.RANGE_END,
+        LOTTO_INFO.TOTAL_LENGTH
+      );
+      lottos.push(new Lotto(numbers));
+    }
+    return lottos;
+  }
+}
+
+export default LottoStore;
diff --git a/src/models/PurchaseAmount.js b/src/models/PurchaseAmount.js
new file mode 100644
index 000000000..df30c3536
--- /dev/null
+++ b/src/models/PurchaseAmount.js
@@ -0,0 +1,21 @@
+import PurchaseAmountValidator from '../validates/PurchaseAmountValidator.js';
+
+class PurchaseAmount {
+  #money;
+
+  constructor(moneyInput) {
+    this.#validate(moneyInput);
+    this.#money = moneyInput;
+  }
+
+  calculateLottoCount() {
+    const money = Number(this.#money);
+    return money / 1000;
+  }
+
+  #validate(money) {
+    PurchaseAmountValidator.validatePurchaseAmount(money);
+  }
+}
+
+export default PurchaseAmount;
diff --git a/src/models/WinningLotto.js b/src/models/WinningLotto.js
new file mode 100644
index 000000000..24dee7a4a
--- /dev/null
+++ b/src/models/WinningLotto.js
@@ -0,0 +1,29 @@
+import WinningLottoValidator from '../validates/WinningLottoValidator.js';
+
+class WinningLotto {
+  #mainNumbers;
+  #bonusNumber;
+
+  constructor(mainNumbers, bonusNumber) {
+    this.#validate(mainNumbers, bonusNumber);
+    this.#mainNumbers = mainNumbers;
+    this.#bonusNumber = Number(bonusNumber);
+  }
+
+  compare(lottoNumbers) {
+    const winningNumbers = this.#mainNumbers;
+    const matchCount = winningNumbers.filter((number) => lottoNumbers.includes(number)).length;
+    const hasBonus = lottoNumbers.includes(this.#bonusNumber);
+
+    return {
+      matchCount,
+      hasBonus,
+    };
+  }
+
+  #validate(mainNumbers, bonusNumber) {
+    WinningLottoValidator.validateBonusNumber(mainNumbers, bonusNumber);
+  }
+}
+
+export default WinningLotto;
diff --git a/src/utils/Utils.js b/src/utils/Utils.js
new file mode 100644
index 000000000..4ce6fa1e2
--- /dev/null
+++ b/src/utils/Utils.js
@@ -0,0 +1,9 @@
+export function splitBySeparator(string, separator) {
+  return string.trim().split(separator);
+}
+
+export function formatNumber(number) {
+  return number.toLocaleString('ko-KR', {
+    maximumFractionDigits: 1,
+  });
+}
diff --git a/src/validates/LottoValidator.js b/src/validates/LottoValidator.js
new file mode 100644
index 000000000..9e9b4d96f
--- /dev/null
+++ b/src/validates/LottoValidator.js
@@ -0,0 +1,28 @@
+import { LOTTO_INFO } from '../constants/config.js';
+import { ERROR_MESSAGE } from '../constants/messages.js';
+import Validator from './Validator.js';
+
+export default {
+  validateSingleNumber(number) {
+    const numStr = String(number);
+    Validator.isInputEmpty(numStr);
+    Validator.isPositiveInteger(numStr);
+    Validator.isNumberInRange(number);
+  },
+
+  validateLottolength(length) {
+    if (length !== LOTTO_INFO.TOTAL_LENGTH) {
+      throw new Error(ERROR_MESSAGE.WINNING_NUMBERS.INVALID_COUNT);
+    }
+  },
+
+  validateLottoNumbers(numbers) {
+    numbers.forEach((number) => {
+      this.validateSingleNumber(number);
+    });
+
+    Validator.duplicatesNumber(numbers);
+
+    this.validateLottolength(numbers.length);
+  },
+};
diff --git a/src/validates/MoneyValidator.js b/src/validates/MoneyValidator.js
new file mode 100644
index 000000000..eefb0240d
--- /dev/null
+++ b/src/validates/MoneyValidator.js
@@ -0,0 +1,15 @@
+import { ERROR_MESSAGE } from '../constants/messages.js';
+
+export default {
+  isValidUnit(money) {
+    if (Number(money) % 1000 !== 0) {
+      throw new Error(ERROR_MESSAGE.MONEY.INVALID_UNIT);
+    }
+  },
+
+  tooLarge(money) {
+    if (BigInt(money) > BigInt(Number.MAX_SAFE_INTEGER)) {
+      throw new Error(ERROR_MESSAGE.MONEY.TOO_LARGE);
+    }
+  },
+};
diff --git a/src/validates/PurchaseAmountValidator.js b/src/validates/PurchaseAmountValidator.js
new file mode 100644
index 000000000..ddb79d34c
--- /dev/null
+++ b/src/validates/PurchaseAmountValidator.js
@@ -0,0 +1,11 @@
+import Validator from './Validator.js';
+import MoneyValidator from './MoneyValidator.js';
+
+export default {
+  validatePurchaseAmount(money) {
+    Validator.isInputEmpty(money);
+    Validator.isPositiveInteger(money);
+    MoneyValidator.isValidUnit(money);
+    MoneyValidator.tooLarge(money);
+  },
+};
diff --git a/src/validates/Validator.js b/src/validates/Validator.js
new file mode 100644
index 000000000..e90b78b66
--- /dev/null
+++ b/src/validates/Validator.js
@@ -0,0 +1,32 @@
+import { ERROR_MESSAGE } from '../constants/messages.js';
+import { LOTTO_INFO } from '../constants/config.js';
+
+const POSTIVIE_INTEGER_REGEX = /^[1-9]\d*$/;
+
+export default {
+  isInputEmpty(input) {
+    if (input === '') {
+      throw new Error(ERROR_MESSAGE.COMMON.INPUT_EMPTY);
+    }
+  },
+
+  isPositiveInteger(input) {
+    if (!POSTIVIE_INTEGER_REGEX.test(input)) {
+      throw new Error(ERROR_MESSAGE.COMMON.INPUT_NOT_AN_POSITIVE_INTEGER);
+    }
+  },
+
+  isNumberInRange(_number) {
+    const number = Number(_number);
+    if (number < LOTTO_INFO.RANGE_START || number > LOTTO_INFO.RANGE_END) {
+      throw new Error(ERROR_MESSAGE.COMMON.LOTTO_NUMBER_OUT_OF_RANGE);
+    }
+  },
+
+  duplicatesNumber(numbers) {
+    const numberSet = new Set(numbers);
+    if (numberSet.size !== numbers.length) {
+      throw new Error(ERROR_MESSAGE.COMMON.LOTTO_NUMBER_DUPLICATED);
+    }
+  },
+};
diff --git a/src/validates/WinningLottoValidator.js b/src/validates/WinningLottoValidator.js
new file mode 100644
index 000000000..d0e4b5a4f
--- /dev/null
+++ b/src/validates/WinningLottoValidator.js
@@ -0,0 +1,33 @@
+import { LOTTO_NUMBER_SEPARATOR } from '../constants/config.js';
+import { ERROR_MESSAGE } from '../constants/messages.js';
+import Validator from './Validator.js';
+
+export default {
+  isSeparatorExist(input) {
+    if (!input.includes(LOTTO_NUMBER_SEPARATOR)) {
+      throw new Error(ERROR_MESSAGE.WINNING_NUMBER_STRING.NO_SEPARATOR);
+    }
+  },
+
+  correctFormat(input) {
+    if (input.startsWith(LOTTO_NUMBER_SEPARATOR) || input.endsWith(LOTTO_NUMBER_SEPARATOR)) {
+      throw new Error(ERROR_MESSAGE.WINNING_NUMBER_STRING.INVALID_FORMAT);
+    }
+  },
+
+  validateWinningNumberString(input) {
+    Validator.isInputEmpty(input);
+    this.isSeparatorExist(input);
+    this.correctFormat(input);
+  },
+
+  validateBonusNumber(mainNumbers, bonusNumber) {
+    Validator.isInputEmpty(bonusNumber);
+    Validator.isPositiveInteger(bonusNumber);
+    Validator.isNumberInRange(bonusNumber);
+
+    if (mainNumbers.includes(Number(bonusNumber))) {
+      throw new Error(ERROR_MESSAGE.COMMON.LOTTO_NUMBER_DUPLICATED);
+    }
+  },
+};
diff --git a/src/views/InputView.js b/src/views/InputView.js
new file mode 100644
index 000000000..f573adf7e
--- /dev/null
+++ b/src/views/InputView.js
@@ -0,0 +1,10 @@
+import { Console } from '@woowacourse/mission-utils';
+
+const InputView = {
+  async readStringWithMsg(message) {
+    const input = await Console.readLineAsync(message);
+    return input;
+  },
+};
+
+export default InputView;
diff --git a/src/views/OuputView.js b/src/views/OuputView.js
new file mode 100644
index 000000000..c27931606
--- /dev/null
+++ b/src/views/OuputView.js
@@ -0,0 +1,42 @@
+import { Console } from '@woowacourse/mission-utils';
+import { OUTPUT_MESSAGE } from '../constants/messages.js';
+import { LOTTO_NUMBER_SEPARATOR } from '../constants/config.js';
+import { formatNumber } from '../utils/Utils.js';
+const OutputView = {
+  printPurchasedLottos(lottoNumberArrays) {
+    Console.print(OUTPUT_MESSAGE.PURCHASE_RESULT(lottoNumberArrays.length));
+
+    lottoNumberArrays.forEach((numbers) => {
+      Console.print(`[${numbers.join(`${LOTTO_NUMBER_SEPARATOR} `)}]`);
+    });
+  },
+
+  printResult(resultData, profitRate) {
+    Console.print(OUTPUT_MESSAGE.WINNING_STATISTICS_HEADER);
+
+    this.printWinningInfo(resultData);
+
+    const formattedProfitRate = Number(formatNumber(profitRate)).toFixed(1);
+    Console.print(OUTPUT_MESSAGE.PROFIT_RATE(formattedProfitRate));
+  },
+
+  printWinningInfo(resultData) {
+    resultData.forEach((rank) => {
+      const { matchCount, money, requireBonus, count } = rank;
+
+      let matchMessage = OUTPUT_MESSAGE.WINNING_MATCH_COUNT_INFO(matchCount);
+      if (requireBonus) matchMessage += ', 보너스 볼 일치';
+
+      const formattedMoney = formatNumber(money);
+      const prizeMessage = OUTPUT_MESSAGE.WINNING_PRIZE_MONEY(formattedMoney);
+
+      Console.print(`${matchMessage} ${prizeMessage} - ${count}개`);
+    });
+  },
+
+  printMessage(message) {
+    Console.print(message);
+  },
+};
+
+export default OutputView;