🎭 극단 공연 시즌 티켓 패키지 판매 플랫폼 - 연극/뮤지컬 시리즈 구독 시스템

mkdir theater-season-ticket-platform && cd theater-season-ticket-platform

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

Laravel 13.x 프로젝트를 생성하고 기본 설정을 완료해주세요.

```bash
composer create-project laravel/laravel . "^13.0"
```

다음 설정을 진행하세요:
1. .env 파일에서 데이터베이스를 SQLite로 설정
   - DB_CONNECTION=sqlite
   - DB_DATABASE 경로를 database/database.sqlite로 지정
   - database/database.sqlite 파일 생성
2. Tailwind CSS 4.x 설치 및 설정
   - npm install -D tailwindcss@latest postcss autoprefixer
   - npx tailwindcss init -p
   - tailwind.config.js에서 content 경로 설정 (resources/**/*.blade.php, resources/**/*.js)
   - resources/css/app.css에 @tailwind 지시문 추가
3. Alpine.js 3.x 설치
   - npm install alpinejs@latest
   - resources/js/app.js에서 Alpine 초기화
4. Redis 설정
   - .env에서 CACHE_DRIVER=redis, QUEUE_CONNECTION=database 설정
   - composer require predis/predis
5. 기본 인증 스캐폴딩 설치
   - composer require laravel/breeze --dev
   - php artisan breeze:install blade
   - npm install && npm run build
6. 필요한 패키지 추가 설치
   - composer require barryvdh/laravel-dompdf (PDF 생성)
   - composer require stripe/stripe-php (결제 연동)

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

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

프로젝트 기본 구조가 완성되면 http://localhost:8000 에 접속하여 Laravel 웰컴 페이지를 확인하세요.

데이터베이스 스키마를 설계하고 마이그레이션 파일을 생성하세요.

다음 테이블들을 생성해야 합니다:

1. **users 테이블** (Breeze 기본 테이블 확장)
   - role 컬럼 추가 (enum: 'admin', 'user', 기본값 'user')
   - membership_tier 컬럼 추가 (enum: 'bronze', 'silver', 'gold', nullable)
   - total_spent 컬럼 추가 (decimal, 기본값 0) - 누적 구매 금액

2. **seasons 테이블**
   - id (primary key)
   - title (string) - 시즌 제목 (예: "2025 봄 시즌")
   - description (text) - 시즌 소개
   - start_date, end_date (date) - 시즌 기간
   - image (string, nullable) - 시즌 포스터 이미지 경로
   - is_active (boolean, 기본값 true) - 판매 중 여부
   - created_at, updated_at

3. **shows 테이블**
   - id (primary key)
   - season_id (foreign key → seasons.id, onDelete cascade)
   - title (string) - 공연 제목
   - description (text)
   - genre (string) - 장르 (연극/뮤지컬/오페라 등)
   - duration_minutes (integer) - 공연 시간(분)
   - image (string, nullable)
   - created_at, updated_at

4. **show_schedules 테이블**
   - id (primary key)
   - show_id (foreign key → shows.id, onDelete cascade)
   - show_date (date) - 공연 날짜
   - show_time (time) - 공연 시작 시간
   - venue (string) - 공연장 이름
   - total_seats (integer) - 총 좌석 수
   - available_seats (integer) - 남은 좌석 수
   - created_at, updated_at

5. **seats 테이블**
   - id (primary key)
   - show_schedule_id (foreign key → show_schedules.id, onDelete cascade)
   - seat_number (string) - 좌석 번호 (예: "A-1", "B-5")
   - seat_type (enum: 'vip', 'regular') - 좌석 등급
   - price (decimal) - 좌석 가격
   - status (enum: 'available', 'reserved', 'sold') - 좌석 상태
   - unique 제약 조건: (show_schedule_id, seat_number)
   - created_at, updated_at

6. **season_packages 테이블**
   - id (primary key)
   - season_id (foreign key → seasons.id, onDelete cascade)
   - name (string) - 패키지 이름 (예: "얼리버드 4회권")
   - description (text)
   - show_count (integer) - 포함된 공연 수
   - price (decimal) - 패키지 가격
   - discount_rate (decimal) - 할인율 (%)
   - is_available (boolean, 기본값 true)
   - created_at, updated_at

7. **bookings 테이블**
   - id (primary key)
   - user_id (foreign key → users.id, onDelete cascade)
   - season_package_id (foreign key → season_packages.id, nullable) - 시즌 패스 구매 시
   - booking_number (string, unique) - 예약 번호 (자동 생성)
   - total_amount (decimal) - 총 결제 금액
   - payment_status (enum: 'pending', 'completed', 'failed', 'refunded')
   - payment_method (string, nullable) - 결제 수단
   - stripe_payment_id (string, nullable) - Stripe 결제 ID
   - created_at, updated_at

8. **booking_seats 테이블** (중간 테이블)
   - id (primary key)
   - booking_id (foreign key → bookings.id, onDelete cascade)
   - seat_id (foreign key → seats.id, onDelete cascade)
   - attended (boolean, 기본값 false) - 실제 관람 여부
   - unique 제약 조건: (booking_id, seat_id)
   - created_at, updated_at

9. **reviews 테이블**
   - id (primary key)
   - user_id (foreign key → users.id, onDelete cascade)
   - show_id (foreign key → shows.id, onDelete cascade)
   - rating (integer) - 별점 (1~5)
   - comment (text, nullable) - 리뷰 내용
   - created_at, updated_at

마이그레이션 파일 생성 명령어:
```bash
php artisan make:migration add_role_to_users_table --table=users
php artisan make:migration create_seasons_table
php artisan make:migration create_shows_table
php artisan make:migration create_show_schedules_table
php artisan make:migration create_seats_table
php artisan make:migration create_season_packages_table
php artisan make:migration create_bookings_table
php artisan make:migration create_booking_seats_table
php artisan make:migration create_reviews_table
```

각 마이그레이션 파일에 위 스키마대로 컬럼과 제약 조건을 정의하고, 마이그레이션을 실행하세요:
```bash
php artisan migrate
```

인덱스 추가:
- seats 테이블: (show_schedule_id, status) 복합 인덱스
- bookings 테이블: (user_id, payment_status) 복합 인덱스
- reviews 테이블: (show_id, rating) 복합 인덱스

