🎓 온라인 자격증 시험 응시 플랫폼 - 실시간 타이머 & 자동 채점 시스템

mkdir online-certification-exam-platform && cd online-certification-exam-platform

이 폴더에서 Laravel 13.x 프로젝트를 시작합니다.

1. Laravel 13.x 프로젝트 생성:
```bash
composer create-project laravel/laravel:^13.0 .
```

2. Laravel Breeze (Blade 스택) 설치 및 인증 스캐폴딩 생성:
```bash
composer require laravel/breeze --dev
php artisan breeze:install blade
php artisan migrate
npm install && npm run dev
```

3. Tailwind CSS 4.x 설정 확인 (Breeze가 자동 설정):
- `tailwind.config.js` 파일이 생성되었는지 확인
- `resources/css/app.css`에 Tailwind 디렉티브가 포함되었는지 확인

4. 데이터베이스 설정 (SQLite):
- `.env` 파일에서 `DB_CONNECTION=sqlite` 설정
- `touch database/database.sqlite` 명령으로 SQLite 파일 생성

5. 기본 라우트 확인:
- `routes/web.php`에서 Breeze가 생성한 인증 라우트 확인
- `php artisan route:list` 실행하여 라우트 목록 확인

6. 개발 서버 실행:
```bash
php artisan serve
```

브라우저에서 `http://localhost:8000` 접속하여 Breeze 기본 레이아웃 확인.

데이터베이스 스키마 설계 및 마이그레이션 생성:

1. **User 모델 확장** (관리자/응시자 역할 구분):
```bash
php artisan make:migration add_role_to_users_table --table=users
```
마이그레이션 파일에서:
```php
$table->enum('role', ['admin', 'examinee'])->default('examinee');
```

2. **Exam 모델** (시험 정보):
```bash
php artisan make:model Exam -m
```
마이그레이션:
```php
$table->id();
$table->string('title'); // 시험 제목
$table->text('description')->nullable(); // 시험 설명
$table->integer('duration_minutes'); // 제한 시간 (분)
$table->integer('passing_score'); // 합격 점수
$table->enum('status', ['draft', 'published'])->default('draft'); // 공개 여부
$table->string('category')->nullable(); // 카테고리 (프로그래밍, 디자인 등)
$table->enum('difficulty', ['beginner', 'intermediate', 'advanced'])->default('beginner'); // 난이도
$table->boolean('allow_retake')->default(true); // 재응시 허용 여부
$table->timestamps();
```

3. **Question 모델** (문제):
```bash
php artisan make:model Question -m
```
마이그레이션:
```php
$table->id();
$table->foreignId('exam_id')->constrained()->onDelete('cascade');
$table->text('question_text'); // 문제 내용
$table->enum('question_type', ['multiple_choice', 'short_answer'])->default('multiple_choice');
$table->json('options')->nullable(); // 객관식 선택지 (JSON 배열)
$table->string('correct_answer'); // 정답
$table->integer('points')->default(1); // 배점
$table->integer('order')->default(0); // 문제 순서
$table->timestamps();
```

4. **ExamAttempt 모델** (응시 기록):
```bash
php artisan make:model ExamAttempt -m
```
마이그레이션:
```php
$table->id();
$table->foreignId('user_id')->constrained()->onDelete('cascade');
$table->foreignId('exam_id')->constrained()->onDelete('cascade');
$table->timestamp('started_at')->nullable(); // 시험 시작 시간
$table->timestamp('submitted_at')->nullable(); // 제출 시간
$table->json('answers')->nullable(); // 사용자 답안 (JSON)
$table->integer('score')->nullable(); // 총점
$table->boolean('passed')->default(false); // 합격 여부
$table->timestamps();
```

5. 마이그레이션 실행:
```bash
php artisan migrate
```

6. 모델 관계 설정:
- `app/Models/Exam.php`에 `questions()`, `attempts()` 관계 추가
- `app/Models/Question.php`에 `exam()` 관계 추가
- `app/Models/ExamAttempt.php`에 `user()`, `exam()` 관계 추가
- `app/Models/User.php`에 `examAttempts()` 관계 추가

시더(Seeder)로 샘플 데이터 생성:

1. **DatabaseSeeder 작성**:
```bash
php artisan make:seeder ExamSeeder
```

`database/seeders/ExamSeeder.php`:
```php
use App\Models\Exam;
use App\Models\Question;
use App\Models\User;

public function run()
{
    // 관리자 계정 생성
    User::create([
        'name' => 'Admin User',
        'email' => 'admin@example.com',
        'password' => bcrypt('password'),
        'role' => 'admin',
    ]);

    // 응시자 계정 생성
    User::create([
        'name' => 'Test Examinee',
        'email' => 'examinee@example.com',
        'password' => bcrypt('password'),
        'role' => 'examinee',
    ]);

    // 샘플 시험 1: Laravel 기초
    $exam1 = Exam::create([
        'title' => 'Laravel 기초 자격증 시험',
        'description' => 'Laravel 프레임워크의 기본 개념을 테스트합니다.',
        'duration_minutes' => 30,
        'passing_score' => 70,
        'status' => 'published',
        'category' => '프로그래밍',
        'difficulty' => 'beginner',
        'allow_retake' => true,
    ]);

    Question::create([
        'exam_id' => $exam1->id,
        'question_text' => 'Laravel의 ORM 이름은 무엇인가요?',
        'question_type' => 'multiple_choice',
        'options' => json_encode(['Doctrine', 'Eloquent', 'Propel', 'ActiveRecord']),
        'correct_answer' => 'Eloquent',
        'points' => 10,
        'order' => 1,
    ]);

    Question::create([
        'exam_id' => $exam1->id,
        'question_text' => 'Blade 템플릿 엔진의 확장자는?',
        'question_type' => 'multiple_choice',
        'options' => json_encode(['.tpl', '.blade.php', '.php', '.html']),
        'correct_answer' => '.blade.php',
        'points' => 10,
        'order' => 2,
    ]);

    // 샘플 시험 2: JavaScript 중급
    $exam2 = Exam::create([
        'title' => 'JavaScript ES6+ 자격증',
        'description' => '최신 JavaScript 문법과 기능을 평가합니다.',
        'duration_minutes' => 45,
        'passing_score' => 80,
        'status' => 'published',
        'category' => '프로그래밍',
        'difficulty' => 'intermediate',
        'allow_retake' => false,
    ]);

    Question::create([
        'exam_id' => $exam2->id,
        'question_text' => 'Promise의 세 가지 상태가 아닌 것은?',
        'question_type' => 'multiple_choice',
        'options' => json_encode(['pending', 'fulfilled', 'rejected', 'completed']),
        'correct_answer' => 'completed',
        'points' => 15,
        'order' => 1,
    ]);
}
```

2. `database/seeders/DatabaseSeeder.php`에서 ExamSeeder 호출:
```php
public function run()
{
    $this->call(ExamSeeder::class);
}
```

3. 시더 실행:
```bash
php artisan db:seed
```

