// next.config.js
/** @type {import('next').NextConfig} */
const nextConfig = {
  // 정적 파일 최적화
  // 배경: 이미지는 CDN에서 제공하므로 Next.js 이미지 최적화 설정
  // 효과: WebP/AVIF로 30-50% 용량 감소, 로딩 속도 개선
  images: {
    domains: ['cdn.example.com'], // CDN 도메인 허용
    formats: ['image/avif', 'image/webp'], // 최신 포맷 우선
  },
  
  // 번들 최적화
  // 배경: tRPC 클라이언트 코드가 크므로 트리 셰이킹 최적화 필요
  // 효과: 번들 크기 15-20% 감소, 초기 로딩 시간 단축
  experimental: {
    optimizePackageImports: ['@trpc/client', '@trpc/server'],
  },
  
  // 캐싱 전략
  // 배경: 정적 자산은 해시 기반 파일명으로 변경되지 않으므로 장기 캐싱 가능
  // 효과: CDN 캐시 히트율 95% 이상, 반복 방문자 로딩 시간 90% 단축
  async headers() {
    return [
      {
        source: '/_next/static/:path*',
        headers: [
          {
            key: 'Cache-Control',
            value: 'public, max-age=31536000, immutable', // 1년 캐싱
          },
        ],
      },
    ];
  },
  
  // API 프록시 (개발 환경)
  // 배경: 개발 시 CORS 문제 해결 및 동일 도메인에서 API 호출
  // 장점: 개발 환경에서 프로덕션과 동일한 경험
  // 주의: 프로덕션에서는 API Gateway가 이 역할 수행
  async rewrites() {
    return [
      {
        source: '/api/trpc/:path*',
        destination: 'http://localhost:4000/trpc/:path*',
      },
    ];
  },
};

module.exports = nextConfig;

// lib/trpc.ts
import { createTRPCNext } from '@trpc/next';
import { httpBatchLink } from '@trpc/client';
import type { AppRouter } from '../../../backend/src/app.router';

// 환경별 API URL 자동 감지
// 배경: SSR, 클라이언트, 배포 환경에서 각각 다른 URL 필요
// 동작: 실행 환경을 감지하여 적절한 API 엔드포인트 반환
function getBaseUrl() {
  if (typeof window !== 'undefined') return ''; // 클라이언트: 상대 경로
  if (process.env.VERCEL_URL) return `https://${process.env.VERCEL_URL}`; // Vercel 배포
  return `http://localhost:${process.env.PORT ?? 3000}`; // 로컬 개발
}

export const trpc = createTRPCNext<AppRouter>({
  config({ ctx }) {
    return {
      links: [
        // HTTP Batch Link: 여러 요청을 하나로 묶어 네트워크 효율성 향상
        // 배경: React의 자동 배칭과 유사하게 동시 API 호출을 묶음
        // 효과: 네트워크 요청 수 50-70% 감소, 응답 시간 개선
        httpBatchLink({
          url: `${getBaseUrl()}/api/trpc`,
          
          // 인증 헤더 자동 추가
          // SSR과 클라이언트 환경 모두 지원
          async headers() {
            const token = typeof window !== 'undefined' 
              ? localStorage.getItem('auth-token') // 클라이언트
              : ctx?.req?.cookies?.['auth-token']; // SSR
              
            return {
              authorization: token ? `Bearer ${token}` : '',
            };
          },
        }),
      ],
      
      // React Query 통합 설정
      // 배경: tRPC는 내부적으로 React Query를 사용하여 강력한 캐싱 제공
      // staleTime: 데이터가 "신선"하다고 간주되는 시간 (재요청 안함)
      // cacheTime: 메모리에 캐시를 보관하는 시간
      queryClientConfig: {
        defaultOptions: {
          queries: {
            staleTime: 60 * 1000, // 1분간 재요청 방지
            cacheTime: 5 * 60 * 1000, // 5분간 메모리 캐시 유지
          },
        },
      },
    };
  },
  ssr: true,
});

// 기존 방식 - 타입 안전성 없음
const response = await fetch('/api/products');
const products = await response.json(); // any 타입!
products.forEach(p => console.log(p.name)); // 런타임 에러 가능성

// app/products/page.tsx
'use client';

import { trpc } from '@/lib/trpc';
import { ProductCard } from '@/components/product-card';
import { LoadingSpinner } from '@/components/loading-spinner';

export default function ProductsPage() {
  // tRPC 쿼리 - 완전한 타입 안전성
  // 백엔드 스키마 변경 시 컴파일 타임에 에러 발생
  // React Query 기반으로 자동 캐싱, 백그라운드 업데이트 지원
  const { 
    data: products, // Product[] 타입 자동 추론
    isLoading, 
    error, // TRPCError 타입
    refetch 
  } = trpc.product.getAll.useQuery({
    page: 1,
    limit: 20,
    category: 'electronics', // 백엔드 enum과 동기화
  });

  // 무한 스크롤 - React Query의 강력한 기능 활용
  // 배경: 대용량 데이터를 페이지 단위로 로딩하여 성능 최적화
  // 장점: 자동 중복 제거, 백그라운드 프리페칭, 에러 재시도
  const {
    data: infiniteProducts,
    fetchNextPage, // 다음 페이지 로딩 함수
    hasNextPage, // 더 로딩할 데이터 존재 여부
    isFetchingNextPage, // 로딩 상태
  } = trpc.product.getInfinite.useInfiniteQuery(
    { limit: 10 },
    {
      getNextPageParam: (lastPage) => lastPage.nextCursor, // 커서 기반 페이징
    }
  );

  if (isLoading) return <LoadingSpinner />;
  if (error) return <div>Error: {error.message}</div>;

  return (
    <div className="grid grid-cols-1 md:grid-cols-3 lg:grid-cols-4 gap-6">
      {products?.map((product) => (
        <ProductCard 
          key={product.id} 
          product={product} 
          onUpdate={() => refetch()}
        />
      ))}
    </div>
  );
}