Eloquent 모델을 생성하고 관계를 정의하세요.

다음 명령어로 모델 파일을 생성하세요:
```bash
php artisan make:model Season
php artisan make:model Show
php artisan make:model ShowSchedule
php artisan make:model Seat
php artisan make:model SeasonPackage
php artisan make:model Booking
php artisan make:model BookingSeat
php artisan make:model Review
```

각 모델에 다음 관계를 정의하세요:

**User 모델** (app/Models/User.php):
- `bookings()`: hasMany(Booking::class)
- `reviews()`: hasMany(Review::class)
- `membershipTierBadge()`: Accessor - 등급에 따라 배지 아이콘 반환
- `upgradeMembershipTier()`: 메서드 - total_spent 기준으로 등급 자동 업그레이드 (Bronze: 0원, Silver: 50만원, Gold: 100만원)

**Season 모델**:
- `shows()`: hasMany(Show::class)
- `packages()`: hasMany(SeasonPackage::class)
- `scopeActive()`: 쿼리 스코프 - is_active가 true인 시즌만 조회

**Show 모델**:
- `season()`: belongsTo(Season::class)
- `schedules()`: hasMany(ShowSchedule::class)
- `reviews()`: hasMany(Review::class)
- `averageRating()`: Accessor - 리뷰 별점 평균 계산

**ShowSchedule 모델**:
- `show()`: belongsTo(Show::class)
- `seats()`: hasMany(Seat::class)
- `availableSeatsCount()`: Accessor - available_seats 값 반환
- `isSoldOut()`: Accessor - available_seats가 0이면 true

**Seat 모델**:
- `schedule()`: belongsTo(ShowSchedule::class, 'show_schedule_id')
- `bookingSeats()`: hasMany(BookingSeat::class)
- `scopeAvailable()`: 쿼리 스코프 - status가 'available'인 좌석만 조회
- `reserve()`: 메서드 - 좌석 상태를 'reserved'로 변경
- `markAsSold()`: 메서드 - 좌석 상태를 'sold'로 변경

**SeasonPackage 모델**:
- `season()`: belongsTo(Season::class)
- `bookings()`: hasMany(Booking::class)
- `discountedPrice()`: Accessor - 할인 적용 후 가격 계산

**Booking 모델**:
- `user()`: belongsTo(User::class)
- `seasonPackage()`: belongsTo(SeasonPackage::class)
- `bookingSeats()`: hasMany(BookingSeat::class)
- `seats()`: belongsToMany(Seat::class, 'booking_seats')->withPivot('attended')->withTimestamps()
- `generateBookingNumber()`: Static 메서드 - 예약 번호 자동 생성 (예: "BK-20250115-0001")
- `isPaid()`: Accessor - payment_status가 'completed'인지 확인

**BookingSeat 모델**:
- `booking()`: belongsTo(Booking::class)
- `seat()`: belongsTo(Seat::class)

**Review 모델**:
- `user()`: belongsTo(User::class)
- `show()`: belongsTo(Show::class)
- `scopeHighRated()`: 쿼리 스코프 - rating이 4 이상인 리뷰만 조회

각 모델에 $fillable 속성을 정의하여 대량 할당 가능한 필드를 명시하세요.

또한, Booking 모델에 다음 이벤트 리스너를 추가하세요:
- `creating` 이벤트: booking_number 자동 생성
- `updated` 이벤트: payment_status가 'completed'로 변경되면 user의 total_spent 업데이트 및 등급 갱신

Cast 설정:
- 날짜 필드는 모두 Carbon 인스턴스로 캐스팅
- boolean 필드는 boolean 타입으로 캐스팅
- decimal 필드는 float 또는 decimal:2로 캐스팅

시더(Seeder)를 생성하여 테스트 데이터를 삽입하세요.

```bash
php artisan make:seeder DatabaseSeeder
```

DatabaseSeeder 파일(database/seeders/DatabaseSeeder.php)에서 다음 데이터를 생성하세요:

1. **관리자 계정 1개**
   - name: "극단 관리자"
   - email: "admin@theater.com"
   - password: bcrypt('password')
   - role: 'admin'

2. **일반 사용자 10명**
   - 팩토리 사용 또는 수동 생성
   - role: 'user'
   - membership_tier는 랜덤 (bronze, silver, gold)

3. **시즌 2개**
   - "2025 봄 시즌" (3월~5월)
   - "2025 여름 시즌" (6월~8월)
   - 각 시즌마다 이미지 경로 설정 (public/images/seasons/spring.jpg 등)

4. **각 시즌마다 공연 4개**
   - 총 8개 공연 생성
   - 제목 예시: "햄릿", "로미오와 줄리엣", "오페라의 유령", "캣츠" 등
   - 장르: 연극, 뮤지컬 섞어서
   - duration_minutes: 120~180 사이 랜덤

5. **각 공연마다 스케줄 3개**
   - 총 24개 스케줄
   - show_date: 시즌 기간 내 랜덤 날짜
   - show_time: 14:00, 19:00 중 랜덤
   - venue: "대극장", "소극장" 중 랜덤
   - total_seats: 100
   - available_seats: 100 (초기값)

6. **각 스케줄마다 좌석 100개**
   - 총 2400개 좌석
   - seat_number: "A-1"부터 "J-10"까지 (10행 x 10열)
   - seat_type: 앞 3행은 'vip', 나머지는 'regular'
   - price: VIP 80,000원, 일반석 50,000원
   - status: 'available'

7. **각 시즌마다 패키지 3개**
   - 총 6개 패키지
   - 예시:
     - "얼리버드 4회권" (show_count: 4, discount_rate: 20%)
     - "정규 4회권" (show_count: 4, discount_rate: 10%)
     - "VIP 4회권" (show_count: 4, discount_rate: 15%, VIP 좌석 포함)

8. **예약 데이터 20개**
   - 일반 사용자들이 랜덤하게 예약
   - 일부는 시즌 패키지 구매, 일부는 개별 좌석 구매
   - payment_status: 'completed' 또는 'pending'
   - booking_seats 테이블에도 연결

9. **리뷰 데이터 30개**
   - 예약 완료된 공연에 대해 랜덤 리뷰 생성
   - rating: 1~5 사이 랜덤
   - comment: 샘플 텍스트

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