4. 데이터 확인:
- Tinker로 확인: `php artisan tinker` → `Exam::with('questions')->get()`
- 또는 DB 브라우저 도구로 SQLite 파일 열기

응시자용 홈 화면 및 시험 목록 페이지 구현:

1. **ExamController 생성**:
```bash
php artisan make:controller ExamController
```

`app/Http/Controllers/ExamController.php`:
```php
use App\Models\Exam;

public function index(Request $request)
{
    $query = Exam::where('status', 'published');

    // 카테고리 필터
    if ($request->filled('category')) {
        $query->where('category', $request->category);
    }

    // 난이도 필터
    if ($request->filled('difficulty')) {
        $query->where('difficulty', $request->difficulty);
    }

    $exams = $query->withCount('questions')->latest()->paginate(9);
    $categories = Exam::distinct()->pluck('category');

    return view('exams.index', compact('exams', 'categories'));
}

public function show(Exam $exam)
{
    if ($exam->status !== 'published') {
        abort(403, '공개되지 않은 시험입니다.');
    }

    $exam->load('questions');
    $userAttempts = auth()->check() 
        ? auth()->user()->examAttempts()->where('exam_id', $exam->id)->get() 
        : collect();

    return view('exams.show', compact('exam', 'userAttempts'));
}
```

2. **라우트 설정** (`routes/web.php`):
```php
use App\Http\Controllers\ExamController;

Route::get('/', [ExamController::class, 'index'])->name('home');
Route::get('/exams/{exam}', [ExamController::class, 'show'])->name('exams.show');
```

3. **Blade 뷰 생성**:

`resources/views/exams/index.blade.php`:
```blade
<x-app-layout>
    <div class="py-12">
        <div class="max-w-7xl mx-auto sm:px-6 lg:px-8">
            <h1 class="text-3xl font-bold mb-8">📚 온라인 자격증 시험</h1>

            <!-- 필터 -->
            <form method="GET" class="mb-8 flex gap-4">
                <select name="category" class="rounded-md border-gray-300">
                    <option value="">전체 카테고리</option>
                    @foreach($categories as $cat)
                        <option value="{{ $cat }}" {{ request('category') == $cat ? 'selected' : '' }}>
                            {{ $cat }}
                        </option>
                    @endforeach
                </select>
                <select name="difficulty" class="rounded-md border-gray-300">
                    <option value="">전체 난이도</option>
                    <option value="beginner" {{ request('difficulty') == 'beginner' ? 'selected' : '' }}>초급</option>
                    <option value="intermediate" {{ request('difficulty') == 'intermediate' ? 'selected' : '' }}>중급</option>
                    <option value="advanced" {{ request('difficulty') == 'advanced' ? 'selected' : '' }}>고급</option>
                </select>
                <button type="submit" class="bg-blue-600 text-white px-4 py-2 rounded-md">필터 적용</button>
            </form>

            <!-- 시험 카드 그리드 -->
            <div class="grid grid-cols-1 md:grid-cols-3 gap-6">
                @foreach($exams as $exam)
                    <div class="bg-white rounded-lg shadow-md p-6 hover:shadow-lg transition">
                        <div class="flex items-center justify-between mb-4">
                            <span class="bg-blue-100 text-blue-800 text-xs px-2 py-1 rounded">{{ $exam->category }}</span>
                            <span class="text-xs text-gray-500">{{ $exam->difficulty }}</span>
                        </div>
                        <h2 class="text-xl font-bold mb-2">{{ $exam->title }}</h2>
                        <p class="text-gray-600 text-sm mb-4">{{ Str::limit($exam->description, 100) }}</p>
                        <div class="flex items-center justify-between text-sm text-gray-500 mb-4">
                            <span>⏱️ {{ $exam->duration_minutes }}분</span>
                            <span>📝 {{ $exam->questions_count }}문제</span>
                            <span>✅ {{ $exam->passing_score }}점</span>
                        </div>
                        <a href="{{ route('exams.show', $exam) }}" class="block bg-blue-600 text-white text-center py-2 rounded-md hover:bg-blue-700">
                            시험 보기
                        </a>
                    </div>
                @endforeach
            </div>

            <div class="mt-8">
                {{ $exams->links() }}
            </div>
        </div>
    </div>
</x-app-layout>
```

`resources/views/exams/show.blade.php`:
```blade
<x-app-layout>
    <div class="py-12">
        <div class="max-w-4xl mx-auto sm:px-6 lg:px-8">
            <div class="bg-white rounded-lg shadow-md p-8">
                <h1 class="text-3xl font-bold mb-4">{{ $exam->title }}</h1>
                <p class="text-gray-600 mb-6">{{ $exam->description }}</p>

                <div class="grid grid-cols-2 gap-4 mb-8">
                    <div class="border-l-4 border-blue-500 pl-4">
                        <p class="text-sm text-gray-500">제한 시간</p>
                        <p class="text-xl font-bold">{{ $exam->duration_minutes }}분</p>
                    </div>
                    <div class="border-l-4 border-green-500 pl-4">
                        <p class="text-sm text-gray-500">합격 점수</p>
                        <p class="text-xl font-bold">{{ $exam->passing_score }}점</p>
                    </div>
                    <div class="border-l-4 border-purple-500 pl-4">
                        <p class="text-sm text-gray-500">총 문제 수</p>
                        <p class="text-xl font-bold">{{ $exam->questions->count() }}문제</p>
                    </div>
                    <div class="border-l-4 border-orange-500 pl-4">
                        <p class="text-sm text-gray-500">재응시</p>
                        <p class="text-xl font-bold">{{ $exam->allow_retake ? '가능' : '불가' }}</p>
                    </div>
                </div>

                @if($userAttempts->isNotEmpty())
                    <div class="bg-yellow-50 border border-yellow-200 rounded-md p-4 mb-6">
                        <h3 class="font-bold mb-2">📊 응시 기록</h3>
                        @foreach($userAttempts as $attempt)
                            <p class="text-sm">{{ $attempt->created_at->format('Y-m-d H:i') }} - 점수: {{ $attempt->score }}점 ({{ $attempt->passed ? '✅ 합격' : '❌ 불합격' }})</p>
                        @endforeach
                    </div>
                @endif

                @auth
                    <a href="{{ route('exams.start', $exam) }}" class="block bg-blue-600 text-white text-center py-3 rounded-md hover:bg-blue-700 font-bold">
                        🚀 시험 시작하기
                    </a>
                @else
                    <p class="text-center text-gray-500">로그인 후 시험을 응시할 수 있습니다.</p>
                    <a href="{{ route('login') }}" class="block bg-gray-600 text-white text-center py-3 rounded-md hover:bg-gray-700 mt-4">
                        로그인
                    </a>
                @endauth
            </div>
        </div>
    </div>
</x-app-layout>
```

시험 응시 페이지 구현 (실시간 타이머 포함):