// components/product-card.tsx
import { trpc } from '@/lib/trpc';

interface ProductCardProps {
  product: {
    id: string;
    name: string;
    price: number;
    stock: number;
  };
  onUpdate: () => void;
}

export function ProductCard({ product, onUpdate }: ProductCardProps) {
  // Mutation - 서버 상태 변경 작업
  // 배경: 쿼리와 달리 뮤테이션은 서버 데이터를 변경하는 작업
  // 특징: 자동 재시도 없음, 수동 트리거, 낙관적 업데이트 지원
  const addToCartMutation = trpc.cart.addItem.useMutation({
    onSuccess: () => {
      onUpdate(); // 관련 쿼리 무효화하여 최신 데이터 반영
      toast.success('장바구니에 추가되었습니다');
    },
    onError: (error) => {
      toast.error(error.message); // 타입 안전한 에러 메시지
    },
  });

  const handleAddToCart = () => {
    addToCartMutation.mutate({
      productId: product.id,
      quantity: 1,
    });
  };

  return (
    <div className="border rounded-lg p-4">
      <h3 className="font-semibold">{product.name}</h3>
      <p className="text-gray-600">${product.price}</p>
      <p className="text-sm">재고: {product.stock}개</p>
      
      <button
        onClick={handleAddToCart}
        disabled={addToCartMutation.isLoading || product.stock === 0}
        className="mt-2 w-full bg-blue-500 text-white py-2 rounded disabled:opacity-50"
      >
        {addToCartMutation.isLoading ? '추가 중...' : '장바구니 담기'}
      </button>
    </div>
  );
}

# kong.yml - Kong API Gateway 설정
_format_version: "3.0"

services:
  - name: nextjs-frontend
    url: http://frontend-service:3000
    routes:
      - name: frontend-route
        paths: ["/"]
        strip_path: false

  - name: nestjs-backend
    url: http://backend-service:4000
    routes:
      - name: api-route
        paths: ["/api"]
        strip_path: false

plugins:
  # Rate Limiting - DDoS 방어 및 서비스 보호
  # 배경: 악의적 요청이나 버그로 인한 과도한 요청 방지
  # 효과: 서버 안정성 확보, 공정한 리소스 사용
  - name: rate-limiting
    config:
      minute: 100  # 분당 100회 제한
      hour: 1000   # 시간당 1000회 제한
      
  # JWT 인증 - 토큰 기반 인증
  # 배경: 세션 기반 인증의 확장성 문제 해결
  # 장점: 무상태, 마이크로서비스 간 인증 정보 공유 용이
  - name: jwt
    config:
      secret_is_base64: false
      
  # CORS - 브라우저 보안 정책 처리
  # 배경: SPA에서 다른 도메인 API 호출 시 필요
  # 보안: 허용된 도메인만 API 접근 가능
  - name: cors
    config:
      origins: ["https://yourdomain.com"]
      methods: ["GET", "POST", "PUT", "DELETE"]
      
  # 중앙화된 로깅 - 모든 API 요청/응답 기록
  # 배경: 마이크로서비스 환경에서 통합 로그 관리 필요
  # 활용: 디버깅, 성능 분석, 보안 모니터링
  - name: http-log
    config:
      http_endpoint: "https://logs.yourdomain.com/api/logs"

# nginx.conf
# Next.js 서버 풀 정의
# least_conn: 활성 연결이 가장 적은 서버로 요청 전달
# 배경: SSR 작업은 CPU 집약적이므로 연결 수 기반 분산이 효율적
upstream nextjs_backend {
    least_conn;
    server nextjs-1:3000 max_fails=3 fail_timeout=30s; # 3회 실패 시 30초간 제외
    server nextjs-2:3000 max_fails=3 fail_timeout=30s;
    server nextjs-3:3000 max_fails=3 fail_timeout=30s;
}

upstream nestjs_backend {
    least_conn;
    server nestjs-1:4000 max_fails=3 fail_timeout=30s;
    server nestjs-2:4000 max_fails=3 fail_timeout=30s;
    server nestjs-3:4000 max_fails=3 fail_timeout=30s;
}

server {
    listen 80;
    server_name yourdomain.com;
    
    # Health Check
    location /health {
        access_log off;
        return 200 "healthy\n";
    }
    
    # Frontend (Next.js)
    location / {
        proxy_pass http://nextjs_backend;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        
        # 타임아웃 설정 - 사용자 경험과 리소스 효율성 균형
        # connect: 서버 연결 시도 시간 (짧게 설정하여 빠른 장애 감지)
        # send/read: SSR 처리 시간 고려하여 충분히 설정
        proxy_connect_timeout 5s;   # 빠른 장애 감지
        proxy_send_timeout 60s;     # SSR 처리 시간 고려
        proxy_read_timeout 60s;
    }
    
    # Backend API (NestJS)
    location /api/ {
        proxy_pass http://nestjs_backend;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        
        # WebSocket 프로토콜 업그레이드 지원
        # 배경: tRPC는 실시간 기능을 위해 WebSocket 사용 가능
        # 동작: HTTP 요청을 WebSocket으로 업그레이드 시 프록시 처리
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
    }
}

// src/main.ts
import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
import { TrpcRouter } from './trpc/trpc.router';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  
  // CORS 설정 - 브라우저 보안 정책 처리
  // 배경: SPA와 API 서버가 다른 도메인에 있을 때 필요
  // credentials: true로 쿠키 기반 인증 지원
  app.enableCors({
    origin: process.env.FRONTEND_URL || 'http://localhost:3000',
    credentials: true, // 쿠키, 인증 헤더 허용
  });
  
  // tRPC 라우터 설정
  const trpc = app.get(TrpcRouter);
  trpc.applyMiddleware(app);
  
  // Health Check 엔드포인트
  // 배경: 로드 밸런서와 오케스트레이션 도구가 서비스 상태 확인
  // 용도: 무중단 배포, 자동 복구, 모니터링
  app.use('/health', (req, res) => {
    res.status(200).json({ 
      status: 'ok', 
      timestamp: new Date().toISOString(),
      uptime: process.uptime() // 서비스 실행 시간
    });
  });
  
  await app.listen(process.env.PORT || 4000);
}