또는 마이그레이션과 함께 실행:
```bash
php artisan migrate:fresh --seed
```

시더 실행 후 데이터베이스에 테스트 데이터가 잘 들어갔는지 확인하세요:
```bash
php artisan tinker
>>> \App\Models\Season::count()
>>> \App\Models\Show::count()
>>> \App\Models\Booking::count()
```

라우트와 컨트롤러를 생성하여 사용자 페이지의 기본 구조를 만드세요.

routes/web.php 파일에 다음 라우트를 추가하세요:

```php
use App\Http\Controllers\HomeController;
use App\Http\Controllers\SeasonController;
use App\Http\Controllers\ShowController;
use App\Http\Controllers\BookingController;
use App\Http\Controllers\ReviewController;

// 홈페이지
Route::get('/', [HomeController::class, 'index'])->name('home');

// 시즌 목록 및 상세
Route::get('/seasons', [SeasonController::class, 'index'])->name('seasons.index');
Route::get('/seasons/{season}', [SeasonController::class, 'show'])->name('seasons.show');

// 공연 상세
Route::get('/shows/{show}', [ShowController::class, 'show'])->name('shows.show');

// 예약 프로세스 (로그인 필요)
Route::middleware(['auth'])->group(function () {
    Route::get('/shows/{show}/book', [BookingController::class, 'create'])->name('bookings.create');
    Route::post('/bookings', [BookingController::class, 'store'])->name('bookings.store');
    Route::get('/bookings/{booking}', [BookingController::class, 'show'])->name('bookings.show');
    Route::get('/bookings/{booking}/ticket', [BookingController::class, 'downloadTicket'])->name('bookings.ticket');
    Route::get('/my-bookings', [BookingController::class, 'myBookings'])->name('bookings.my');
    
    // 리뷰 작성
    Route::post('/shows/{show}/reviews', [ReviewController::class, 'store'])->name('reviews.store');
});
```

컨트롤러 생성:
```bash
php artisan make:controller HomeController
php artisan make:controller SeasonController
php artisan make:controller ShowController
php artisan make:controller BookingController
php artisan make:controller ReviewController
```

각 컨트롤러에 다음 메서드를 구현하세요:

**HomeController**:
- `index()`: 활성 시즌 목록, 인기 공연(리뷰 평점 높은 순), 최근 리뷰 3개를 뷰에 전달

**SeasonController**:
- `index()`: 모든 활성 시즌 목록 조회 (페이지네이션)
- `show(Season $season)`: 특정 시즌 상세 정보, 포함된 공연 목록, 시즌 패키지 목록

**ShowController**:
- `show(Show $show)`: 공연 상세 정보, 스케줄 목록, 리뷰 목록(평점 높은 순, 페이지네이션), 평균 별점

**BookingController**:
- `create(Show $show)`: 공연의 스케줄 선택 및 좌석 선택 폼 표시
- `store(Request $request)`: 예약 정보 검증 및 저장 (트랜잭션 사용)
  - 좌석 중복 예약 방지 (DB 락 사용)
  - 좌석 상태를 'reserved'로 변경
  - Booking 레코드 생성
  - BookingSeat 레코드 생성
  - 결제 대기 상태로 설정
- `show(Booking $booking)`: 예약 상세 정보 표시 (Policy로 본인 예약만 조회 가능)
- `downloadTicket(Booking $booking)`: PDF 티켓 생성 및 다운로드
- `myBookings()`: 로그인한 사용자의 모든 예약 목록

**ReviewController**:
- `store(Request $request, Show $show)`: 리뷰 작성 (로그인 + 해당 공연 예약 이력 확인)

Policy 생성 및 등록:
```bash
php artisan make:policy BookingPolicy --model=Booking
```

BookingPolicy에 `view` 메서드 추가:
- 예약한 사용자 본인 또는 관리자만 조회 가능

app/Providers/AuthServiceProvider.php에 Policy 등록:
```php
protected $policies = [
    Booking::class => BookingPolicy::class,
];
```

컨트롤러에서 Policy 사용:
```php
$this->authorize('view', $booking);
```

Blade 뷰 파일을 생성하여 사용자 페이지의 UI를 구현하세요.

Tailwind CSS와 Alpine.js를 활용하여 반응형 디자인을 적용하세요.

**레이아웃 파일** (resources/views/layouts/app.blade.php):
- Breeze의 기본 레이아웃 활용 또는 커스터마이징
- 네비게이션 바: 홈, 시즌, 내 예약, 로그인/로그아웃
- 푸터 추가

**홈페이지** (resources/views/home.blade.php):
- 히어로 섹션: 극단 소개, 시즌 하이라이트 이미지
- 활성 시즌 카드 목록 (최대 3개 표시)
- 인기 공연 섹션: 평점 높은 공연 4개, 별점 아이콘 표시
- 최근 리뷰 섹션: 최신 리뷰 3개, 사용자 이름 + 별점 + 코멘트

**시즌 목록 페이지** (resources/views/seasons/index.blade.php):
- 그리드 레이아웃으로 시즌 카드 표시
- 각 카드: 시즌 포스터 이미지, 제목, 기간, 포함된 공연 수, "자세히 보기" 버튼
- 페이지네이션

**시즌 상세 페이지** (resources/views/seasons/show.blade.php):
- 시즌 정보: 제목, 설명, 기간
- 포함된 공연 목록: 각 공연 카드 (이미지, 제목, 장르, 평균 별점, "예약하기" 버튼)
- 시즌 패키지 섹션: 패키지 카드 (이름, 설명, 가격, 할인율, "구매하기" 버튼)

**공연 상세 페이지** (resources/views/shows/show.blade.php):
- 공연 정보: 제목, 설명, 장르, 러닝타임, 평균 별점
- 스케줄 선택 섹션: 날짜/시간별 스케줄 목록, 잔여 좌석 수 표시
  - 매진된 스케줄은 "매진" 배지 표시
  - 예약 가능한 스케줄은 "예약하기" 버튼
- 리뷰 섹션: 리뷰 목록 (별점, 작성자, 날짜, 코멘트), 페이지네이션
- 리뷰 작성 폼 (로그인 + 해당 공연 예약 이력 있는 경우에만 표시)