1. **ExamController에 응시 관련 메서드 추가**:
```php
public function start(Exam $exam)
{
    if ($exam->status !== 'published') {
        abort(403);
    }

    // 재응시 불가 시험인 경우 기존 응시 기록 확인
    if (!$exam->allow_retake) {
        $existingAttempt = auth()->user()->examAttempts()
            ->where('exam_id', $exam->id)
            ->whereNotNull('submitted_at')
            ->first();

        if ($existingAttempt) {
            return redirect()->route('exams.result', $existingAttempt->id)
                ->with('error', '이미 응시한 시험입니다.');
        }
    }

    // 새 응시 기록 생성
    $attempt = auth()->user()->examAttempts()->create([
        'exam_id' => $exam->id,
        'started_at' => now(),
    ]);

    return redirect()->route('exams.take', $attempt->id);
}

public function take(ExamAttempt $attempt)
{
    if ($attempt->user_id !== auth()->id()) {
        abort(403);
    }

    if ($attempt->submitted_at) {
        return redirect()->route('exams.result', $attempt->id);
    }

    $exam = $attempt->exam->load('questions');
    $endTime = $attempt->started_at->addMinutes($exam->duration_minutes);

    return view('exams.take', compact('attempt', 'exam', 'endTime'));
}

public function saveAnswer(Request $request, ExamAttempt $attempt)
{
    if ($attempt->user_id !== auth()->id() || $attempt->submitted_at) {
        return response()->json(['error' => 'Unauthorized'], 403);
    }

    $answers = $attempt->answers ?? [];
    $answers[$request->question_id] = $request->answer;
    $attempt->update(['answers' => $answers]);

    return response()->json(['success' => true]);
}

public function submit(ExamAttempt $attempt)
{
    if ($attempt->user_id !== auth()->id() || $attempt->submitted_at) {
        abort(403);
    }

    $exam = $attempt->exam->load('questions');
    $answers = $attempt->answers ?? [];
    $score = 0;

    // 자동 채점 (객관식만)
    foreach ($exam->questions as $question) {
        $userAnswer = $answers[$question->id] ?? null;
        if ($question->question_type === 'multiple_choice' && $userAnswer === $question->correct_answer) {
            $score += $question->points;
        }
    }

    $attempt->update([
        'submitted_at' => now(),
        'score' => $score,
        'passed' => $score >= $exam->passing_score,
    ]);

    return redirect()->route('exams.result', $attempt->id);
}
```

2. **라우트 추가**:
```php
Route::middleware('auth')->group(function () {
    Route::post('/exams/{exam}/start', [ExamController::class, 'start'])->name('exams.start');
    Route::get('/attempts/{attempt}', [ExamController::class, 'take'])->name('exams.take');
    Route::post('/attempts/{attempt}/answer', [ExamController::class, 'saveAnswer'])->name('exams.saveAnswer');
    Route::post('/attempts/{attempt}/submit', [ExamController::class, 'submit'])->name('exams.submit');
});
```

3. **Blade 뷰 생성** (`resources/views/exams/take.blade.php`):
```blade
<x-app-layout>
    <div class="py-12" x-data="examTimer(@js($endTime))">
        <div class="max-w-5xl mx-auto sm:px-6 lg:px-8">
            <!-- 타이머 & 진행률 -->
            <div class="bg-white rounded-lg shadow-md p-4 mb-6 flex justify-between items-center">
                <div>
                    <h2 class="text-xl font-bold">{{ $exam->title }}</h2>
                    <p class="text-sm text-gray-500">문제 <span x-text="currentQuestion">1</span> / {{ $exam->questions->count() }}</p>
                </div>
                <div class="text-right">
                    <p class="text-sm text-gray-500">남은 시간</p>
                    <p class="text-2xl font-bold" :class="timeLeft < 300 ? 'text-red-600' : 'text-green-600'" x-text="formatTime(timeLeft)"></p>
                </div>
            </div>

            <!-- 문제 -->
            <div class="bg-white rounded-lg shadow-md p-8">
                @foreach($exam->questions as $index => $question)
                    <div class="mb-8" x-show="currentQuestion === {{ $index + 1 }}">
                        <h3 class="text-lg font-bold mb-4">{{ $index + 1 }}. {{ $question->question_text }}</h3>

                        @if($question->question_type === 'multiple_choice')
                            <div class="space-y-3">
                                @foreach(json_decode($question->options) as $option)
                                    <label class="flex items-center p-3 border rounded-md hover:bg-gray-50 cursor-pointer">
                                        <input type="radio" name="question_{{ $question->id }}" value="{{ $option }}" class="mr-3" @change="saveAnswer({{ $question->id }}, $event.target.value)">
                                        <span>{{ $option }}</span>
                                    </label>
                                @endforeach
                            </div>
                        @else
                            <input type="text" class="w-full border-gray-300 rounded-md" placeholder="답을 입력하세요" @input="saveAnswer({{ $question->id }}, $event.target.value)">
                        @endif
                    </div>
                @endforeach

                <!-- 네비게이션 -->
                <div class="flex justify-between mt-8">
                    <button @click="currentQuestion > 1 && currentQuestion--" class="bg-gray-300 px-4 py-2 rounded-md" :disabled="currentQuestion === 1">이전</button>
                    <button @click="currentQuestion < {{ $exam->questions->count() }} && currentQuestion++" class="bg-blue-600 text-white px-4 py-2 rounded-md" :disabled="currentQuestion === {{ $exam->questions->count() }}">다음</button>
                </div>

                <!-- 제출 버튼 -->
                <form method="POST" action="{{ route('exams.submit', $attempt) }}" class="mt-8">
                    @csrf
                    <button type="submit" class="w-full bg-green-600 text-white py-3 rounded-md font-bold hover:bg-green-700">
                        🎯 시험 제출하기
                    </button>
                </form>
            </div>
        </div>
    </div>

    <script>
        function examTimer(endTime) {
            return {
                currentQuestion: 1,
                timeLeft: Math.floor((new Date(endTime) - new Date()) / 1000),
                interval: null,

                init() {
                    this.interval = setInterval(() => {
                        this.timeLeft--;
                        if (this.timeLeft <= 0) {
                            clearInterval(this.interval);
                            document.querySelector('form').submit(); // 자동 제출
                        }
                    }, 1000);
                },

                formatTime(seconds) {
                    const mins = Math.floor(seconds / 60);
                    const secs = seconds % 60;
                    return `${mins}:${secs.toString().padStart(2, '0')}`;
                },

                saveAnswer(questionId, answer) {
                    fetch(`/attempts/{{ $attempt->id }}/answer`, {
                        method: 'POST',
                        headers: {
                            'Content-Type': 'application/json',
                            'X-CSRF-TOKEN': document.querySelector('meta[name="csrf-token"]').content
                        },
                        body: JSON.stringify({ question_id: questionId, answer: answer })
                    });
                }
            }
        }
    </script>
</x-app-layout>
```

결과 페이지 및 마이페이지 구현:

1. **ExamController에 결과 메서드 추가**:
```php
public function result(ExamAttempt $attempt)
{
    if ($attempt->user_id !== auth()->id()) {
        abort(403);
    }

    if (!$attempt->submitted_at) {
        return redirect()->route('exams.take', $attempt->id);
    }

    $exam = $attempt->exam->load('questions');
    $answers = $attempt->answers ?? [];

    // 문제별 정오답 분석
    $results = $exam->questions->map(function ($question) use ($answers) {
        $userAnswer = $answers[$question->id] ?? null;
        return [
            'question' => $question,
            'user_answer' => $userAnswer,
            'is_correct' => $question->question_type === 'multiple_choice' && $userAnswer === $question->correct_answer,
        ];
    });

    return view('exams.result', compact('attempt', 'exam', 'results'));
}
```

2. **라우트 추가**:
```php
Route::middleware('auth')->group(function () {
    Route::get('/attempts/{attempt}/result', [ExamController::class, 'result'])->name('exams.result');
    Route::get('/my-exams', [ExamController::class, 'myExams'])->name('exams.my');
});
```

3. **Blade 뷰** (`resources/views/exams/result.blade.php`):
```blade
<x-app-layout>
    <div class="py-12">
        <div class="max-w-4xl mx-auto sm:px-6 lg:px-8">
            <!-- 결과 요약 -->
            <div class="bg-white rounded-lg shadow-md p-8 mb-6 text-center">
                @if($attempt->passed)
                    <div class="text-6xl mb-4">🎉</div>
                    <h1 class="text-3xl font-bold text-green-600 mb-2">합격을 축하합니다!</h1>
                @else
                    <div class="text-6xl mb-4">😢</div>
                    <h1 class="text-3xl font-bold text-red-600 mb-2">아쉽게도 불합격입니다</h1>
                @endif

                <div class="grid grid-cols-3 gap-4 mt-8">
                    <div class="border-l-4 border-blue-500 pl-4">
                        <p class="text-sm text-gray-500">취득 점수</p>
                        <p class="text-3xl font-bold">{{ $attempt->score }}점</p>
                    </div>
                    <div class="border-l-4 border-green-500 pl-4">
                        <p class="text-sm text-gray-500">합격 점수</p>
                        <p class="text-3xl font-bold">{{ $exam->passing_score }}점</p>
                    </div>
                    <div class="border-l-4 border-purple-500 pl-4">
                        <p class="text-sm text-gray-500">정답률</p>
                        <p class="text-3xl font-bold">{{ round(($results->where('is_correct', true)->count() / $results->count()) * 100) }}%</p>
                    </div>
                </div>
            </div>

            <!-- 문제별 상세 결과 -->
            <div class="bg-white rounded-lg shadow-md p-8">
                <h2 class="text-2xl font-bold mb-6">📝 문제별 상세 결과</h2>

                @foreach($results as $index => $result)
                    <div class="mb-6 pb-6 border-b">
                        <div class="flex items-start justify-between">
                            <h3 class="text-lg font-bold mb-2">{{ $index + 1 }}. {{ $result['question']->question_text }}</h3>
                            @if($result['is_correct'])
                                <span class="bg-green-100 text-green-800 text-xs px-2 py-1 rounded">✅ 정답</span>
                            @else
                                <span class="bg-red-100 text-red-800 text-xs px-2 py-1 rounded">❌ 오답</span>
                            @endif
                        </div>

                        <p class="text-sm text-gray-600 mt-2">당신의 답: <strong>{{ $result['user_answer'] ?? '미응답' }}</strong></p>
                        @if(!$result['is_correct'])
                            <p class="text-sm text-green-600 mt-1">정답: <strong>{{ $result['question']->correct_answer }}</strong></p>
                        @endif
                    </div>
                @endforeach
            </div>

            <div class="mt-6 flex gap-4">
                <a href="{{ route('home') }}" class="flex-1 bg-gray-600 text-white text-center py-3 rounded-md hover:bg-gray-700">
                    🏠 홈으로
                </a>
                @if($exam->allow_retake)
                    <a href="{{ route('exams.show', $exam) }}" class="flex-1 bg-blue-600 text-white text-center py-3 rounded-md hover:bg-blue-700">
                        🔄 다시 도전하기
                    </a>
                @endif
            </div>
        </div>
    </div>
</x-app-layout>
```

4. **마이페이지 뷰** (`resources/views/exams/my.blade.php`):
```blade
<x-app-layout>
    <div class="py-12">
        <div class="max-w-5xl mx-auto sm:px-6 lg:px-8">
            <h1 class="text-3xl font-bold mb-8">📊 나의 응시 기록</h1>

            <div class="bg-white rounded-lg shadow-md overflow-hidden">
                <table class="w-full">
                    <thead class="bg-gray-100">
                        <tr>
                            <th class="px-6 py-3 text-left">시험명</th>
                            <th class="px-6 py-3 text-left">응시일</th>
                            <th class="px-6 py-3 text-left">점수</th>
                            <th class="px-6 py-3 text-left">결과</th>
                            <th class="px-6 py-3 text-left">상세</th>
                        </tr>
                    </thead>
                    <tbody>
                        @forelse(auth()->user()->examAttempts()->with('exam')->latest()->get() as $attempt)
                            <tr class="border-b">
                                <td class="px-6 py-4">{{ $attempt->exam->title }}</td>
                                <td class="px-6 py-4">{{ $attempt->created_at->format('Y-m-d H:i') }}</td>
                                <td class="px-6 py-4 font-bold">{{ $attempt->score }}점</td>
                                <td class="px-6 py-4">
                                    @if($attempt->passed)
                                        <span class="bg-green-100 text-green-800 text-xs px-2 py-1 rounded">✅ 합격</span>
                                    @else
                                        <span class="bg-red-100 text-red-800 text-xs px-2 py-1 rounded">❌ 불합격</span>
                                    @endif
                                </td>
                                <td class="px-6 py-4">
                                    <a href="{{ route('exams.result', $attempt) }}" class="text-blue-600 hover:underline">결과 보기</a>
                                </td>
                            </tr>
                        @empty
                            <tr>
                                <td colspan="5" class="px-6 py-8 text-center text-gray-500">아직 응시한 시험이 없습니다.</td>
                            </tr>
                        @endforelse
                    </tbody>
                </table>
            </div>
        </div>
    </div>
</x-app-layout>
```

5. **네비게이션에 마이페이지 링크 추가** (`resources/views/layouts/navigation.blade.php`):
```blade
<x-nav-link :href="route('exams.my')" :active="request()->routeIs('exams.my')">
    나의 시험 기록
</x-nav-link>
```

관리자 패널 구현 (시험/문제 CRUD):

1. **Policy 생성** (관리자만 접근):
```bash
php artisan make:policy ExamPolicy --model=Exam
```

`app/Policies/ExamPolicy.php`:
```php
public function viewAny(User $user)
{
    return $user->role === 'admin';
}

public function create(User $user)
{
    return $user->role === 'admin';
}

public function update(User $user, Exam $exam)
{
    return $user->role === 'admin';
}

public function delete(User $user, Exam $exam)
{
    return $user->role === 'admin';
}
```

2. **AdminExamController 생성**:
```bash
php artisan make:controller Admin/ExamController --resource
```