bootstrap();

// src/trpc/trpc.router.ts
import { Injectable } from '@nestjs/common';
import { TRPCError, initTRPC } from '@trpc/server';
import { z } from 'zod';
import { UserService } from '../user/user.service';
import { ProductService } from '../product/product.service';
import { OrderService } from '../order/order.service';

// Context 정의 - 모든 프로시저에서 사용할 수 있는 공통 데이터
// 배경: 인증 정보, 데이터베이스 연결 등을 프로시저에 전달
// 장점: 의존성 주입과 유사한 패턴으로 테스트 용이성 확보
export interface Context {
  user?: {
    id: string;
    email: string;
    role: string;
  };
  // 필요시 추가: db, redis, logger 등
}

const t = initTRPC.context<Context>().create();

// 인증 미들웨어 - 보호된 프로시저에 적용
// 동작 원리: 컨텍스트에서 사용자 정보 확인 후 다음 단계로 전달
// 장점: 횡단 관심사 분리, 재사용 가능한 인증 로직
const authMiddleware = t.middleware(({ ctx, next }) => {
  if (!ctx.user) {
    throw new TRPCError({ code: 'UNAUTHORIZED' });
  }
  return next({
    ctx: {
      user: ctx.user, // 타입 좁히기로 user가 존재함을 보장
    },
  });
});

// 프로시저 팩토리 - 재사용 가능한 프로시저 템플릿
// publicProcedure: 인증 불필요 (로그인, 회원가입, 공개 데이터 조회)
// protectedProcedure: 인증 필요 (개인 정보, 주문, 결제)
const publicProcedure = t.procedure;
const protectedProcedure = t.procedure.use(authMiddleware);

@Injectable()
export class TrpcRouter {
  constructor(
    private userService: UserService,
    private productService: ProductService,
    private orderService: OrderService,
  ) {}

  appRouter = t.router({
    // User 관련 라우터
    user: t.router({
      // 회원가입 - Zod 스키마로 입력 검증
      // 장점: 런타임 검증 + 컴파일 타임 타입 추론
      // 보안: SQL 인젝션, XSS 등 입력 기반 공격 방어
      register: publicProcedure
        .input(z.object({
          email: z.string().email(),        // 이메일 형식 검증
          password: z.string().min(8),      // 최소 8자 패스워드
          name: z.string().min(2),          // 최소 2자 이름
        }))
        .mutation(async ({ input }) => {
          return await this.userService.register(input);
        }),

      // 로그인
      login: publicProcedure
        .input(z.object({
          email: z.string().email(),
          password: z.string(),
        }))
        .mutation(async ({ input }) => {
          return await this.userService.login(input);
        }),

      // 프로필 조회
      profile: protectedProcedure
        .query(async ({ ctx }) => {
          return await this.userService.findById(ctx.user.id);
        }),
    }),

    // Product 관련 라우터
    product: t.router({
      // 상품 목록 조회
      getAll: publicProcedure
        .input(z.object({
          page: z.number().default(1),
          limit: z.number().default(20),
          category: z.string().optional(),
          search: z.string().optional(),
        }))
        .query(async ({ input }) => {
          return await this.productService.findAll(input);
        }),

      // 커서 기반 페이지네이션 - 대용량 데이터 효율적 처리
      // 배경: offset 기반 페이징은 뒤쪽 페이지에서 성능 저하
      // 장점: 일관된 성능, 실시간 데이터 추가에도 안정적
      getInfinite: publicProcedure
        .input(z.object({
          limit: z.number().min(1).max(100).default(10), // 과도한 요청 방지
          cursor: z.string().optional(), // 마지막 아이템의 ID
        }))
        .query(async ({ input }) => {
          const { limit, cursor } = input;
          // limit + 1로 조회하여 다음 페이지 존재 여부 확인
          const products = await this.productService.findInfinite({
            limit: limit + 1,
            cursor,
          });
          
          let nextCursor: typeof cursor | undefined = undefined;
          if (products.length > limit) {
            const nextItem = products.pop(); // 마지막 아이템 제거
            nextCursor = nextItem!.id; // 다음 페이지 커서로 사용
          }
          
          return {
            products,
            nextCursor, // 클라이언트에서 다음 요청 시 사용
          };
        }),

      // 상품 상세 조회
      getById: publicProcedure
        .input(z.string())
        .query(async ({ input }) => {
          return await this.productService.findById(input);
        }),

      // 상품 생성 (관리자만)
      create: protectedProcedure
        .input(z.object({
          name: z.string(),
          description: z.string(),
          price: z.number().positive(),
          stock: z.number().nonnegative(),
          categoryId: z.string(),
        }))
        .mutation(async ({ input, ctx }) => {
          // 역할 기반 접근 제어 (RBAC)
          // 배경: 인증된 사용자라도 모든 작업을 할 수 있으면 안됨
          // 보안: 최소 권한 원칙 적용
          if (ctx.user.role !== 'admin') {
            throw new TRPCError({ code: 'FORBIDDEN' });
          }
          
          return await this.productService.create(input);
        }),
    }),

    // Cart 관련 라우터
    cart: t.router({
      // 장바구니 아이템 추가
      addItem: protectedProcedure
        .input(z.object({
          productId: z.string(),
          quantity: z.number().positive(),
        }))
        .mutation(async ({ input, ctx }) => {
          return await this.orderService.addToCart(ctx.user.id, input);
        }),

      // 장바구니 조회
      get: protectedProcedure
        .query(async ({ ctx }) => {
          return await this.orderService.getCart(ctx.user.id);
        }),
    }),

    // Order 관련 라우터
    order: t.router({
      // 주문 생성
      create: protectedProcedure
        .input(z.object({
          items: z.array(z.object({
            productId: z.string(),
            quantity: z.number().positive(),
          })),
          shippingAddress: z.object({
            street: z.string(),
            city: z.string(),
            zipCode: z.string(),
          }),
        }))
        .mutation(async ({ input, ctx }) => {
          return await this.orderService.createOrder(ctx.user.id, input);
        }),

      // 주문 목록 조회
      getAll: protectedProcedure
        .input(z.object({
          page: z.number().default(1),
          limit: z.number().default(10),
        }))
        .query(async ({ input, ctx }) => {
          return await this.orderService.findByUserId(ctx.user.id, input);
        }),
    }),
  });