**예약 페이지** (resources/views/bookings/create.blade.php):
- 선택한 스케줄 정보 표시
- 좌석 선택 UI:
  - 극장 좌석 배치도 (10행 x 10열 그리드)
  - 좌석 상태별 색상 구분: 예약 가능(초록), 선택됨(파랑), 매진(회색)
  - Alpine.js로 좌석 클릭 시 선택/해제 토글
  - 선택한 좌석 목록 실시간 표시
- 총 결제 금액 계산 (선택한 좌석 가격 합계)
- "결제하기" 버튼 (선택한 좌석이 없으면 비활성화)

Alpine.js 좌석 선택 로직 예시:
```html
<div x-data="{
    selectedSeats: [],
    toggleSeat(seatId, price) {
        const index = this.selectedSeats.findIndex(s => s.id === seatId);
        if (index > -1) {
            this.selectedSeats.splice(index, 1);
        } else {
            this.selectedSeats.push({ id: seatId, price: price });
        }
    },
    totalPrice() {
        return this.selectedSeats.reduce((sum, seat) => sum + seat.price, 0);
    }
}">
    <!-- 좌석 그리드 -->
    @foreach($seats as $seat)
        <button 
            @click="toggleSeat({{ $seat->id }}, {{ $seat->price }})"
            :class="selectedSeats.some(s => s.id === {{ $seat->id }}) ? 'bg-blue-500' : 'bg-green-500'"
            :disabled="'{{ $seat->status }}' !== 'available'"
            class="w-10 h-10 m-1 rounded"
        >
            {{ $seat->seat_number }}
        </button>
    @endforeach
    
    <!-- 선택한 좌석 목록 -->
    <div>
        <h3>선택한 좌석:</h3>
        <template x-for="seat in selectedSeats" :key="seat.id">
            <p x-text="'좌석 ID: ' + seat.id + ', 가격: ' + seat.price + '원'"></p>
        </template>
        <p><strong>총 금액: <span x-text="totalPrice()"></span>원</strong></p>
    </div>
    
    <!-- 폼 제출 -->
    <form method="POST" action="{{ route('bookings.store') }}">
        @csrf
        <input type="hidden" name="schedule_id" value="{{ $schedule->id }}">
        <template x-for="seat in selectedSeats" :key="seat.id">
            <input type="hidden" name="seat_ids[]" :value="seat.id">
        </template>
        <button type="submit" :disabled="selectedSeats.length === 0">결제하기</button>
    </form>
</div>
```

**예약 완료 페이지** (resources/views/bookings/show.blade.php):
- 예약 번호, 공연 정보, 선택한 좌석, 결제 금액
- "PDF 티켓 다운로드" 버튼
- 결제 상태 표시 (대기 중/완료/실패)

**내 예약 목록 페이지** (resources/views/bookings/my.blade.php):
- 로그인한 사용자의 모든 예약 목록
- 각 예약: 공연 제목, 날짜, 좌석, 결제 상태, "상세 보기" 버튼
- 페이지네이션

모든 뷰에서 Tailwind CSS 유틸리티 클래스를 사용하여 스타일링하세요.
반응형 디자인: sm:, md:, lg: 브레이크포인트 활용

결제 연동 및 예약 완료 처리를 구현하세요.

Stripe API를 사용하여 실제 결제 프로세스를 구현합니다.

1. **Stripe 설정**:
   - .env 파일에 Stripe API 키 추가:
     ```
     STRIPE_KEY=pk_test_xxxxx
     STRIPE_SECRET=sk_test_xxxxx
     ```
   - config/services.php에 Stripe 설정 추가:
     ```php
     'stripe' => [
         'key' => env('STRIPE_KEY'),
         'secret' => env('STRIPE_SECRET'),
     ],
     ```

2. **결제 컨트롤러 생성**:
   ```bash
   php artisan make:controller PaymentController
   ```

3. **라우트 추가** (routes/web.php):
   ```php
   Route::middleware(['auth'])->group(function () {
       Route::post('/payment/process', [PaymentController::class, 'process'])->name('payment.process');
       Route::get('/payment/success', [PaymentController::class, 'success'])->name('payment.success');
       Route::get('/payment/cancel', [PaymentController::class, 'cancel'])->name('payment.cancel');
   });
   ```