`app/Http/Controllers/Admin/ExamController.php`:
```php
namespace App\Http\Controllers\Admin;

use App\Http\Controllers\Controller;
use App\Models\Exam;
use Illuminate\Http\Request;

public function __construct()
{
    $this->authorizeResource(Exam::class, 'exam');
}

public function index()
{
    $exams = Exam::withCount('questions', 'attempts')->latest()->paginate(10);
    return view('admin.exams.index', compact('exams'));
}

public function create()
{
    return view('admin.exams.create');
}

public function store(Request $request)
{
    $validated = $request->validate([
        'title' => 'required|max:255',
        'description' => 'nullable',
        'duration_minutes' => 'required|integer|min:1',
        'passing_score' => 'required|integer|min:0|max:100',
        'category' => 'required|max:100',
        'difficulty' => 'required|in:beginner,intermediate,advanced',
        'status' => 'required|in:draft,published',
        'allow_retake' => 'boolean',
    ]);

    Exam::create($validated);

    return redirect()->route('admin.exams.index')->with('success', '시험이 생성되었습니다.');
}

public function edit(Exam $exam)
{
    return view('admin.exams.edit', compact('exam'));
}

public function update(Request $request, Exam $exam)
{
    $validated = $request->validate([
        'title' => 'required|max:255',
        'description' => 'nullable',
        'duration_minutes' => 'required|integer|min:1',
        'passing_score' => 'required|integer|min:0|max:100',
        'category' => 'required|max:100',
        'difficulty' => 'required|in:beginner,intermediate,advanced',
        'status' => 'required|in:draft,published',
        'allow_retake' => 'boolean',
    ]);

    $exam->update($validated);

    return redirect()->route('admin.exams.index')->with('success', '시험이 수정되었습니다.');
}

public function destroy(Exam $exam)
{
    $exam->delete();
    return redirect()->route('admin.exams.index')->with('success', '시험이 삭제되었습니다.');
}
```

3. **라우트 설정** (`routes/web.php`):
```php
use App\Http\Controllers\Admin\ExamController as AdminExamController;

Route::middleware(['auth'])->prefix('admin')->name('admin.')->group(function () {
    Route::resource('exams', AdminExamController::class);
});
```

4. **Blade 뷰** (`resources/views/admin/exams/index.blade.php`):
```blade
<x-app-layout>
    <div class="py-12">
        <div class="max-w-7xl mx-auto sm:px-6 lg:px-8">
            <div class="flex justify-between items-center mb-8">
                <h1 class="text-3xl font-bold">🎓 시험 관리</h1>
                <a href="{{ route('admin.exams.create') }}" class="bg-blue-600 text-white px-4 py-2 rounded-md hover:bg-blue-700">
                    + 새 시험 만들기
                </a>
            </div>

            @if(session('success'))
                <div class="bg-green-100 border border-green-400 text-green-700 px-4 py-3 rounded mb-4">
                    {{ session('success') }}
                </div>
            @endif

            <div class="bg-white rounded-lg shadow-md overflow-hidden">
                <table class="w-full">
                    <thead class="bg-gray-100">
                        <tr>
                            <th class="px-6 py-3 text-left">제목</th>
                            <th class="px-6 py-3 text-left">카테고리</th>
                            <th class="px-6 py-3 text-left">문제 수</th>
                            <th class="px-6 py-3 text-left">응시자 수</th>
                            <th class="px-6 py-3 text-left">상태</th>
                            <th class="px-6 py-3 text-left">관리</th>
                        </tr>
                    </thead>
                    <tbody>
                        @foreach($exams as $exam)
                            <tr class="border-b">
                                <td class="px-6 py-4 font-bold">{{ $exam->title }}</td>
                                <td class="px-6 py-4">{{ $exam->category }}</td>
                                <td class="px-6 py-4">{{ $exam->questions_count }}문제</td>
                                <td class="px-6 py-4">{{ $exam->attempts_count }}명</td>
                                <td class="px-6 py-4">
                                    @if($exam->status === 'published')
                                        <span class="bg-green-100 text-green-800 text-xs px-2 py-1 rounded">공개</span>
                                    @else
                                        <span class="bg-gray-100 text-gray-800 text-xs px-2 py-1 rounded">비공개</span>
                                    @endif
                                </td>
                                <td class="px-6 py-4 flex gap-2">
                                    <a href="{{ route('admin.exams.edit', $exam) }}" class="text-blue-600 hover:underline">수정</a>
                                    <form method="POST" action="{{ route('admin.exams.destroy', $exam) }}" onsubmit="return confirm('정말 삭제하시겠습니까?')">
                                        @csrf
                                        @method('DELETE')
                                        <button type="submit" class="text-red-600 hover:underline">삭제</button>
                                    </form>
                                </td>
                            </tr>
                        @endforeach
                    </tbody>
                </table>
            </div>

            <div class="mt-6">
                {{ $exams->links() }}
            </div>
        </div>
    </div>
</x-app-layout>
```

5. **시험 생성/수정 폼** (`resources/views/admin/exams/create.blade.php`, `edit.blade.php`):
```blade
<x-app-layout>
    <div class="py-12">
        <div class="max-w-3xl mx-auto sm:px-6 lg:px-8">
            <h1 class="text-3xl font-bold mb-8">{{ isset($exam) ? '시험 수정' : '새 시험 만들기' }}</h1>

            <form method="POST" action="{{ isset($exam) ? route('admin.exams.update', $exam) : route('admin.exams.store') }}" class="bg-white rounded-lg shadow-md p-8">
                @csrf
                @if(isset($exam))
                    @method('PUT')
                @endif

                <div class="mb-6">
                    <label class="block text-sm font-bold mb-2">시험 제목 *</label>
                    <input type="text" name="title" value="{{ old('title', $exam->title ?? '') }}" class="w-full border-gray-300 rounded-md" required>
                    @error('title')<p class="text-red-600 text-sm mt-1">{{ $message }}</p>@enderror
                </div>

                <div class="mb-6">
                    <label class="block text-sm font-bold mb-2">설명</label>
                    <textarea name="description" rows="4" class="w-full border-gray-300 rounded-md">{{ old('description', $exam->description ?? '') }}</textarea>
                </div>

                <div class="grid grid-cols-2 gap-4 mb-6">
                    <div>
                        <label class="block text-sm font-bold mb-2">제한 시간 (분) *</label>
                        <input type="number" name="duration_minutes" value="{{ old('duration_minutes', $exam->duration_minutes ?? 30) }}" class="w-full border-gray-300 rounded-md" required>
                    </div>
                    <div>
                        <label class="block text-sm font-bold mb-2">합격 점수 *</label>
                        <input type="number" name="passing_score" value="{{ old('passing_score', $exam->passing_score ?? 70) }}" class="w-full border-gray-300 rounded-md" required>
                    </div>
                </div>

                <div class="grid grid-cols-2 gap-4 mb-6">
                    <div>
                        <label class="block text-sm font-bold mb-2">카테고리 *</label>
                        <input type="text" name="category" value="{{ old('category', $exam->category ?? '') }}" class="w-full border-gray-300 rounded-md" required>
                    </div>
                    <div>
                        <label class="block text-sm font-bold mb-2">난이도 *</label>
                        <select name="difficulty" class="w-full border-gray-300 rounded-md" required>
                            <option value="beginner" {{ old('difficulty', $exam->difficulty ?? '') === 'beginner' ? 'selected' : '' }}>초급</option>
                            <option value="intermediate" {{ old('difficulty', $exam->difficulty ?? '') === 'intermediate' ? 'selected' : '' }}>중급</option>
                            <option value="advanced" {{ old('difficulty', $exam->difficulty ?? '') === 'advanced' ? 'selected' : '' }}>고급</option>
                        </select>
                    </div>
                </div>

                <div class="mb-6">
                    <label class="block text-sm font-bold mb-2">공개 상태 *</label>
                    <select name="status" class="w-full border-gray-300 rounded-md" required>
                        <option value="draft" {{ old('status', $exam->status ?? '') === 'draft' ? 'selected' : '' }}>비공개</option>
                        <option value="published" {{ old('status', $exam->status ?? '') === 'published' ? 'selected' : '' }}>공개</option>
                    </select>
                </div>

                <div class="mb-6">
                    <label class="flex items-center">
                        <input type="checkbox" name="allow_retake" value="1" {{ old('allow_retake', $exam->allow_retake ?? true) ? 'checked' : '' }} class="mr-2">
                        <span class="text-sm">재응시 허용</span>
                    </label>
                </div>

                <button type="submit" class="w-full bg-blue-600 text-white py-3 rounded-md font-bold hover:bg-blue-700">
                    {{ isset($exam) ? '수정하기' : '생성하기' }}
                </button>
            </form>
        </div>
    </div>
</x-app-layout>
```