  // Express 어댑터 - tRPC를 HTTP 서버에 연결
  // 배경: tRPC는 전송 계층에 독립적이므로 어댑터 필요
  // 지원: HTTP, WebSocket, 서버리스 등 다양한 환경
  applyMiddleware(app: any) {
    const { createExpressMiddleware } = require('@trpc/server/adapters/express');
    
    app.use('/trpc', createExpressMiddleware({
      router: this.appRouter,
      // 컨텍스트 생성 - 각 요청마다 실행
      createContext: ({ req, res }) => {
        // JWT 토큰 파싱 및 검증
        const token = req.headers.authorization?.replace('Bearer ', '');
        let user = null;
        
        if (token) {
          try {
            user = this.userService.verifyToken(token);
          } catch (error) {
            // 토큰 검증 실패 시 익명 사용자로 처리
            // 에러를 던지지 않아 공개 프로시저는 정상 동작
          }
        }
        
        return { user }; // 모든 프로시저에서 사용 가능
      },
    }));
  }
}

// 타입 추출 (프론트엔드에서 사용)
export type AppRouter = TrpcRouter['appRouter'];

// src/product/product.service.ts
import { Injectable } from '@nestjs/common';
import { PrismaService } from '../prisma/prisma.service';
import { RedisService } from '../redis/redis.service';
import { EventEmitter2 } from '@nestjs/event-emitter';

@Injectable()
export class ProductService {
  constructor(
    private prisma: PrismaService,
    private redis: RedisService,
    private eventEmitter: EventEmitter2,
  ) {}

  // 캐시 우선 조회 패턴 (Cache-Aside)
  // 동작 순서: 1) 캐시 확인 → 2) 캐시 미스 시 DB 조회 → 3) 결과 캐시 저장
  // 장점: DB 부하 90% 이상 감소, 응답 시간 10배 개선
  async findAll(params: {
    page: number;
    limit: number;
    category?: string;
    search?: string;
  }) {
    // 파라미터 기반 캐시 키 생성 (동일 조건은 동일 캐시)
    const cacheKey = `products:${JSON.stringify(params)}`;
    
    // 1단계: Redis 캐시 확인 (평균 1ms)
    const cached = await this.redis.get(cacheKey);
    if (cached) {
      return JSON.parse(cached); // 캐시 히트 - 즉시 반환
    }
    
    // 2단계: 캐시 미스 시 DB 조회 (평균 50-100ms)
    const products = await this.prisma.product.findMany({
      where: {
        // 동적 필터링 - 조건부 쿼리 구성
        ...(params.category && { categoryId: params.category }),
        ...(params.search && {
          OR: [ // 다중 필드 검색
            { name: { contains: params.search, mode: 'insensitive' } },
            { description: { contains: params.search, mode: 'insensitive' } },
          ],
        }),
      },
      skip: (params.page - 1) * params.limit, // 오프셋 페이징
      take: params.limit,
      include: { // N+1 문제 방지를 위한 조인
        category: true,
        images: true,
      },
    });
    
    // 3단계: 결과를 캐시에 저장 (5분 TTL)
    // TTL 설정 이유: 데이터 신선도와 메모리 사용량 균형
    await this.redis.setex(cacheKey, 300, JSON.stringify(products));
    
    return products;
  }

  // 재고 업데이트 - 동시성 제어와 이벤트 발행
  async updateStock(productId: string, quantity: number) {
    // 데이터베이스 트랜잭션 - ACID 속성 보장
    // 배경: 재고 차감은 원자적 연산이어야 함 (동시 주문 시 경쟁 상태 방지)
    const product = await this.prisma.$transaction(async (tx) => {
      const updated = await tx.product.update({
        where: { id: productId },
        data: {
          stock: { decrement: quantity }, // 원자적 감소 연산
        },
      });
      
      // 비즈니스 규칙 검증 - 음수 재고 방지
      if (updated.stock < 0) {
        throw new Error('재고가 부족합니다'); // 트랜잭션 롤백 트리거
      }
      
      return updated;
    });
    
    // 캐시 무효화 - 데이터 일관성 유지
    // 패턴 매칭으로 관련된 모든 캐시 제거
    await this.redis.del(`product:${productId}`);
    await this.redis.del('products:*'); // 상품 목록 캐시들
    
    // 도메인 이벤트 발행 - 다른 서비스에 변경 사항 알림
    // 장점: 서비스 간 느슨한 결합, 확장 가능한 아키텍처
    this.eventEmitter.emit('product.stock.updated', {
      productId,
      newStock: product.stock,
    });
    
    return product;
  }
}

// src/order/order.service.ts
import { Injectable } from '@nestjs/common';
import { OnEvent } from '@nestjs/event-emitter';

@Injectable()
export class OrderService {
  constructor(
    private prisma: PrismaService,
    private productService: ProductService,
    private paymentService: PaymentService,
  ) {}

