func(w http.ResponseWriter, r *http.Request)

func Middleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        // 전처리 작업
        fmt.Println("미들웨어 시작")
        
        // 다음 핸들러 호출
        next.ServeHTTP(w, r)
        
        // 후처리 작업
        fmt.Println("미들웨어 종료")
    })
}

package main

import (
    "fmt"
    "log"
    "net/http"
    "time"
)

func LoggingMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        start := time.Now()
        
        // 요청 정보 로깅
        log.Printf("요청 시작: %s %s", r.Method, r.URL.Path)
        
        // 다음 핸들러 실행
        next.ServeHTTP(w, r)
        
        // 처리 시간 로깅
        duration := time.Since(start)
        log.Printf("요청 완료: %s %s (소요시간: %v)", 
            r.Method, r.URL.Path, duration)
    })
}

func HelloHandler(w http.ResponseWriter, r *http.Request) {
    time.Sleep(100 * time.Millisecond) // 작업 시뮬레이션
    fmt.Fprintf(w, "안녕하세요!")
}

func main() {
    mux := http.NewServeMux()
    mux.HandleFunc("/hello", HelloHandler)
    
    // 미들웨어 적용
    wrappedMux := LoggingMiddleware(mux)
    
    log.Println("서버 시작: http://localhost:8080")
    http.ListenAndServe(":8080", wrappedMux)
}

func main() {
    mux := http.NewServeMux()
    mux.HandleFunc("/api/data", DataHandler)
    
    // 미들웨어를 겹겹이 감싸기
    handler := LoggingMiddleware(
        AuthMiddleware(
            CORSMiddleware(mux),
        ),
    )
    
    http.ListenAndServe(":8080", handler)
}

type Middleware func(http.Handler) http.Handler

// 여러 미들웨어를 체인으로 연결
func Chain(middlewares ...Middleware) Middleware {
    return func(final http.Handler) http.Handler {
        // 역순으로 적용 (마지막부터 첫번째까지)
        for i := len(middlewares) - 1; i >= 0; i-- {
            final = middlewares[i](final)
        }
        return final
    }
}

func main() {
    mux := http.NewServeMux()
    mux.HandleFunc("/api/data", DataHandler)
    
    // 체인 함수로 깔끔하게 연결
    chain := Chain(
        LoggingMiddleware,
        AuthMiddleware,
        CORSMiddleware,
    )
    
    http.ListenAndServe(":8080", chain(mux))
}

import "github.com/justinas/alice"

func main() {
    mux := http.NewServeMux()
    mux.HandleFunc("/api/data", DataHandler)
    
    // Alice로 체인 구성
    chain := alice.New(
        LoggingMiddleware,
        AuthMiddleware,
        CORSMiddleware,
    ).Then(mux)
    
    http.ListenAndServe(":8080", chain)
}

package main

import (
    "context"
    "fmt"
    "net/http"
    "strings"
)

type contextKey string

const UserContextKey contextKey = "user"

func AuthMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        // Authorization 헤더 가져오기
        authHeader := r.Header.Get("Authorization")
        
        if authHeader == "" {
            http.Error(w, "인증 토큰이 필요합니다", http.StatusUnauthorized)
            return
        }
        
        // "Bearer " 접두사 제거
        token := strings.TrimPrefix(authHeader, "Bearer ")
        
        // 토큰 검증 (실제로는 JWT 라이브러리 사용)
        user, err := validateToken(token)
        if err != nil {
            http.Error(w, "유효하지 않은 토큰입니다", http.StatusUnauthorized)
            return
        }
        
        // 사용자 정보를 컨텍스트에 저장
        ctx := context.WithValue(r.Context(), UserContextKey, user)
        
        // 다음 핸들러에 전달
        next.ServeHTTP(w, r.WithContext(ctx))
    })
}

func validateToken(token string) (string, error) {
    // 실제로는 JWT 검증 로직이 들어가야 함
    if token == "valid-token-123" {
        return "user@example.com", nil
    }
    return "", fmt.Errorf("invalid token")
}

func ProtectedHandler(w http.ResponseWriter, r *http.Request) {
    // 컨텍스트에서 사용자 정보 가져오기
    user := r.Context().Value(UserContextKey).(string)
    fmt.Fprintf(w, "안녕하세요, %s님!", user)
}

func CORSMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        // CORS 헤더 설정
        w.Header().Set("Access-Control-Allow-Origin", "*")
        w.Header().Set("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS")
        w.Header().Set("Access-Control-Allow-Headers", "Content-Type, Authorization")
        
        // Preflight 요청 처리
        if r.Method == "OPTIONS" {
            w.WriteHeader(http.StatusOK)
            return
        }
        
        next.ServeHTTP(w, r)
    })
}

import (
    "net/http"
    "sync"
    "time"
)

type RateLimiter struct {
    requests map[string][]time.Time
    mu       sync.Mutex
    limit    int
    window   time.Duration
}

func NewRateLimiter(limit int, window time.Duration) *RateLimiter {
    return &RateLimiter{
        requests: make(map[string][]time.Time),
        limit:    limit,
        window:   window,
    }
}

func (rl *RateLimiter) Middleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        ip := r.RemoteAddr
        
        rl.mu.Lock()
        defer rl.mu.Unlock()
        
        now := time.Now()
        
        // 이전 요청 기록 가져오기
        requests := rl.requests[ip]
        
        // 시간 윈도우 밖의 요청 제거
        var validRequests []time.Time
        for _, reqTime := range requests {
            if now.Sub(reqTime) < rl.window {
                validRequests = append(validRequests, reqTime)
            }
        }
        
        // 제한 확인
        if len(validRequests) >= rl.limit {
            http.Error(w, "요청 제한 초과", http.StatusTooManyRequests)
            return
        }
        
        // 현재 요청 추가
        validRequests = append(validRequests, now)
        rl.requests[ip] = validRequests
        
        next.ServeHTTP(w, r)
    })
}

// 사용 예시
func main() {
    mux := http.NewServeMux()
    mux.HandleFunc("/api/data", DataHandler)
    
    // 1분에 10개 요청으로 제한
    limiter := NewRateLimiter(10, time.Minute)
    
    http.ListenAndServe(":8080", limiter.Middleware(mux))
}

func RecoveryMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        defer func() {
            if err := recover(); err != nil {
                log.Printf("패닉 발생: %v", err)
                
                // 스택 트레이스 출력
                debug.PrintStack()
                
                // 500 에러 응답
                http.Error(w, "서버 내부 오류가 발생했습니다", 
                    http.StatusInternalServerError)
            }
        }()
        
        next.ServeHTTP(w, r)
    })
}

type LoggingConfig struct {
    IncludeHeaders bool
    IncludeBody    bool
    MaxBodySize    int
}

func LoggingMiddlewareWithConfig(config LoggingConfig) func(http.Handler) http.Handler {
    return func(next http.Handler) http.Handler {
        return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
            start := time.Now()
            
            log.Printf("요청: %s %s", r.Method, r.URL.Path)
            
            // 설정에 따라 헤더 로깅
            if config.IncludeHeaders {
                for key, values := range r.Header {
                    log.Printf("  헤더 %s: %v", key, values)
                }
            }
            
            // 설정에 따라 바디 로깅
            if config.IncludeBody && r.ContentLength > 0 {
                // 바디 읽기 로직...
            }
            
            next.ServeHTTP(w, r)
            
            log.Printf("완료: %v", time.Since(start))
        })
    }
}

// 사용 예시
func main() {
    config := LoggingConfig{
        IncludeHeaders: true,
        IncludeBody:    false,
        MaxBodySize:    1024,
    }
    
    mux := http.NewServeMux()
    mux.HandleFunc("/api/data", DataHandler)
    
    handler := LoggingMiddlewareWithConfig(config)(mux)
    http.ListenAndServe(":8080", handler)
}

func main() {
    mux := http.NewServeMux()
    mux.HandleFunc("/api/users", UsersHandler)
    
    // 권장 순서대로 체인 구성
    chain := Chain(
        RecoveryMiddleware,      // 1. 패닉 복구
        LoggingMiddleware,       // 2. 로깅
        CORSMiddleware,          // 3. CORS
        RateLimitMiddleware,     // 4. Rate Limiting
        AuthMiddleware,          // 5. 인증
        AuthorizationMiddleware, // 6. 권한
    )
    
    http.ListenAndServe(":8080", chain(mux))
}

func ConditionalMiddleware(condition func(*http.Request) bool, 
    middleware func(http.Handler) http.Handler) func(http.Handler) http.Handler {
    
    return func(next http.Handler) http.Handler {
        return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
            if condition(r) {
                // 조건이 참이면 미들웨어 적용
                middleware(next).ServeHTTP(w, r)
            } else {
                // 조건이 거짓이면 바로 다음 핸들러로
                next.ServeHTTP(w, r)
            }
        })
    }
}