문제 관리 시스템 구현:

1. **QuestionController 생성**:
```bash
php artisan make:controller Admin/QuestionController --resource
```

`app/Http/Controllers/Admin/QuestionController.php`:
```php
namespace App\Http\Controllers\Admin;

use App\Http\Controllers\Controller;
use App\Models\Exam;
use App\Models\Question;
use Illuminate\Http\Request;

public function index(Exam $exam)
{
    $this->authorize('update', $exam);
    $questions = $exam->questions()->orderBy('order')->get();
    return view('admin.questions.index', compact('exam', 'questions'));
}

public function create(Exam $exam)
{
    $this->authorize('update', $exam);
    return view('admin.questions.create', compact('exam'));
}

public function store(Request $request, Exam $exam)
{
    $this->authorize('update', $exam);

    $validated = $request->validate([
        'question_text' => 'required',
        'question_type' => 'required|in:multiple_choice,short_answer',
        'options' => 'required_if:question_type,multiple_choice|array|min:2',
        'options.*' => 'required_if:question_type,multiple_choice|string',
        'correct_answer' => 'required',
        'points' => 'required|integer|min:1',
    ]);

    $validated['exam_id'] = $exam->id;
    $validated['order'] = $exam->questions()->max('order') + 1;
    $validated['options'] = $request->question_type === 'multiple_choice' ? json_encode($request->options) : null;

    Question::create($validated);

    return redirect()->route('admin.questions.index', $exam)->with('success', '문제가 추가되었습니다.');
}

public function edit(Exam $exam, Question $question)
{
    $this->authorize('update', $exam);
    return view('admin.questions.edit', compact('exam', 'question'));
}

public function update(Request $request, Exam $exam, Question $question)
{
    $this->authorize('update', $exam);

    $validated = $request->validate([
        'question_text' => 'required',
        'question_type' => 'required|in:multiple_choice,short_answer',
        'options' => 'required_if:question_type,multiple_choice|array|min:2',
        'options.*' => 'required_if:question_type,multiple_choice|string',
        'correct_answer' => 'required',
        'points' => 'required|integer|min:1',
    ]);

    $validated['options'] = $request->question_type === 'multiple_choice' ? json_encode($request->options) : null;
    $question->update($validated);

    return redirect()->route('admin.questions.index', $exam)->with('success', '문제가 수정되었습니다.');
}

public function destroy(Exam $exam, Question $question)
{
    $this->authorize('update', $exam);
    $question->delete();
    return redirect()->route('admin.questions.index', $exam)->with('success', '문제가 삭제되었습니다.');
}
```

2. **라우트 추가**:
```php
Route::middleware(['auth'])->prefix('admin')->name('admin.')->group(function () {
    Route::resource('exams', AdminExamController::class);
    Route::resource('exams.questions', QuestionController::class)->except(['show']);
});
```

3. **문제 목록 뷰** (`resources/views/admin/questions/index.blade.php`):
```blade
<x-app-layout>
    <div class="py-12">
        <div class="max-w-5xl mx-auto sm:px-6 lg:px-8">
            <div class="flex justify-between items-center mb-8">
                <div>
                    <h1 class="text-3xl font-bold">📝 문제 관리</h1>
                    <p class="text-gray-600 mt-2">시험: {{ $exam->title }}</p>
                </div>
                <div class="flex gap-2">
                    <a href="{{ route('admin.exams.index') }}" class="bg-gray-600 text-white px-4 py-2 rounded-md hover:bg-gray-700">← 시험 목록</a>
                    <a href="{{ route('admin.questions.create', $exam) }}" class="bg-blue-600 text-white px-4 py-2 rounded-md hover:bg-blue-700">+ 문제 추가</a>
                </div>
            </div>

            @if(session('success'))
                <div class="bg-green-100 border border-green-400 text-green-700 px-4 py-3 rounded mb-4">
                    {{ session('success') }}
                </div>
            @endif

            <div class="space-y-4">
                @forelse($questions as $question)
                    <div class="bg-white rounded-lg shadow-md p-6">
                        <div class="flex justify-between items-start">
                            <div class="flex-1">
                                <h3 class="text-lg font-bold mb-2">{{ $question->order }}. {{ $question->question_text }}</h3>
                                @if($question->question_type === 'multiple_choice')
                                    <div class="space-y-1 text-sm text-gray-600">
                                        @foreach(json_decode($question->options) as $option)
                                            <p class="{{ $option === $question->correct_answer ? 'text-green-600 font-bold' : '' }}">
                                                {{ $option === $question->correct_answer ? '✅' : '○' }} {{ $option }}
                                            </p>
                                        @endforeach
                                    </div>
                                @else
                                    <p class="text-sm text-green-600">정답: {{ $question->correct_answer }}</p>
                                @endif
                                <p class="text-xs text-gray-500 mt-2">배점: {{ $question->points }}점</p>
                            </div>
                            <div class="flex gap-2">
                                <a href="{{ route('admin.questions.edit', [$exam, $question]) }}" class="text-blue-600 hover:underline text-sm">수정</a>
                                <form method="POST" action="{{ route('admin.questions.destroy', [$exam, $question]) }}" onsubmit="return confirm('정말 삭제하시겠습니까?')">
                                    @csrf
                                    @method('DELETE')
                                    <button type="submit" class="text-red-600 hover:underline text-sm">삭제</button>
                                </form>
                            </div>
                        </div>
                    </div>
                @empty
                    <div class="bg-white rounded-lg shadow-md p-8 text-center text-gray-500">
                        아직 등록된 문제가 없습니다. 첫 번째 문제를 추가해보세요!
                    </div>
                @endforelse
            </div>
        </div>
    </div>
</x-app-layout>
```