  async createOrder(userId: string, orderData: any) {
    // 1. 재고 확인 및 차감
    for (const item of orderData.items) {
      await this.productService.updateStock(item.productId, item.quantity);
    }
    
    // 2. 주문 생성
    const order = await this.prisma.order.create({
      data: {
        userId,
        status: 'pending',
        items: {
          create: orderData.items.map(item => ({
            productId: item.productId,
            quantity: item.quantity,
            price: item.price,
          })),
        },
        shippingAddress: orderData.shippingAddress,
      },
    });
    
    // 3. 결제 처리 (비동기)
    this.paymentService.processPayment(order.id, order.total);
    
    return order;
  }

  // 도메인 이벤트 리스너 - 횡단 관심사 처리
  // 배경: 재고 변경은 여러 비즈니스 로직을 트리거 (알림, 재주문, 분석 등)
  // 장점: 단일 책임 원칙, 확장 가능한 이벤트 처리
  @OnEvent('product.stock.updated')
  handleStockUpdate(payload: { productId: string; newStock: number }) {
    console.log(`Product ${payload.productId} stock updated to ${payload.newStock}`);
    
    // 비즈니스 규칙: 재고 부족 임계값 체크
    // 실제 환경에서는 상품별로 다른 임계값 설정 가능
    if (payload.newStock <= 5) {
      this.notifyLowStock(payload.productId);
    }
  }
  
  private async notifyLowStock(productId: string) {
    // 관리자에게 알림 발송
    // 또는 자동 재주문 로직
  }
}

// src/prisma/prisma.service.ts
import { Injectable, OnModuleInit } from '@nestjs/common';
import { PrismaClient } from '@prisma/client';

// Prisma 서비스 - 데이터베이스 연결 및 설정 관리
// 배경: NestJS DI 컨테이너에서 관리되는 싱글톤 서비스
// 장점: 연결 풀링, 자동 재연결, 로깅 통합
@Injectable()
export class PrismaService extends PrismaClient implements OnModuleInit {
  constructor() {
    super({
      datasources: {
        db: {
          url: process.env.DATABASE_URL, // 메인 데이터베이스
        },
      },
      log: ['query', 'info', 'warn', 'error'], // 개발/디버깅용 쿼리 로깅
    });
  }

  async onModuleInit() {
    await this.$connect(); // 애플리케이션 시작 시 DB 연결 확인
    
    // Prisma 미들웨어 - 쿼리 실행 전/후 처리
    // 동작 원리: 모든 DB 쿼리를 가로채서 라우팅 결정
    // 장점: 애플리케이션 코드 변경 없이 읽기/쓰기 분산
    this.$use(async (params, next) => {
      // 읽기 전용 쿼리 감지 및 Read Replica로 라우팅
      // 배경: 읽기 작업은 마스터 DB 부하를 줄이고 지연 시간 최적화
      if (params.action === 'findMany' || params.action === 'findFirst' || params.action === 'findUnique') {
        params.datasource = 'replica'; // Read Replica 사용
      }
      // 쓰기 작업(create, update, delete)은 자동으로 메인 DB 사용
      
      return next(params);
    });
  }
}

// prisma/schema.prisma
generator client {
  provider = "prisma-client-js"
}

datasource db {
  provider = "postgresql"
  url      = env("DATABASE_URL")
}

datasource replica {
  provider = "postgresql"
  url      = env("DATABASE_REPLICA_URL")
}

// 사용자 모델 - 인증 및 권한 관리
model User {
  id        String   @id @default(cuid()) // 충돌 방지를 위한 CUID 사용
  email     String   @unique              // 로그인 식별자, 유니크 제약
  name      String
  role      Role     @default(USER)       // 기본값으로 일반 사용자 권한
  orders    Order[]                       // 1:N 관계 - 사용자의 주문들
  createdAt DateTime @default(now())      // 생성 시점 자동 기록
  updatedAt DateTime @updatedAt           // 수정 시점 자동 업데이트

  @@map("users") // 실제 테이블명 매핑
}

// 상품 모델 - 전자상거래 핵심 엔티티
model Product {
  id          String      @id @default(cuid())
  name        String
  description String
  price       Decimal     @db.Decimal(10, 2)  // 정확한 금액 계산을 위한 Decimal 타입
  stock       Int                              // 재고 수량 (동시성 제어 필요)
  categoryId  String
  category    Category    @relation(fields: [categoryId], references: [id]) // 외래키 관계
  orderItems  OrderItem[]                      // 1:N - 주문 항목들
  images      ProductImage[]                   // 1:N - 상품 이미지들
  createdAt   DateTime    @default(now())
  updatedAt   DateTime    @updatedAt

  // 성능 최적화를 위한 인덱스
  @@index([categoryId]) // 카테고리별 조회 최적화
  @@index([name])       // 상품명 검색 최적화
  @@map("products")
}

model Order {
  id              String      @id @default(cuid())
  userId          String
  user            User        @relation(fields: [userId], references: [id])
  status          OrderStatus @default(PENDING)
  total           Decimal     @db.Decimal(10, 2)
  items           OrderItem[]
  shippingAddress Json
  createdAt       DateTime    @default(now())
  updatedAt       DateTime    @updatedAt

  @@index([userId])
  @@index([status])
  @@map("orders")
}

enum Role {
  USER
  ADMIN
}

enum OrderStatus {
  PENDING
  PAID
  SHIPPED
  DELIVERED
  CANCELLED
}

// src/redis/redis.service.ts
import { Injectable } from '@nestjs/common';
import { Redis } from 'ioredis';

// Redis 서비스 - 고성능 캐싱 및 메시징
// 배경: 단일 연결로는 Pub/Sub과 일반 명령어 동시 사용 불가
// 해결: 용도별 연결 분리로 블로킹 방지
@Injectable()
export class RedisService {
  private client: Redis;     // 일반 캐시 작업용
  private subscriber: Redis; // 메시지 구독 전용
  private publisher: Redis;  // 메시지 발행 전용