// 사용 예시
func main() {
    mux := http.NewServeMux()
    mux.HandleFunc("/public", PublicHandler)
    mux.HandleFunc("/api/private", PrivateHandler)
    
    // /api/로 시작하는 경로에만 인증 적용
    authCondition := func(r *http.Request) bool {
        return strings.HasPrefix(r.URL.Path, "/api/")
    }
    
    handler := ConditionalMiddleware(authCondition, AuthMiddleware)(mux)
    http.ListenAndServe(":8080", handler)
}

type Router struct {
    mux         *http.ServeMux
    middlewares []Middleware
}

func NewRouter() *Router {
    return &Router{
        mux:         http.NewServeMux(),
        middlewares: []Middleware{},
    }
}

func (rt *Router) Use(middleware Middleware) {
    rt.middlewares = append(rt.middlewares, middleware)
}

func (rt *Router) Handle(pattern string, handler http.HandlerFunc) {
    // 현재 라우터의 미들웨어 체인 적용
    wrapped := handler
    for i := len(rt.middlewares) - 1; i >= 0; i-- {
        wrapped = rt.middlewares[i](wrapped).(http.HandlerFunc)
    }
    rt.mux.HandleFunc(pattern, wrapped)
}

func (rt *Router) Group(prefix string) *Router {
    // 새로운 서브 라우터 생성 (부모의 미들웨어 상속)
    subRouter := &Router{
        mux:         rt.mux,
        middlewares: append([]Middleware{}, rt.middlewares...),
    }
    return subRouter
}

// 사용 예시
func main() {
    router := NewRouter()
    
    // 전역 미들웨어
    router.Use(LoggingMiddleware)
    router.Use(RecoveryMiddleware)
    
    // 공개 라우트
    router.Handle("/", HomeHandler)
    router.Handle("/about", AboutHandler)
    
    // API 그룹 (인증 필요)
    apiRouter := router.Group("/api")
    apiRouter.Use(AuthMiddleware)
    apiRouter.Use(RateLimitMiddleware)
    apiRouter.Handle("/api/users", UsersHandler)
    apiRouter.Handle("/api/posts", PostsHandler)
    
    // 관리자 그룹 (인증 + 권한 필요)
    adminRouter := apiRouter.Group("/api/admin")
    adminRouter.Use(AdminAuthorizationMiddleware)
    adminRouter.Handle("/api/admin/settings", SettingsHandler)
    
    http.ListenAndServe(":8080", router.mux)
}

type ResponseWriterWrapper struct {
    http.ResponseWriter
    statusCode int
    bytesWritten int
}

func NewResponseWriterWrapper(w http.ResponseWriter) *ResponseWriterWrapper {
    return &ResponseWriterWrapper{
        ResponseWriter: w,
        statusCode:     http.StatusOK, // 기본값
    }
}

func (rw *ResponseWriterWrapper) WriteHeader(statusCode int) {
    rw.statusCode = statusCode
    rw.ResponseWriter.WriteHeader(statusCode)
}

func (rw *ResponseWriterWrapper) Write(b []byte) (int, error) {
    n, err := rw.ResponseWriter.Write(b)
    rw.bytesWritten += n
    return n, err
}

func DetailedLoggingMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        start := time.Now()
        
        // ResponseWriter 래핑
        wrapped := NewResponseWriterWrapper(w)
        
        // 다음 핸들러 실행
        next.ServeHTTP(wrapped, r)
        
        // 상세 로깅
        duration := time.Since(start)
        log.Printf("%s %s - Status: %d, Size: %d bytes, Duration: %v",
            r.Method, r.URL.Path, 
            wrapped.statusCode, 
            wrapped.bytesWritten, 
            duration)
    })
}

type RequestIDKey struct{}

func RequestIDMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        // 고유 요청 ID 생성
        requestID := generateRequestID()
        
        // 컨텍스트에 저장
        ctx := context.WithValue(r.Context(), RequestIDKey{}, requestID)
        
        // 응답 헤더에도 추가
        w.Header().Set("X-Request-ID", requestID)
        
        next.ServeHTTP(w, r.WithContext(ctx))
    })
}

func LoggingMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        // 컨텍스트에서 요청 ID 가져오기
        requestID := r.Context().Value(RequestIDKey{}).(string)
        
        log.Printf("[%s] %s %s", requestID, r.Method, r.URL.Path)
        
        next.ServeHTTP(w, r)
    })
}

func generateRequestID() string {
    return fmt.Sprintf("%d", time.Now().UnixNano())
}

package main

import (
    "github.com/gin-gonic/gin"
    "log"
    "time"
)

// 커스텀 미들웨어
func CustomLogger() gin.HandlerFunc {
    return func(c *gin.Context) {
        start := time.Now()
        
        // 요청 처리 전
        log.Printf("요청 시작: %s %s", c.Request.Method, c.Request.URL.Path)
        
        // 다음 핸들러 실행
        c.Next()
        
        // 요청 처리 후
        duration := time.Since(start)
        log.Printf("요청 완료: %d (%v)", c.Writer.Status(), duration)
    }
}

func main() {
    r := gin.Default() // 기본 미들웨어 포함 (Logger, Recovery)
    
    // 전역 미들웨어
    r.Use(CustomLogger())
    
    // 라우트별 미들웨어
    r.GET("/public", func(c *gin.Context) {
        c.JSON(200, gin.H{"message": "공개 페이지"})
    })
    
    // 그룹별 미들웨어
    authorized := r.Group("/api")
    authorized.Use(AuthMiddleware())
    {
        authorized.GET("/users", func(c *gin.Context) {
            c.JSON(200, gin.H{"message": "사용자 목록"})
        })
    }
    
    r.Run(":8080")
}

package main

import (
    "github.com/labstack/echo/v4"
    "github.com/labstack/echo/v4/middleware"
)

func main() {
    e := echo.New()
    
    // 기본 미들웨어
    e.Use(middleware.Logger())
    e.Use(middleware.Recover())
    
    // CORS 미들웨어
    e.Use(middleware.CORSWithConfig(middleware.CORSConfig{
        AllowOrigins: []string{"*"},
        AllowMethods: []string{echo.GET, echo.POST, echo.PUT, echo.DELETE},
    }))
    
    // Rate Limiting
    e.Use(middleware.RateLimiter(middleware.NewRateLimiterMemoryStore(20)))
    
    // 라우트
    e.GET("/", func(c echo.Context) error {
        return c.String(200, "Hello, World!")
    })
    
    // 그룹별 미들웨어
    api := e.Group("/api")
    api.Use(middleware.JWT([]byte("secret")))
    api.GET("/users", func(c echo.Context) error {
        return c.JSON(200, map[string]string{"message": "사용자 목록"})
    })
    
    e.Start(":8080")
}

package main

import (
    "github.com/go-chi/chi/v5"
    "github.com/go-chi/chi/v5/middleware"
    "net/http"
)

func main() {
    r := chi.NewRouter()
    
    // 기본 미들웨어
    r.Use(middleware.Logger)
    r.Use(middleware.Recoverer)
    r.Use(middleware.RequestID)
    r.Use(middleware.RealIP)
    
    // Timeout 미들웨어
    r.Use(middleware.Timeout(60 * time.Second))
    
    // 공개 라우트
    r.Get("/", func(w http.ResponseWriter, r *http.Request) {
        w.Write([]byte("홈페이지"))
    })
    
    // API 그룹
    r.Route("/api", func(r chi.Router) {
        r.Use(AuthMiddleware) // 이 그룹에만 적용
        
        r.Get("/users", func(w http.ResponseWriter, r *http.Request) {
            w.Write([]byte("사용자 목록"))
        })
        
        // 중첩 그룹
        r.Route("/admin", func(r chi.Router) {
            r.Use(AdminMiddleware) // 추가 미들웨어
            
            r.Get("/settings", func(w http.ResponseWriter, r *http.Request) {
                w.Write([]byte("관리자 설정"))
            })
        })
    })
    
    http.ListenAndServe(":8080", r)
}

package middleware

import (
    "net/http"
    "net/http/httptest"
    "testing"
)

func TestLoggingMiddleware(t *testing.T) {
    // 테스트용 핸들러
    handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        w.WriteHeader(http.StatusOK)
        w.Write([]byte("OK"))
    })
    
    // 미들웨어 적용
    middleware := LoggingMiddleware(handler)
    
    // 테스트 요청 생성
    req := httptest.NewRequest("GET", "/test", nil)
    rec := httptest.NewRecorder()
    
    // 실행
    middleware.ServeHTTP(rec, req)
    
    // 검증
    if rec.Code != http.StatusOK {
        t.Errorf("예상 상태 코드: %d, 실제: %d", http.StatusOK, rec.Code)
    }
    
    if rec.Body.String() != "OK" {
        t.Errorf("예상 응답: OK, 실제: %s", rec.Body.String())
    }
}