4. **문제 생성/수정 폼** (`resources/views/admin/questions/create.blade.php`, `edit.blade.php`):
```blade
<x-app-layout>
    <div class="py-12">
        <div class="max-w-3xl mx-auto sm:px-6 lg:px-8">
            <h1 class="text-3xl font-bold mb-8">{{ isset($question) ? '문제 수정' : '새 문제 추가' }}</h1>

            <form method="POST" action="{{ isset($question) ? route('admin.questions.update', [$exam, $question]) : route('admin.questions.store', $exam) }}" class="bg-white rounded-lg shadow-md p-8" x-data="questionForm()">
                @csrf
                @if(isset($question))
                    @method('PUT')
                @endif

                <div class="mb-6">
                    <label class="block text-sm font-bold mb-2">문제 유형 *</label>
                    <select name="question_type" x-model="questionType" class="w-full border-gray-300 rounded-md" required>
                        <option value="multiple_choice">객관식</option>
                        <option value="short_answer">주관식</option>
                    </select>
                </div>

                <div class="mb-6">
                    <label class="block text-sm font-bold mb-2">문제 내용 *</label>
                    <textarea name="question_text" rows="4" class="w-full border-gray-300 rounded-md" required>{{ old('question_text', $question->question_text ?? '') }}</textarea>
                </div>

                <div class="mb-6" x-show="questionType === 'multiple_choice'">
                    <label class="block text-sm font-bold mb-2">선택지 (최소 2개) *</label>
                    <template x-for="(option, index) in options" :key="index">
                        <div class="flex gap-2 mb-2">
                            <input type="text" :name="'options[' + index + ']'" x-model="options[index]" class="flex-1 border-gray-300 rounded-md" placeholder="선택지 입력">
                            <button type="button" @click="options.splice(index, 1)" class="bg-red-600 text-white px-3 py-2 rounded-md" x-show="options.length > 2">삭제</button>
                        </div>
                    </template>
                    <button type="button" @click="options.push('')" class="bg-gray-600 text-white px-4 py-2 rounded-md mt-2">+ 선택지 추가</button>
                </div>

                <div class="mb-6">
                    <label class="block text-sm font-bold mb-2">정답 *</label>
                    <input type="text" name="correct_answer" value="{{ old('correct_answer', $question->correct_answer ?? '') }}" class="w-full border-gray-300 rounded-md" required>
                    <p class="text-xs text-gray-500 mt-1">객관식인 경우 위 선택지 중 하나를 정확히 입력하세요.</p>
                </div>

                <div class="mb-6">
                    <label class="block text-sm font-bold mb-2">배점 *</label>
                    <input type="number" name="points" value="{{ old('points', $question->points ?? 10) }}" class="w-full border-gray-300 rounded-md" required>
                </div>

                <button type="submit" class="w-full bg-blue-600 text-white py-3 rounded-md font-bold hover:bg-blue-700">
                    {{ isset($question) ? '수정하기' : '추가하기' }}
                </button>
            </form>
        </div>
    </div>

    <script>
        function questionForm() {
            return {
                questionType: '{{ old('question_type', $question->question_type ?? 'multiple_choice') }}',
                options: @json(old('options', isset($question) && $question->options ? json_decode($question->options) : ['', '']))
            }
        }
    </script>
</x-app-layout>
```

통계 대시보드 및 보너스 기능 구현:

1. **통계 대시보드 추가** (`app/Http/Controllers/Admin/DashboardController.php`):
```bash
php artisan make:controller Admin/DashboardController
```

```php
namespace App\Http\Controllers\Admin;

use App\Http\Controllers\Controller;
use App\Models\Exam;
use App\Models\ExamAttempt;
use Illuminate\Support\Facades\DB;

public function index()
{
    $this->authorize('viewAny', Exam::class);

    $stats = [
        'total_exams' => Exam::count(),
        'total_attempts' => ExamAttempt::count(),
        'pass_rate' => ExamAttempt::whereNotNull('submitted_at')->avg('passed') * 100,
        'avg_score' => ExamAttempt::whereNotNull('submitted_at')->avg('score'),
    ];

    $recentAttempts = ExamAttempt::with(['user', 'exam'])
        ->whereNotNull('submitted_at')
        ->latest()
        ->take(10)
        ->get();

    $examStats = Exam::withCount('attempts')
        ->withAvg('attempts', 'score')
        ->get()
        ->map(function ($exam) {
            return [
                'title' => $exam->title,
                'attempts' => $exam->attempts_count,
                'avg_score' => round($exam->attempts_avg_score ?? 0, 1),
            ];
        });

    return view('admin.dashboard', compact('stats', 'recentAttempts', 'examStats'));
}
```

2. **라우트 추가**:
```php
Route::middleware(['auth'])->prefix('admin')->name('admin.')->group(function () {
    Route::get('/dashboard', [DashboardController::class, 'index'])->name('dashboard');
    // ... 기존 라우트
});
```

3. **대시보드 뷰** (`resources/views/admin/dashboard.blade.php`):
```blade
<x-app-layout>
    <div class="py-12">
        <div class="max-w-7xl mx-auto sm:px-6 lg:px-8">
            <h1 class="text-3xl font-bold mb-8">📊 관리자 대시보드</h1>

            <!-- 통계 카드 -->
            <div class="grid grid-cols-4 gap-6 mb-8">
                <div class="bg-white rounded-lg shadow-md p-6">
                    <p class="text-sm text-gray-500 mb-2">총 시험 수</p>
                    <p class="text-3xl font-bold">{{ $stats['total_exams'] }}</p>
                </div>
                <div class="bg-white rounded-lg shadow-md p-6">
                    <p class="text-sm text-gray-500 mb-2">총 응시 횟수</p>
                    <p class="text-3xl font-bold">{{ $stats['total_attempts'] }}</p>
                </div>
                <div class="bg-white rounded-lg shadow-md p-6">
                    <p class="text-sm text-gray-500 mb-2">평균 합격률</p>
                    <p class="text-3xl font-bold text-green-600">{{ round($stats['pass_rate'], 1) }}%</p>
                </div>
                <div class="bg-white rounded-lg shadow-md p-6">
                    <p class="text-sm text-gray-500 mb-2">평균 점수</p>
                    <p class="text-3xl font-bold text-blue-600">{{ round($stats['avg_score'], 1) }}점</p>
                </div>
            </div>

            <div class="grid grid-cols-2 gap-6">
                <!-- 시험별 통계 -->
                <div class="bg-white rounded-lg shadow-md p-6">
                    <h2 class="text-xl font-bold mb-4">시험별 통계</h2>
                    <canvas id="examChart"></canvas>
                </div>

                <!-- 최근 응시 기록 -->
                <div class="bg-white rounded-lg shadow-md p-6">
                    <h2 class="text-xl font-bold mb-4">최근 응시 기록</h2>
                    <div class="space-y-2">
                        @foreach($recentAttempts as $attempt)
                            <div class="flex justify-between items-center py-2 border-b">
                                <div>
                                    <p class="font-bold text-sm">{{ $attempt->user->name }}</p>
                                    <p class="text-xs text-gray-500">{{ $attempt->exam->title }}</p>
                                </div>
                                <div class="text-right">
                                    <p class="font-bold">{{ $attempt->score }}점</p>
                                    @if($attempt->passed)
                                        <span class="text-xs bg-green-100 text-green-800 px-2 py-1 rounded">합격</span>
                                    @else
                                        <span class="text-xs bg-red-100 text-red-800 px-2 py-1 rounded">불합격</span>
                                    @endif
                                </div>
                            </div>
                        @endforeach
                    </div>
                </div>
            </div>
        </div>
    </div>

    <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
    <script>
        const ctx = document.getElementById('examChart').getContext('2d');
        new Chart(ctx, {
            type: 'bar',
            data: {
                labels: @json($examStats->pluck('title')),
                datasets: [{
                    label: '평균 점수',
                    data: @json($examStats->pluck('avg_score')),
                    backgroundColor: 'rgba(59, 130, 246, 0.5)',
                    borderColor: 'rgb(59, 130, 246)',
                    borderWidth: 1
                }]
            },
            options: {
                responsive: true,
                scales: {
                    y: {
                        beginAtZero: true,
                        max: 100
                    }
                }
            }
        });
    </script>
</x-app-layout>
```