  constructor() {
    // 연결 설정 - 장애 복구 및 재시도 정책
    const redisConfig = {
      host: process.env.REDIS_HOST,
      port: parseInt(process.env.REDIS_PORT || '6379'),
      password: process.env.REDIS_PASSWORD,
      retryDelayOnFailover: 100,    // 장애 시 100ms 후 재시도
      maxRetriesPerRequest: 3,      // 최대 3회 재시도
    };

    // 용도별 연결 생성 - 성능과 안정성 확보
    this.client = new Redis(redisConfig);
    this.subscriber = new Redis(redisConfig);
    this.publisher = new Redis(redisConfig);
  }

  // 기본 캐시 작업 - Cache-Aside 패턴 구현
  async get(key: string): Promise<string | null> {
    return await this.client.get(key); // O(1) 시간복잡도
  }

  // TTL(Time To Live) 지원 캐시 저장
  // 배경: 메모리 사용량 제한 및 데이터 신선도 관리
  async set(key: string, value: string, ttl?: number): Promise<void> {
    if (ttl) {
      await this.client.setex(key, ttl, value); // 원자적 SET + EXPIRE
    } else {
      await this.client.set(key, value); // 영구 저장
    }
  }

  async del(key: string): Promise<void> {
    await this.client.del(key);
  }

  // 패턴 기반 캐시 무효화 - 관련 데이터 일괄 삭제
  // 주의: KEYS 명령어는 O(N) 복잡도로 프로덕션에서 주의 필요
  // 대안: Redis 6.0+ SCAN 명령어 또는 캐시 태깅 사용 권장
  async invalidatePattern(pattern: string): Promise<void> {
    const keys = await this.client.keys(pattern);
    if (keys.length > 0) {
      await this.client.del(...keys); // 배치 삭제로 네트워크 효율성 확보
    }
  }

  // Redis Pub/Sub - 실시간 메시징
  // 배경: 마이크로서비스 간 느슨한 결합의 이벤트 통신
  // 장점: 확장성, 장애 격리, 비동기 처리
  async publish(channel: string, message: string): Promise<void> {
    await this.publisher.publish(channel, message);
  }

  // 채널 구독 및 메시지 처리
  // 패턴: Observer 패턴의 분산 버전
  async subscribe(channel: string, callback: (message: string) => void): Promise<void> {
    await this.subscriber.subscribe(channel);
    this.subscriber.on('message', (receivedChannel, message) => {
      if (receivedChannel === channel) {
        callback(message); // 메시지 처리 콜백 실행
      }
    });
  }

  // 분산 락 - 동시성 제어
  // 배경: 여러 서버에서 동일 리소스 접근 시 경쟁 상태 방지
  // 사용 사례: 재고 차감, 중복 결제 방지, 배치 작업 중복 실행 방지
  async acquireLock(key: string, ttl: number = 10): Promise<boolean> {
    // SET NX PX - 원자적 연산으로 락 획득
    // NX: key가 존재하지 않을 때만 설정
    // PX: 밀리초 단위 TTL (데드락 방지)
    const result = await this.client.set(
      `lock:${key}`,
      'locked',
      'PX',
      ttl * 1000,
      'NX'
    );
    return result === 'OK'; // 락 획득 성공 여부
  }

  // 락 해제 - 작업 완료 후 다른 프로세스가 접근 가능하도록
  async releaseLock(key: string): Promise<void> {
    await this.client.del(`lock:${key}`);
  }
}

// 캐싱 데코레이터 - AOP(Aspect-Oriented Programming) 패턴
// 배경: 비즈니스 로직과 캐싱 로직 분리로 코드 가독성 향상
// 장점: 선언적 캐싱, 재사용성, 유지보수성
export function Cacheable(ttl: number = 300) {
  return function (target: any, propertyName: string, descriptor: PropertyDescriptor) {
    const method = descriptor.value;

    // 메서드 래핑 - 원본 메서드 실행 전후에 캐싱 로직 추가
    descriptor.value = async function (...args: any[]) {
      const redis = this.redis || this.redisService;
      // 클래스명:메서드명:인자 기반 유니크 키 생성
      const cacheKey = `${target.constructor.name}:${propertyName}:${JSON.stringify(args)}`;
      
      // 1단계: 캐시 확인 (Cache Hit 체크)
      const cached = await redis.get(cacheKey);
      if (cached) {
        return JSON.parse(cached); // 캐시된 결과 즉시 반환
      }
      
      // 2단계: 캐시 미스 시 원본 메서드 실행
      const result = await method.apply(this, args);
      
      // 3단계: 결과를 캐시에 저장 (다음 호출을 위해)
      await redis.set(cacheKey, JSON.stringify(result), ttl);
      
      return result;
    };
  };
}

// src/websocket/websocket.gateway.ts
import {
  WebSocketGateway,
  WebSocketServer,
  SubscribeMessage,
  OnGatewayConnection,
  OnGatewayDisconnect,
} from '@nestjs/websockets';
import { Server, Socket } from 'socket.io';
import { OnEvent } from '@nestjs/event-emitter';

// WebSocket Gateway - 실시간 양방향 통신 관리
// 배경: HTTP의 요청-응답 모델로는 서버에서 클라이언트로 능동적 푸시 불가
// 해결: WebSocket으로 지속적인 연결 유지 및 실시간 메시지 교환
@WebSocketGateway({
  cors: {
    origin: process.env.FRONTEND_URL, // CORS 정책 설정
    credentials: true,                // 쿠키 기반 인증 허용
  },
})
export class WebSocketGateway implements OnGatewayConnection, OnGatewayDisconnect {
  @WebSocketServer()
  server: Server; // Socket.IO 서버 인스턴스

  // 연결된 사용자 추적 - 메모리 기반 세션 관리
  // 프로덕션: Redis 등 외부 저장소 사용 권장 (서버 재시작 시 세션 유지)
  private connectedUsers = new Map<string, string>(); // socketId -> userId