func TestAuthMiddleware(t *testing.T) {
    handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        w.Write([]byte("인증 성공"))
    })
    
    middleware := AuthMiddleware(handler)
    
    tests := []struct {
        name           string
        authHeader     string
        expectedStatus int
        expectedBody   string
    }{
        {
            name:           "유효한 토큰",
            authHeader:     "Bearer valid-token-123",
            expectedStatus: http.StatusOK,
            expectedBody:   "인증 성공",
        },
        {
            name:           "토큰 없음",
            authHeader:     "",
            expectedStatus: http.StatusUnauthorized,
            expectedBody:   "인증 토큰이 필요합니다\n",
        },
        {
            name:           "유효하지 않은 토큰",
            authHeader:     "Bearer invalid-token",
            expectedStatus: http.StatusUnauthorized,
            expectedBody:   "유효하지 않은 토큰입니다\n",
        },
    }
    
    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            req := httptest.NewRequest("GET", "/test", nil)
            if tt.authHeader != "" {
                req.Header.Set("Authorization", tt.authHeader)
            }
            rec := httptest.NewRecorder()
            
            middleware.ServeHTTP(rec, req)
            
            if rec.Code != tt.expectedStatus {
                t.Errorf("상태 코드: 예상 %d, 실제 %d", 
                    tt.expectedStatus, rec.Code)
            }
            
            if rec.Body.String() != tt.expectedBody {
                t.Errorf("응답 본문: 예상 %s, 실제 %s", 
                    tt.expectedBody, rec.Body.String())
            }
        })
    }
}

func TestMiddlewareChain(t *testing.T) {
    // 최종 핸들러
    handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        // 컨텍스트에서 사용자 정보 확인
        user := r.Context().Value(UserContextKey)
        if user == nil {
            t.Error("사용자 정보가 컨텍스트에 없음")
        }
        
        w.Write([]byte("성공"))
    })
    
    // 미들웨어 체인 구성
    chain := Chain(
        LoggingMiddleware,
        AuthMiddleware,
    )(handler)
    
    // 테스트 요청
    req := httptest.NewRequest("GET", "/test", nil)
    req.Header.Set("Authorization", "Bearer valid-token-123")
    rec := httptest.NewRecorder()
    
    chain.ServeHTTP(rec, req)
    
    if rec.Code != http.StatusOK {
        t.Errorf("예상 상태 코드: %d, 실제: %d", http.StatusOK, rec.Code)
    }
}

package main

import (
    "context"
    "encoding/json"
    "fmt"
    "log"
    "net/http"
    "strings"
    "time"
)

// ============ 컨텍스트 키 ============
type contextKey string

const (
    UserContextKey      contextKey = "user"
    RequestIDContextKey contextKey = "requestID"
)

// ============ 미들웨어 ============

// 요청 ID 생성 미들웨어
func RequestIDMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        requestID := fmt.Sprintf("%d", time.Now().UnixNano())
        ctx := context.WithValue(r.Context(), RequestIDContextKey, requestID)
        w.Header().Set("X-Request-ID", requestID)
        next.ServeHTTP(w, r.WithContext(ctx))
    })
}

// 로깅 미들웨어
func LoggingMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        start := time.Now()
        requestID := r.Context().Value(RequestIDContextKey).(string)
        
        wrapped := &responseWriter{ResponseWriter: w, statusCode: 200}
        
        log.Printf("[%s] 요청: %s %s", requestID, r.Method, r.URL.Path)
        
        next.ServeHTTP(wrapped, r)
        
        duration := time.Since(start)
        log.Printf("[%s] 응답: %d (%v)", requestID, wrapped.statusCode, duration)
    })
}

type responseWriter struct {
    http.ResponseWriter
    statusCode int
}

func (rw *responseWriter) WriteHeader(code int) {
    rw.statusCode = code
    rw.ResponseWriter.WriteHeader(code)
}