4. **네비게이션에 관리자 메뉴 추가** (`resources/views/layouts/navigation.blade.php`):
```blade
@if(auth()->user()->role === 'admin')
    <x-nav-link :href="route('admin.dashboard')" :active="request()->routeIs('admin.dashboard')">
        관리자 대시보드
    </x-nav-link>
    <x-nav-link :href="route('admin.exams.index')" :active="request()->routeIs('admin.exams.*')">
        시험 관리
    </x-nav-link>
@endif
```

5. **부정행위 방지 기능 추가** (시험 응시 페이지에 탭 전환 감지):

`resources/views/exams/take.blade.php`의 Alpine.js 데이터에 추가:
```javascript
warnings: 0,

init() {
    // 기존 init 코드...

    // 탭 전환 감지
    document.addEventListener('visibilitychange', () => {
        if (document.hidden) {
            this.warnings++;
            if (this.warnings >= 3) {
                alert('부정행위가 의심되어 시험이 자동 제출됩니다.');
                document.querySelector('form').submit();
            } else {
                alert(`경고: 탭 전환이 감지되었습니다. (${this.warnings}/3)`);
            }
        }
    });
}
```

최종 마무리 및 UI/UX 개선:

1. **다크모드 토글 추가** (`resources/views/layouts/app.blade.php`):

`<head>` 태그 안에 다크모드 스크립트 추가:
```html
<script>
    if (localStorage.theme === 'dark' || (!('theme' in localStorage) && window.matchMedia('(prefers-color-scheme: dark)').matches)) {
        document.documentElement.classList.add('dark')
    } else {
        document.documentElement.classList.remove('dark')
    }
</script>
```

네비게이션에 다크모드 토글 버튼 추가:
```blade
<button @click="toggleDarkMode()" class="p-2 rounded-md hover:bg-gray-100 dark:hover:bg-gray-800">
    <span x-show="!darkMode">🌙</span>
    <span x-show="darkMode">☀️</span>
</button>

<script>
    function toggleDarkMode() {
        if (document.documentElement.classList.contains('dark')) {
            document.documentElement.classList.remove('dark');
            localStorage.theme = 'light';
        } else {
            document.documentElement.classList.add('dark');
            localStorage.theme = 'dark';
        }
    }
</script>
```

2. **Tailwind 다크모드 설정** (`tailwind.config.js`):
```javascript
module.exports = {
    darkMode: 'class',
    // ... 기존 설정
}
```

3. **반응형 개선 및 애니메이션 추가**:

시험 카드 호버 효과 강화:
```blade
<div class="bg-white dark:bg-gray-800 rounded-lg shadow-md p-6 hover:shadow-xl hover:scale-105 transition-all duration-300">
```

타이머 애니메이션:
```blade
<p class="text-2xl font-bold transition-colors duration-300" 
   :class="timeLeft < 300 ? 'text-red-600 animate-pulse' : 'text-green-600'" 
   x-text="formatTime(timeLeft)">
</p>
```

4. **에러 핸들링 개선**:

`app/Exceptions/Handler.php`에서 403, 404 에러 커스텀 페이지 추가:
```php
public function render($request, Throwable $exception)
{
    if ($exception instanceof \Symfony\Component\HttpKernel\Exception\NotFoundHttpException) {
        return response()->view('errors.404', [], 404);
    }

    if ($exception instanceof \Symfony\Component\HttpKernel\Exception\AccessDeniedHttpException) {
        return response()->view('errors.403', [], 403);
    }

    return parent::render($request, $exception);
}
```

5. **README.md 작성**:
```markdown
# 🎓 온라인 자격증 시험 플랫폼

Laravel 13.x + Blade 템플릿으로 구현한 실시간 타이머 기반 온라인 시험 응시 시스템입니다.

## 주요 기능
- ✅ 실시간 카운트다운 타이머 (시간 초과 시 자동 제출)
- ✅ 객관식/주관식 문제 지원
- ✅ 자동 채점 시스템
- ✅ 합격/불합격 판정 및 결과 리포트
- ✅ 관리자 시험/문제 관리 CRUD
- ✅ 응시 기록 및 통계 대시보드
- ✅ 부정행위 방지 (탭 전환 감지)
- ✅ 다크모드 지원

## 설치 방법

1. 의존성 설치:
```bash
composer install
npm install
```

2. 환경 설정:
```bash
cp .env.example .env
php artisan key:generate
```

3. 데이터베이스 마이그레이션 및 시더:
```bash
touch database/database.sqlite
php artisan migrate --seed
```

4. 개발 서버 실행:
```bash
php artisan serve
npm run dev
```

## 기본 계정
- **관리자**: admin@example.com / password
- **응시자**: examinee@example.com / password

## 기술 스택
- Laravel 13.x
- Blade 템플릿
- Tailwind CSS 4.x
- Alpine.js
- Chart.js
- SQLite

## 라이선스
MIT License
```

6. **최종 테스트**:
```bash
# 캐시 클리어
php artisan config:clear
php artisan cache:clear
php artisan view:clear

# 프로덕션 빌드
npm run build

# 모든 기능 테스트:
# 1. 회원가입/로그인
# 2. 시험 목록 조회 및 필터링
# 3. 시험 응시 (타이머 확인)
# 4. 답안 자동 저장 확인
# 5. 시험 제출 및 결과 확인
# 6. 관리자 로그인 후 시험/문제 CRUD
# 7. 통계 대시보드 확인
# 8. 다크모드 토글
```