  // 클라이언트 연결 이벤트 - 새로운 WebSocket 연결 시 실행
  handleConnection(client: Socket) {
    console.log(`Client connected: ${client.id}`);
    // 여기서 추가 가능한 작업:
    // - IP 기반 Rate Limiting
    // - 연결 수 모니터링
    // - 인증 토큰 사전 검증
  }

  // 클라이언트 연결 해제 - 네트워크 끊김, 브라우저 종료 등
  handleDisconnect(client: Socket) {
    const userId = this.connectedUsers.get(client.id);
    if (userId) {
      this.connectedUsers.delete(client.id); // 메모리 누수 방지
      console.log(`User ${userId} disconnected`);
      // 추가 정리 작업: 룸 탈퇴, 상태 업데이트 등
    }
  }

  // 사용자 인증 및 개인 룸 참여
  // 배경: 개인화된 알림 (주문 상태, 개인 메시지 등)을 위한 전용 채널
  @SubscribeMessage('join')
  handleJoin(client: Socket, data: { userId: string }) {
    // TODO: 실제 환경에서는 JWT 토큰 검증 필요
    this.connectedUsers.set(client.id, data.userId);
    client.join(`user:${data.userId}`); // 개인 전용 룸 참여
    console.log(`User ${data.userId} joined`);
  }

  // 상품별 실시간 정보 구독
  // 사용 사례: 재고 변동, 가격 변경, 리뷰 추가 등
  @SubscribeMessage('join-product')
  handleJoinProduct(client: Socket, data: { productId: string }) {
    client.join(`product:${data.productId}`); // 상품별 룸 참여
    // 룸 기반 메시징으로 해당 상품에 관심있는 사용자들만 업데이트 수신
  }

  // 도메인 이벤트를 WebSocket 메시지로 변환
  // 패턴: Event-Driven Architecture + Real-time Messaging
  
  // 재고 변동 실시간 알림
  // 배경: 플래시 세일, 한정 상품 등에서 실시간 재고 정보 중요
  @OnEvent('product.stock.updated')
  handleStockUpdate(payload: { productId: string; newStock: number }) {
    // 해당 상품을 보고 있는 모든 사용자에게 브로드캐스트
    this.server.to(`product:${payload.productId}`).emit('stock-updated', {
      productId: payload.productId,
      stock: payload.newStock,
    });
  }

  // 개인 주문 상태 변경 알림
  // 배경: 주문 진행 상황을 실시간으로 고객에게 전달
  @OnEvent('order.status.updated')
  handleOrderUpdate(payload: { userId: string; orderId: string; status: string }) {
    // 특정 사용자의 개인 룸으로만 메시지 전송
    this.server.to(`user:${payload.userId}`).emit('order-updated', {
      orderId: payload.orderId,
      status: payload.status,
    });
  }
}

// 프론트엔드에서 WebSocket 사용
// hooks/use-websocket.ts
import { useEffect, useState } from 'react';
import { io, Socket } from 'socket.io-client';

// React Hook - WebSocket 연결 관리
// 배경: 컴포넌트 생명주기와 WebSocket 연결 동기화
// 장점: 재사용 가능한 로직, 자동 정리, 상태 관리
export function useWebSocket(userId?: string) {
  const [socket, setSocket] = useState<Socket | null>(null);
  const [connected, setConnected] = useState(false);

  useEffect(() => {
    if (!userId) return; // 인증되지 않은 사용자는 연결 안함

    // Socket.IO 클라이언트 생성 및 연결
    const newSocket = io(process.env.NEXT_PUBLIC_WS_URL || 'http://localhost:4000');
    
    // 연결 성공 이벤트
    newSocket.on('connect', () => {
      setConnected(true);
      newSocket.emit('join', { userId }); // 서버에 사용자 등록
    });

    // 연결 해제 이벤트 (네트워크 문제, 서버 재시작 등)
    newSocket.on('disconnect', () => {
      setConnected(false);
      // Socket.IO가 자동으로 재연결 시도
    });

    setSocket(newSocket);

    // 컴포넌트 언마운트 시 연결 정리
    return () => {
      newSocket.close(); // 메모리 누수 방지
    };
  }, [userId]); // userId 변경 시 재연결

  return { socket, connected };
}

// components/realtime-stock.tsx
// 실시간 재고 표시 컴포넌트
// 배경: 전자상거래에서 실시간 재고 정보는 구매 결정에 중요한 영향
// 기능: 서버에서 재고 변동 시 즉시 UI 업데이트
export function RealtimeStock({ productId, initialStock }) {
  const [stock, setStock] = useState(initialStock);
  const { socket } = useWebSocket(); // WebSocket 연결 재사용

  useEffect(() => {
    if (!socket) return;

    // 해당 상품의 실시간 업데이트 구독
    socket.emit('join-product', { productId });

    // 재고 업데이트 이벤트 리스너 등록
    socket.on('stock-updated', (data) => {
      if (data.productId === productId) {
        setStock(data.stock); // 실시간 재고 반영
      }
    });

    // 컴포넌트 정리 시 이벤트 리스너 제거
    return () => {
      socket.off('stock-updated'); // 메모리 누수 방지
    };
  }, [socket, productId]);

  // 재고 수준에 따른 시각적 피드백
  return (
    <div className={`text-sm ${stock <= 5 ? 'text-red-500' : 'text-green-500'}`}>
      재고: {stock}개 {stock <= 5 && '(품절 임박!)'}
    </div>
  );
}

# Frontend Dockerfile
FROM node:18-alpine AS base
WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production

FROM base AS build
COPY . .
RUN npm run build

FROM node:18-alpine AS runtime
WORKDIR /app
COPY --from=build /app/.next ./.next
COPY --from=build /app/public ./public
COPY --from=build /app/package.json ./package.json
COPY --from=base /app/node_modules ./node_modules

EXPOSE 3000
CMD ["npm", "start"]