// 패닉 복구 미들웨어
func RecoveryMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        defer func() {
            if err := recover(); err != nil {
                requestID := r.Context().Value(RequestIDContextKey).(string)
                log.Printf("[%s] 패닉 발생: %v", requestID, err)
                
                w.Header().Set("Content-Type", "application/json")
                w.WriteHeader(http.StatusInternalServerError)
                json.NewEncoder(w).Encode(map[string]string{
                    "error": "서버 내부 오류가 발생했습니다",
                    "requestId": requestID,
                })
            }
        }()
        next.ServeHTTP(w, r)
    })
}

// CORS 미들웨어
func CORSMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        w.Header().Set("Access-Control-Allow-Origin", "*")
        w.Header().Set("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS")
        w.Header().Set("Access-Control-Allow-Headers", "Content-Type, Authorization")
        
        if r.Method == "OPTIONS" {
            w.WriteHeader(http.StatusOK)
            return
        }
        
        next.ServeHTTP(w, r)
    })
}

// 인증 미들웨어
func AuthMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        authHeader := r.Header.Get("Authorization")
        
        if authHeader == "" {
            respondError(w, "인증이 필요합니다", http.StatusUnauthorized)
            return
        }
        
        token := strings.TrimPrefix(authHeader, "Bearer ")
        
        // 실제로는 JWT 검증
        if token != "valid-token-123" {
            respondError(w, "유효하지 않은 토큰입니다", http.StatusUnauthorized)
            return
        }
        
        // 사용자 정보를 컨텍스트에 저장
        ctx := context.WithValue(r.Context(), UserContextKey, "user@example.com")
        next.ServeHTTP(w, r.WithContext(ctx))
    })
}

// JSON 응답 미들웨어
func JSONMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        w.Header().Set("Content-Type", "application/json")
        next.ServeHTTP(w, r)
    })
}

// ============ 핸들러 ============

func HomeHandler(w http.ResponseWriter, r *http.Request) {
    response := map[string]string{
        "message": "재능넷 API 서버에 오신 것을 환영합니다!",
        "version": "1.0.0",
    }
    json.NewEncoder(w).Encode(response)
}

func UsersHandler(w http.ResponseWriter, r *http.Request) {
    user := r.Context().Value(UserContextKey).(string)
    
    response := map[string]interface{}{
        "users": []map[string]string{
            {"id": "1", "name": "홍길동", "email": "hong@example.com"},
            {"id": "2", "name": "김철수", "email": "kim@example.com"},
        },
        "requestedBy": user,
    }
    json.NewEncoder(w).Encode(response)
}

func ProfileHandler(w http.ResponseWriter, r *http.Request) {
    user := r.Context().Value(UserContextKey).(string)
    
    response := map[string]string{
        "email": user,
        "name": "홍길동",
        "role": "developer",
    }
    json.NewEncoder(w).Encode(response)
}

// ============ 헬퍼 함수 ============

func respondError(w http.ResponseWriter, message string, statusCode int) {
    w.Header().Set("Content-Type", "application/json")
    w.WriteHeader(statusCode)
    json.NewEncoder(w).Encode(map[string]string{
        "error": message,
    })
}

type Middleware func(http.Handler) http.Handler

func Chain(middlewares ...Middleware) Middleware {
    return func(final http.Handler) http.Handler {
        for i := len(middlewares) - 1; i >= 0; i-- {
            final = middlewares[i](final)
        }
        return final
    }
}

// ============ 메인 함수 ============

func main() {
    mux := http.NewServeMux()
    
    // 공개 라우트
    mux.HandleFunc("/", HomeHandler)
    
    // API 라우트 (인증 필요)
    apiMux := http.NewServeMux()
    apiMux.HandleFunc("/api/users", UsersHandler)
    apiMux.HandleFunc("/api/profile", ProfileHandler)
    
    // API 미들웨어 체인
    apiChain := Chain(
        JSONMiddleware,
        AuthMiddleware,
    )
    
    mux.Handle("/api/", apiChain(apiMux))
    
    // 전역 미들웨어 체인
    globalChain := Chain(
        RecoveryMiddleware,
        RequestIDMiddleware,
        LoggingMiddleware,
        CORSMiddleware,
    )
    
    handler := globalChain(mux)
    
    log.Println("🚀 서버 시작: http://localhost:8080")
    log.Println("📝 테스트 명령어:")
    log.Println("  curl http://localhost:8080/")
    log.Println("  curl -H \"Authorization: Bearer valid-token-123\" http://localhost:8080/api/users")
    
    if err := http.ListenAndServe(":8080", handler); err != nil {
        log.Fatal(err)
    }
}