4. **PaymentController 구현**:
   - `process()` 메서드:
     - 예약 정보를 세션에 저장
     - Stripe Checkout Session 생성
     - Checkout URL로 리다이렉트
   
   ```php
   use Stripe\Stripe;
   use Stripe\Checkout\Session;
   
   public function process(Request $request)
   {
       Stripe::setApiKey(config('services.stripe.secret'));
       
       // 예약 정보 검증
       $validated = $request->validate([
           'schedule_id' => 'required|exists:show_schedules,id',
           'seat_ids' => 'required|array|min:1',
           'seat_ids.*' => 'exists:seats,id',
       ]);
       
       $schedule = ShowSchedule::findOrFail($validated['schedule_id']);
       $seats = Seat::whereIn('id', $validated['seat_ids'])
                    ->where('status', 'available')
                    ->lockForUpdate()
                    ->get();
       
       // 좌석이 모두 예약 가능한지 확인
       if ($seats->count() !== count($validated['seat_ids'])) {
           return back()->withErrors(['seats' => '선택한 좌석 중 일부가 이미 예약되었습니다.']);
       }
       
       // 총 금액 계산
       $totalAmount = $seats->sum('price');
       
       // 예약 정보 세션에 저장
       session([
           'pending_booking' => [
               'schedule_id' => $schedule->id,
               'seat_ids' => $validated['seat_ids'],
               'total_amount' => $totalAmount,
           ]
       ]);
       
       // Stripe Checkout Session 생성
       $checkoutSession = Session::create([
           'payment_method_types' => ['card'],
           'line_items' => [[
               'price_data' => [
                   'currency' => 'krw',
                   'product_data' => [
                       'name' => $schedule->show->title . ' - ' . $schedule->show_date,
                   ],
                   'unit_amount' => $totalAmount,
               ],
               'quantity' => 1,
           ]],
           'mode' => 'payment',
           'success_url' => route('payment.success') . '?session_id={CHECKOUT_SESSION_ID}',
           'cancel_url' => route('payment.cancel'),
       ]);
       
       return redirect($checkoutSession->url);
   }
   ```
   
   - `success()` 메서드:
     - Stripe 결제 성공 확인
     - DB 트랜잭션으로 예약 생성 및 좌석 상태 업데이트
     - 사용자 total_spent 업데이트 및 등급 갱신
     - 예약 완료 이메일 발송 (Queue 사용)
   
   ```php
   public function success(Request $request)
   {
       Stripe::setApiKey(config('services.stripe.secret'));
       
       $sessionId = $request->query('session_id');
       $checkoutSession = Session::retrieve($sessionId);
       
       if ($checkoutSession->payment_status !== 'paid') {
           return redirect()->route('home')->withErrors(['payment' => '결제가 완료되지 않았습니다.']);
       }
       
       $pendingBooking = session('pending_booking');
       if (!$pendingBooking) {
           return redirect()->route('home')->withErrors(['booking' => '예약 정보를 찾을 수 없습니다.']);
       }
       
       DB::transaction(function () use ($pendingBooking, $sessionId) {
           // 좌석 락 및 상태 확인
           $seats = Seat::whereIn('id', $pendingBooking['seat_ids'])
                        ->where('status', 'available')
                        ->lockForUpdate()
                        ->get();
           
           if ($seats->count() !== count($pendingBooking['seat_ids'])) {
               throw new \Exception('좌석이 이미 예약되었습니다.');
           }
           
           // 예약 생성
           $booking = Booking::create([
               'user_id' => auth()->id(),
               'booking_number' => Booking::generateBookingNumber(),
               'total_amount' => $pendingBooking['total_amount'],
               'payment_status' => 'completed',
               'payment_method' => 'card',
               'stripe_payment_id' => $sessionId,
           ]);
           
           // 좌석 예약 및 상태 변경
           foreach ($seats as $seat) {
               BookingSeat::create([
                   'booking_id' => $booking->id,
                   'seat_id' => $seat->id,
               ]);
               $seat->markAsSold();
           }
           
           // 스케줄의 남은 좌석 수 업데이트
           $schedule = ShowSchedule::find($pendingBooking['schedule_id']);
           $schedule->decrement('available_seats', $seats->count());
           
           // 사용자 누적 구매 금액 업데이트
           $user = auth()->user();
           $user->increment('total_spent', $pendingBooking['total_amount']);
           $user->upgradeMembershipTier();
           
           // 예약 완료 이메일 발송 (Queue)
           // TODO: 다음 단계에서 구현
       });
       
       session()->forget('pending_booking');
       
       return redirect()->route('bookings.my')->with('success', '예약이 완료되었습니다!');
   }
   ```
   
   - `cancel()` 메서드:
     - 결제 취소 처리
     - 세션 정보 삭제

5. **예약 페이지 수정**:
   - bookings/create.blade.php의 폼 액션을 `route('payment.process')`로 변경
   - 결제하기 버튼 클릭 시 Stripe Checkout으로 이동

6. **트랜잭션 및 락 처리**:
   - 좌석 중복 예약 방지를 위해 `lockForUpdate()` 사용
   - DB::transaction()으로 원자성 보장

Queue를 사용하여 예약 완료 이메일 알림을 비동기로 발송하고, PDF 티켓을 생성하세요.

1. **Queue 설정**:
   - .env 파일에서 QUEUE_CONNECTION을 database로 설정 (이미 설정됨)
   - Queue 테이블 마이그레이션 생성 및 실행:
     ```bash
     php artisan queue:table
     php artisan migrate
     ```

2. **메일 설정**:
   - .env 파일에 메일 설정 추가 (테스트용으로 Mailtrap 또는 log 드라이버 사용):
     ```
     MAIL_MAILER=log
     MAIL_FROM_ADDRESS=noreply@theater.com
     MAIL_FROM_NAME="극단 티켓"
     ```

3. **Mailable 클래스 생성**:
   ```bash
   php artisan make:mail BookingConfirmation
   ```
   
   app/Mail/BookingConfirmation.php:
   ```php
   namespace App\Mail;
   
   use App\Models\Booking;
   use Illuminate\Bus\Queueable;
   use Illuminate\Mail\Mailable;
   use Illuminate\Queue\SerializesModels;
   
   class BookingConfirmation extends Mailable
   {
       use Queueable, SerializesModels;
       
       public $booking;
       
       public function __construct(Booking $booking)
       {
           $this->booking = $booking;
       }
       
       public function build()
       {
           return $this->subject('예약 완료 안내')
                       ->markdown('emails.booking-confirmation');
       }
   }
   ```

4. **메일 뷰 생성** (resources/views/emails/booking-confirmation.blade.php):
   ```blade
   @component('mail::message')
   # 예약이 완료되었습니다!
   
   안녕하세요 {{ $booking->user->name }}님,
   
   예약 번호: **{{ $booking->booking_number }}**
   
   ## 예약 정보
   - 공연: {{ $booking->seats->first()->schedule->show->title }}
   - 날짜: {{ $booking->seats->first()->schedule->show_date }}
   - 시간: {{ $booking->seats->first()->schedule->show_time }}
   - 좌석: {{ $booking->seats->pluck('seat_number')->join(', ') }}
   - 총 금액: {{ number_format($booking->total_amount) }}원
   
   @component('mail::button', ['url' => route('bookings.show', $booking)])
   예약 상세 보기
   @endcomponent
   
   감사합니다,<br>
   {{ config('app.name') }}
   @endcomponent
   ```

5. **Job 클래스 생성**:
   ```bash
   php artisan make:job SendBookingConfirmationEmail
   ```
   
   app/Jobs/SendBookingConfirmationEmail.php:
   ```php
   namespace App\Jobs;
   
   use App\Models\Booking;
   use App\Mail\BookingConfirmation;
   use Illuminate\Bus\Queueable;
   use Illuminate\Contracts\Queue\ShouldQueue;
   use Illuminate\Foundation\Bus\Dispatchable;
   use Illuminate\Queue\InteractsWithQueue;
   use Illuminate\Queue\SerializesModels;
   use Illuminate\Support\Facades\Mail;
   
   class SendBookingConfirmationEmail implements ShouldQueue
   {
       use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;
       
       public $booking;
       
       public function __construct(Booking $booking)
       {
           $this->booking = $booking;
       }
       
       public function handle()
       {
           Mail::to($this->booking->user->email)
               ->send(new BookingConfirmation($this->booking));
       }
   }
   ```