# Backend Dockerfile
FROM node:18-alpine AS base
WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production

FROM base AS build
COPY . .
RUN npm run build

FROM node:18-alpine AS runtime
WORKDIR /app
COPY --from=build /app/dist ./dist
COPY --from=build /app/package.json ./package.json
COPY --from=base /app/node_modules ./node_modules

EXPOSE 4000
CMD ["node", "dist/main.js"]

# k8s/frontend-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: nextjs-frontend
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nextjs-frontend
  template:
    metadata:
      labels:
        app: nextjs-frontend
    spec:
      containers:
      - name: nextjs
        image: your-registry/nextjs-app:latest
        ports:
        - containerPort: 3000
        env:
        - name: NEXT_PUBLIC_API_URL
          value: "https://api.yourdomain.com"
        resources:
          requests:
            memory: "256Mi"
            cpu: "250m"
          limits:
            memory: "512Mi"
            cpu: "500m"
        livenessProbe:
          httpGet:
            path: /health
            port: 3000
          initialDelaySeconds: 30
          periodSeconds: 10
        readinessProbe:
          httpGet:
            path: /health
            port: 3000
          initialDelaySeconds: 5
          periodSeconds: 5

---
apiVersion: v1
kind: Service
metadata:
  name: nextjs-service
spec:
  selector:
    app: nextjs-frontend
  ports:
  - port: 80
    targetPort: 3000
  type: LoadBalancer

---
# k8s/backend-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: nestjs-backend
spec:
  replicas: 5
  selector:
    matchLabels:
      app: nestjs-backend
  template:
    metadata:
      labels:
        app: nestjs-backend
    spec:
      containers:
      - name: nestjs
        image: your-registry/nestjs-app:latest
        ports:
        - containerPort: 4000
        env:
        - name: DATABASE_URL
          valueFrom:
            secretKeyRef:
              name: db-secret
              key: url
        - name: REDIS_URL
          valueFrom:
            secretKeyRef:
              name: redis-secret
              key: url
        resources:
          requests:
            memory: "512Mi"
            cpu: "500m"
          limits:
            memory: "1Gi"
            cpu: "1000m"

---
# HPA (Horizontal Pod Autoscaler)
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: nestjs-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: nestjs-backend
  minReplicas: 3
  maxReplicas: 20
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 70
  - type: Resource
    resource:
      name: memory
      target:
        type: Utilization
        averageUtilization: 80

// src/monitoring/metrics.service.ts
import { Injectable } from '@nestjs/common';
import { Counter, Histogram, register } from 'prom-client';

@Injectable()
export class MetricsService {
  private httpRequestsTotal = new Counter({
    name: 'http_requests_total',
    help: 'Total number of HTTP requests',
    labelNames: ['method', 'route', 'status_code'],
  });

  private httpRequestDuration = new Histogram({
    name: 'http_request_duration_seconds',
    help: 'Duration of HTTP requests in seconds',
    labelNames: ['method', 'route'],
    buckets: [0.1, 0.5, 1, 2, 5],
  });

  private trpcCallsTotal = new Counter({
    name: 'trpc_calls_total',
    help: 'Total number of tRPC calls',
    labelNames: ['procedure', 'type', 'status'],
  });

  recordHttpRequest(method: string, route: string, statusCode: number, duration: number) {
    this.httpRequestsTotal.inc({ method, route, status_code: statusCode });
    this.httpRequestDuration.observe({ method, route }, duration);
  }

  recordTrpcCall(procedure: string, type: 'query' | 'mutation', status: 'success' | 'error') {
    this.trpcCallsTotal.inc({ procedure, type, status });
  }

  getMetrics() {
    return register.metrics();
  }
}

// tRPC 미들웨어에 메트릭 추가
const metricsMiddleware = t.middleware(async ({ path, type, next }) => {
  const start = Date.now();
  
  try {
    const result = await next();
    const duration = Date.now() - start;
    
    metricsService.recordTrpcCall(path, type, 'success');
    console.log(`tRPC ${type} ${path}: ${duration}ms`);
    
    return result;
  } catch (error) {
    metricsService.recordTrpcCall(path, type, 'error');
    throw error;
  }
});

// 프론트엔드 최적화
// components/optimized-product-list.tsx
import { memo, useMemo, useCallback } from 'react';
import { FixedSizeList as List } from 'react-window';

const ProductItem = memo(({ index, style, data }) => {
  const product = data[index];
  
  return (
    <div style={style}>
      <ProductCard product={product} />
    </div>
  );
});

export function OptimizedProductList({ products }) {
  // 가상화된 리스트로 대용량 데이터 처리
  const itemData = useMemo(() => products, [products]);
  
  const getItemSize = useCallback(() => 200, []);
  
  return (
    <List
      height={600}
      itemCount={products.length}
      itemSize={getItemSize}
      itemData={itemData}
    >
      {ProductItem}
    </List>
  );
}

// 이미지 최적화
export function OptimizedImage({ src, alt, ...props }) {
  return (
    <Image
      src={src}
      alt={alt}
      loading="lazy"
      placeholder="blur"
      blurDataURL="data:image/jpeg;base64,/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAAYEBQYFBAYGBQYHBwYIChAKCgkJChQODwwQFxQYGBcUFhYaHSUfGhsjHBYWICwgIyYnKSopGR8tMC0oMCUoKSj/2wBDAQcHBwoIChMKChMoGhYaKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCj/wAARCAABAAEDASIAAhEBAxEB/8QAFQABAQAAAAAAAAAAAAAAAAAAAAv/xAAUEAEAAAAAAAAAAAAAAAAAAAAA/8QAFQEBAQAAAAAAAAAAAAAAAAAAAAX/xAAUEQEAAAAAAAAAAAAAAAAAAAAA/9oADAMBAAIRAxEAPwCdABmX/9k="
      {...props}
    />
  );
}