6. **PaymentController의 success() 메서드 수정**:
   - 트랜잭션 내부에서 Job 디스패치:
     ```php
     // 예약 완료 이메일 발송 (Queue)
     SendBookingConfirmationEmail::dispatch($booking);
     ```

7. **Queue Worker 실행**:
   ```bash
   php artisan queue:work
   ```
   - 또는 개발 환경에서는 `php artisan queue:listen`

8. **PDF 티켓 생성**:
   - BookingController의 `downloadTicket()` 메서드 구현:
   
   ```php
   use Barryvdh\DomPDF\Facade\Pdf;
   
   public function downloadTicket(Booking $booking)
   {
       $this->authorize('view', $booking);
       
       if ($booking->payment_status !== 'completed') {
           return back()->withErrors(['ticket' => '결제가 완료된 예약만 티켓을 다운로드할 수 있습니다.']);
       }
       
       $pdf = Pdf::loadView('bookings.ticket', compact('booking'));
       
       return $pdf->download('ticket-' . $booking->booking_number . '.pdf');
   }
   ```

9. **PDF 티켓 뷰 생성** (resources/views/bookings/ticket.blade.php):
   ```blade
   <!DOCTYPE html>
   <html>
   <head>
       <meta charset="utf-8">
       <title>티켓 - {{ $booking->booking_number }}</title>
       <style>
           body { font-family: DejaVu Sans, sans-serif; }
           .ticket { border: 2px solid #000; padding: 20px; }
           .qr-code { text-align: center; }
       </style>
   </head>
   <body>
       <div class="ticket">
           <h1>공연 티켓</h1>
           <p><strong>예약 번호:</strong> {{ $booking->booking_number }}</p>
           <p><strong>공연:</strong> {{ $booking->seats->first()->schedule->show->title }}</p>
           <p><strong>날짜:</strong> {{ $booking->seats->first()->schedule->show_date }}</p>
           <p><strong>시간:</strong> {{ $booking->seats->first()->schedule->show_time }}</p>
           <p><strong>좌석:</strong> {{ $booking->seats->pluck('seat_number')->join(', ') }}</p>
           <p><strong>관람객:</strong> {{ $booking->user->name }}</p>
           
           <div class="qr-code">
               <!-- QR 코드 생성 라이브러리 사용 (예: SimpleSoftwareIO/simple-qrcode) -->
               <p>[QR 코드 위치]</p>
               <p>{{ $booking->booking_number }}</p>
           </div>
       </div>
   </body>
   </html>
   ```

10. **QR 코드 생성 (선택사항)**:
    - QR 코드 라이브러리 설치:
      ```bash
      composer require simplesoftwareio/simple-qrcode
      ```
    - 티켓 뷰에서 QR 코드 생성:
      ```blade
      {!! QrCode::size(200)->generate($booking->booking_number) !!}
      ```

관리자 대시보드를 구성하여 시즌/공연/좌석 관리 및 통계 기능을 구현하세요.

1. **관리자 미들웨어 생성**:
   ```bash
   php artisan make:middleware IsAdmin
   ```
   
   app/Http/Middleware/IsAdmin.php:
   ```php
   public function handle(Request $request, Closure $next)
   {
       if (!auth()->check() || auth()->user()->role !== 'admin') {
           abort(403, '관리자 권한이 필요합니다.');
       }
       return $next($request);
   }
   ```
   
   app/Http/Kernel.php에 미들웨어 등록:
   ```php
   protected $middlewareAliases = [
       // ...
       'admin' => \App\Http\Middleware\IsAdmin::class,
   ];
   ```

2. **관리자 라우트 추가** (routes/web.php):
   ```php
   use App\Http\Controllers\Admin\DashboardController;
   use App\Http\Controllers\Admin\SeasonManageController;
   use App\Http\Controllers\Admin\ShowManageController;
   use App\Http\Controllers\Admin\BookingManageController;
   
   Route::prefix('admin')->middleware(['auth', 'admin'])->name('admin.')->group(function () {
       Route::get('/dashboard', [DashboardController::class, 'index'])->name('dashboard');
       
       Route::resource('seasons', SeasonManageController::class);
       Route::resource('shows', ShowManageController::class);
       Route::get('bookings', [BookingManageController::class, 'index'])->name('bookings.index');
       Route::patch('bookings/{booking}/refund', [BookingManageController::class, 'refund'])->name('bookings.refund');
   });
   ```

3. **관리자 컨트롤러 생성**:
   ```bash
   php artisan make:controller Admin/DashboardController
   php artisan make:controller Admin/SeasonManageController --resource
   php artisan make:controller Admin/ShowManageController --resource
   php artisan make:controller Admin/BookingManageController
   ```

4. **DashboardController 구현**:
   - `index()` 메서드:
     - 전체 예약 수, 총 매출, 평균 예약 금액
     - 오늘/이번 주/이번 달 예약 통계
     - 인기 공연 Top 5 (예약 수 기준)
     - 최근 예약 10건
     - 좌석 점유율 차트 데이터 (Chart.js용 JSON)
   
   ```php
   public function index()
   {
       $totalBookings = Booking::where('payment_status', 'completed')->count();
       $totalRevenue = Booking::where('payment_status', 'completed')->sum('total_amount');
       $avgBookingAmount = $totalBookings > 0 ? $totalRevenue / $totalBookings : 0;
       
       $todayBookings = Booking::whereDate('created_at', today())->count();
       $weekBookings = Booking::whereBetween('created_at', [now()->startOfWeek(), now()->endOfWeek()])->count();
       $monthBookings = Booking::whereMonth('created_at', now()->month)->count();
       
       $topShows = Show::withCount('schedules.seats.bookingSeats')
                       ->orderBy('schedules_seats_booking_seats_count', 'desc')
                       ->take(5)
                       ->get();
       
       $recentBookings = Booking::with('user', 'seats.schedule.show')
                                ->latest()
                                ->take(10)
                                ->get();
       
       // 좌석 점유율 차트 데이터
       $occupancyData = ShowSchedule::selectRaw('show_id, SUM(total_seats - available_seats) as sold, SUM(total_seats) as total')
                                    ->groupBy('show_id')
                                    ->with('show')
                                    ->get()
                                    ->map(function ($schedule) {
                                        return [
                                            'show' => $schedule->show->title,
                                            'occupancy' => $schedule->total > 0 ? round(($schedule->sold / $schedule->total) * 100, 2) : 0,
                                        ];
                                    });
       
       return view('admin.dashboard', compact(
           'totalBookings', 'totalRevenue', 'avgBookingAmount',
           'todayBookings', 'weekBookings', 'monthBookings',
           'topShows', 'recentBookings', 'occupancyData'
       ));
   }
   ```

5. **SeasonManageController 구현**:
   - `index()`: 시즌 목록 (페이지네이션)
   - `create()`: 시즌 생성 폼
   - `store()`: 시즌 저장 (이미지 업로드 포함)
   - `edit()`: 시즌 수정 폼
   - `update()`: 시즌 업데이트
   - `destroy()`: 시즌 삭제 (연관된 공연도 함께 삭제됨)

6. **ShowManageController 구현**:
   - `index()`: 공연 목록 (시즌별 필터링 가능)
   - `create()`: 공연 생성 폼 (시즌 선택 드롭다운)
   - `store()`: 공연 저장 (스케줄 및 좌석 자동 생성)
   - `edit()`: 공연 수정 폼
   - `update()`: 공연 업데이트
   - `destroy()`: 공연 삭제

7. **BookingManageController 구현**:
   - `index()`: 예약 목록 (검색/필터링: 사용자명, 공연명, 결제 상태)
   - `refund()`: 예약 환불 처리 (좌석 상태 'available'로 복구, 결제 상태 'refunded'로 변경)

8. **관리자 뷰 생성**:
   - resources/views/admin/dashboard.blade.php:
     - 통계 카드 (총 예약, 총 매출, 평균 금액)
     - 오늘/이번 주/이번 달 예약 수
     - 인기 공연 Top 5 리스트
     - 최근 예약 테이블
     - Chart.js로 좌석 점유율 차트 표시
   
   - resources/views/admin/seasons/index.blade.php:
     - 시즌 목록 테이블 (제목, 기간, 공연 수, 액션 버튼)
     - "새 시즌 추가" 버튼
   
   - resources/views/admin/seasons/create.blade.php:
     - 시즌 생성 폼 (제목, 설명, 시작/종료 날짜, 이미지 업로드)
   
   - resources/views/admin/shows/index.blade.php:
     - 공연 목록 테이블 (제목, 시즌, 장르, 스케줄 수, 액션 버튼)
   
   - resources/views/admin/bookings/index.blade.php:
     - 예약 목록 테이블 (예약 번호, 사용자, 공연, 결제 상태, 금액, 환불 버튼)

9. **Chart.js 통합**:
   - resources/views/admin/dashboard.blade.php에 Chart.js CDN 추가:
     ```html
     <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
     <script>
         const ctx = document.getElementById('occupancyChart').getContext('2d');
         const occupancyData = @json($occupancyData);
         
         new Chart(ctx, {
             type: 'bar',
             data: {
                 labels: occupancyData.map(d => d.show),
                 datasets: [{
                     label: '좌석 점유율 (%)',
                     data: occupancyData.map(d => d.occupancy),
                     backgroundColor: 'rgba(54, 162, 235, 0.5)',
                     borderColor: 'rgba(54, 162, 235, 1)',
                     borderWidth: 1
                 }]
             },
             options: {
                 scales: {
                     y: {
                         beginAtZero: true,
                         max: 100
                     }
                 }
             }
         });
     </script>
     ```

10. **네비게이션에 관리자 링크 추가**:
    - layouts/app.blade.php에서 로그인한 사용자가 관리자인 경우 "관리자 대시보드" 링크 표시:
      ```blade
      @auth
          @if(auth()->user()->role === 'admin')
              <a href="{{ route('admin.dashboard') }}">관리자 대시보드</a>
          @endif
      @endauth
      ```

Redis 캐싱을 적용하여 성능을 최적화하고, PHPUnit 테스트를 작성하세요.

1. **Redis 캐싱 적용**:
   - 자주 조회되는 데이터에 캐싱 적용:
     - 홈페이지의 인기 공연 목록
     - 시즌 목록
     - 공연 상세 정보
     - 좌석 재고 정보
   
   예시: HomeController의 index() 메서드에 캐싱 적용:
   ```php
   use Illuminate\Support\Facades\Cache;
   
   public function index()
   {
       $activeSeasons = Cache::remember('active_seasons', 3600, function () {
           return Season::active()->with('shows')->get();
       });
       
       $popularShows = Cache::remember('popular_shows', 3600, function () {
           return Show::withAvg('reviews', 'rating')
                      ->orderBy('reviews_avg_rating', 'desc')
                      ->take(4)
                      ->get();
       });
       
       $recentReviews = Review::with('user', 'show')
                              ->latest()
                              ->take(3)
                              ->get();
       
       return view('home', compact('activeSeasons', 'popularShows', 'recentReviews'));
   }
   ```
   
   - 캐시 무효화:
     - 시즌이나 공연이 생성/수정/삭제될 때 관련 캐시 삭제:
       ```php
       Cache::forget('active_seasons');
       Cache::forget('popular_shows');
       ```

2. **좌석 재고 캐싱**:
   - ShowSchedule 모델에 캐시 메서드 추가:
     ```php
     public function getAvailableSeatsAttribute()
     {
         return Cache::remember("schedule_{$this->id}_available_seats", 60, function () {
             return $this->seats()->where('status', 'available')->count();
         });
     }
     
     public function decrementAvailableSeats()
     {
         Cache::forget("schedule_{$this->id}_available_seats");
         $this->decrement('available_seats');
     }
     ```

3. **PHPUnit 테스트 작성**:
   - 테스트 데이터베이스 설정 (phpunit.xml):
     ```xml
     <env name="DB_CONNECTION" value="sqlite"/>
     <env name="DB_DATABASE" value=":memory:"/>
     ```
   
   - Feature 테스트 생성:
     ```bash
     php artisan make:test BookingTest
     php artisan make:test PaymentTest
     php artisan make:test SeatReservationTest
     ```
   
   - **BookingTest** (tests/Feature/BookingTest.php):
     ```php
     namespace Tests\Feature;
     
     use Tests\TestCase;
     use App\Models\User;
     use App\Models\Show;
     use App\Models\ShowSchedule;
     use App\Models\Seat;
     use Illuminate\Foundation\Testing\RefreshDatabase;
     
     class BookingTest extends TestCase
     {
         use RefreshDatabase;
         
         public function test_user_can_view_booking_page()
         {
             $user = User::factory()->create();
             $show = Show::factory()->create();
             $schedule = ShowSchedule::factory()->create(['show_id' => $show->id]);
             
             $response = $this->actingAs($user)
                              ->get(route('bookings.create', $show));
             
             $response->assertStatus(200);
             $response->assertSee($show->title);
         }
         
         public function test_guest_cannot_access_booking_page()
         {
             $show = Show::factory()->create();
             
             $response = $this->get(route('bookings.create', $show));
             
             $response->assertRedirect(route('login'));
         }
         
         public function test_booking_creates_record_in_database()
         {
             $user = User::factory()->create();
             $schedule = ShowSchedule::factory()->create();
             $seat = Seat::factory()->create(['show_schedule_id' => $schedule->id, 'status' => 'available']);
             
             $response = $this->actingAs($user)
                              ->post(route('payment.process'), [
                                  'schedule_id' => $schedule->id,
                                  'seat_ids' => [$seat->id],
                              ]);
             
             // Stripe Checkout으로 리다이렉트되는지 확인
             $response->assertRedirect();
             
             // 세션에 예약 정보가 저장되는지 확인
             $this->assertNotNull(session('pending_booking'));
         }
     }
     ```
   
   - **SeatReservationTest** (tests/Feature/SeatReservationTest.php):
     ```php
     namespace Tests\Feature;
     
     use Tests\TestCase;
     use App\Models\Seat;
     use App\Models\Booking;
     use App\Models\BookingSeat;
     use Illuminate\Foundation\Testing\RefreshDatabase;
     use Illuminate\Support\Facades\DB;
     
     class SeatReservationTest extends TestCase
     {
         use RefreshDatabase;
         
         public function test_seat_status_changes_after_booking()
         {
             $seat = Seat::factory()->create(['status' => 'available']);
             
             $seat->markAsSold();
             
             $this->assertEquals('sold', $seat->fresh()->status);
         }
         
         public function test_cannot_book_already_sold_seat()
         {
             $seat = Seat::factory()->create(['status' => 'sold']);
             
             $availableSeats = Seat::where('id', $seat->id)
                                   ->where('status', 'available')
                                   ->get();
             
             $this->assertCount(0, $availableSeats);
         }
         
         public function test_concurrent_booking_prevents_double_reservation()
         {
             $seat = Seat::factory()->create(['status' => 'available']);
             
             // 동시 예약 시뮬레이션
             DB::transaction(function () use ($seat) {
                 $lockedSeat = Seat::where('id', $seat->id)
                                   ->where('status', 'available')
                                   ->lockForUpdate()
                                   ->first();
                 
                 $this->assertNotNull($lockedSeat);
                 $lockedSeat->markAsSold();
             });
             
             // 다른 트랜잭션에서 같은 좌석 예약 시도
             $lockedSeat = Seat::where('id', $seat->id)
                               ->where('status', 'available')
                               ->first();
             
             $this->assertNull($lockedSeat);
         }
     }
     ```
   
   - **PaymentTest** (tests/Feature/PaymentTest.php):
     ```php
     namespace Tests\Feature;
     
     use Tests\TestCase;
     use App\Models\User;
     use App\Models\Booking;
     use Illuminate\Foundation\Testing\RefreshDatabase;
     
     class PaymentTest extends TestCase
     {
         use RefreshDatabase;
         
         public function test_user_total_spent_increases_after_payment()
         {
             $user = User::factory()->create(['total_spent' => 0]);
             $booking = Booking::factory()->create([
                 'user_id' => $user->id,
                 'total_amount' => 100000,
                 'payment_status' => 'pending',
             ]);
             
             $booking->update(['payment_status' => 'completed']);
             
             $this->assertEquals(100000, $user->fresh()->total_spent);
         }
         
         public function test_membership_tier_upgrades_based_on_spending()
         {
             $user = User::factory()->create(['total_spent' => 0, 'membership_tier' => 'bronze']);
             
             $user->update(['total_spent' => 600000]);
             $user->upgradeMembershipTier();
             
             $this->assertEquals('silver', $user->fresh()->membership_tier);
             
             $user->update(['total_spent' => 1100000]);
             $user->upgradeMembershipTier();
             
             $this->assertEquals('gold', $user->fresh()->membership_tier);
         }
     }
     ```

4. **팩토리 생성** (필요한 경우):
   ```bash
   php artisan make:factory ShowFactory
   php artisan make:factory ShowScheduleFactory
   php artisan make:factory SeatFactory
   php artisan make:factory BookingFactory
   ```
   
   각 팩토리에 기본 데이터 정의:
   ```php
   // database/factories/SeatFactory.php
   public function definition()
   {
       return [
           'show_schedule_id' => ShowSchedule::factory(),
           'seat_number' => 'A-' . $this->faker->numberBetween(1, 100),
           'seat_type' => $this->faker->randomElement(['vip', 'regular']),
           'price' => $this->faker->randomElement([50000, 80000]),
           'status' => 'available',
       ];
   }
   ```

5. **테스트 실행**:
   ```bash
   php artisan test
   ```
   
   또는 특정 테스트만 실행:
   ```bash
   php artisan test --filter BookingTest
   ```

6. **테스트 커버리지 확인** (선택사항):
   - Xdebug 설치 후:
     ```bash
     php artisan test --coverage
     ```

7. **N+1 쿼리 문제 해결**:
   - Eager Loading 적용:
     ```php
     // 예약 목록 조회 시
     $bookings = Booking::with('user', 'seats.schedule.show')->paginate(20);
     
     // 공연 목록 조회 시
     $shows = Show::with('season', 'schedules')->get();
     ```
   
   - Laravel Debugbar 설치하여 쿼리 모니터링:
     ```bash
     composer require barryvdh/laravel-debugbar --dev
     ```