@Configuration
class WebConfig : WebMvcConfigurer {

    override fun addResourceHandlers(registry: ResourceHandlerRegistry) {
        registry.addResourceHandler("/static/**")
            .addResourceLocations("classpath:/static/")
            .setCacheControl(CacheControl.maxAge(365, TimeUnit.DAYS).cachePublic())
    }
}

@RestController
class ProductController(
    private val productService: ProductService
) {
    @GetMapping("/api/products/{id}")
    fun getProduct(@PathVariable id: String): ResponseEntity<Product> {
        val product = productService.getProduct(id)

        return ResponseEntity.ok()
            .cacheControl(CacheControl.maxAge(5, TimeUnit.MINUTES).cachePublic())
            .eTag(product.version.toString())
            .body(product)
    }
}

@RestController
class ProductController(
    private val productService: ProductService
) {
    @GetMapping("/api/categories/{categoryId}/products")
    fun getProductsByCategory(
        @PathVariable categoryId: String
    ): ResponseEntity<List<Product>> {
        val products = productService.getByCategory(categoryId)

        return ResponseEntity.ok()
            .header("Surrogate-Key", "category-$categoryId products")
            .cacheControl(CacheControl.maxAge(1, TimeUnit.HOURS))
            .body(products)
    }
}

// 캐시 무효화
@Service
class CacheInvalidationService(
    private val webClient: WebClient
) {
    fun invalidateCategory(categoryId: String) {
        webClient.post()
            .uri("https://api.fastly.com/service/{serviceId}/purge/category-$categoryId")
            .header("Fastly-Key", fastlyApiKey)
            .retrieve()
            .toBodilessEntity()
            .block()
    }
}

// Lambda@Edge - Viewer Request
class ViewerRequestHandler : RequestHandler<CloudFrontEvent, CloudFrontResponse> {

    override fun handleRequest(event: CloudFrontEvent, context: Context): CloudFrontResponse {
        val request = event.records[0].cf.request

        // 인증 토큰 검증
        val authHeader = request.headers["authorization"]?.get(0)?.value

        if (authHeader == null || !validateToken(authHeader)) {
            return CloudFrontResponse().apply {
                status = "401"
                statusDescription = "Unauthorized"
                body = "Invalid token"
            }
        }

        // 요청 변환
        request.headers["x-user-id"] = listOf(
            Header("x-user-id", extractUserId(authHeader))
        )

        return request
    }
}

@Configuration
class RegionalRoutingConfig {

    @Bean
    fun regionalDataSource(
        @Value("\${region}") region: String
    ): DataSource {
        val config = when (region) {
            "ap-northeast-2" -> DataSourceConfig(
                primary = "jdbc:postgresql://db-ap-northeast-2.example.com:5432/mydb",
                replica = "jdbc:postgresql://db-ap-replica.example.com:5432/mydb"
            )
            "us-east-1" -> DataSourceConfig(
                primary = "jdbc:postgresql://db-us-east-1.example.com:5432/mydb",
                replica = "jdbc:postgresql://db-us-replica.example.com:5432/mydb"
            )
            else -> throw IllegalArgumentException("Unknown region: $region")
        }

        return createRoutingDataSource(config)
    }

    private fun createRoutingDataSource(config: DataSourceConfig): AbstractRoutingDataSource {
        return object : AbstractRoutingDataSource() {
            override fun determineCurrentLookupKey(): Any {
                return if (TransactionSynchronizationManager.isCurrentTransactionReadOnly()) {
                    "replica"
                } else {
                    "primary"
                }
            }
        }.apply {
            setTargetDataSources(mapOf(
                "primary" to createHikariDataSource(config.primary),
                "replica" to createHikariDataSource(config.replica)
            ))
            setDefaultTargetDataSource(createHikariDataSource(config.primary))
        }
    }
}

@Service
class RegionalService(
    private val regionalApiClients: Map<String, WebClient>
) {
    fun getDataFromNearestRegion(userId: String, userRegion: String): Data {
        val client = regionalApiClients[userRegion]
            ?: regionalApiClients["default"]!!

        return client.get()
            .uri("/api/data/{userId}", userId)
            .retrieve()
            .bodyToMono(Data::class.java)
            .block()!!
    }
}

@Configuration
class RegionalClientConfig {

    @Bean
    fun regionalApiClients(): Map<String, WebClient> {
        return mapOf(
            "ap-northeast-2" to WebClient.create("https://api-ap.example.com"),
            "us-east-1" to WebClient.create("https://api-us.example.com"),
            "eu-west-1" to WebClient.create("https://api-eu.example.com"),
            "default" to WebClient.create("https://api-us.example.com")
        )
    }
}

// Spring Boot에서 엣지 정보 수집
@RestController
class ApiController {

    @GetMapping("/api/data")
    fun getData(
        @RequestHeader("CF-Ray") cfRay: String?,
        @RequestHeader("CF-IPCountry") country: String?,
        @RequestHeader("X-Request-Region") region: String?
    ): ResponseEntity<Data> {
        // 메트릭 기록
        Metrics.counter("api.requests",
            "country", country ?: "unknown",
            "edge_region", region ?: "unknown"
        ).increment()

        // 로그
        logger.info("Request from country=$country, edge=$region, ray=$cfRay")

        return ResponseEntity.ok(data)
    }
}

// 문제 코드
@Component
class OrderCache {
    private val cache = ConcurrentHashMap<String, Order>()

    fun put(orderId: String, order: Order) {
        cache[orderId] = order  // 제거 로직 없음!
    }
}

@Component
class OrderCache {
    private val cache = Caffeine.newBuilder()
        .maximumSize(10_000)
        .expireAfterWrite(Duration.ofHours(1))
        .build<String, Order>()
}

@Service
class PaymentClient(
    private val circuitBreakerFactory: Resilience4JCircuitBreakerFactory
) {
    private val circuitBreaker = circuitBreakerFactory.create("payment")

    fun processPayment(order: Order): PaymentResult {
        return circuitBreaker.run(
            { paymentApi.charge(order) },
            { fallback -> handleFallback(order) }
        )
    }

    private fun handleFallback(order: Order): PaymentResult {
        // 결제 대기열에 추가하고 나중에 처리
        paymentQueue.add(order)
        return PaymentResult.PENDING
    }
}

dependencies {
    implementation("org.springframework.boot:spring-boot-starter-actuator")
    implementation("io.micrometer:micrometer-registry-prometheus")
}

@Service
class OrderMetrics(private val meterRegistry: MeterRegistry) {

    private val ordersCreated = Counter.builder("orders.created")
        .description("Total number of orders created")
        .tag("service", "order-service")
        .register(meterRegistry)

    private val ordersFailed = Counter.builder("orders.failed")
        .description("Total number of failed orders")
        .tag("service", "order-service")
        .register(meterRegistry)

    fun recordOrderCreated() {
        ordersCreated.increment()
    }

    fun recordOrderFailed(reason: String) {
        Counter.builder("orders.failed")
            .tag("reason", reason)
            .register(meterRegistry)
            .increment()
    }
}

@Component
class QueueMetrics(
    meterRegistry: MeterRegistry,
    private val orderQueue: OrderQueue
) {
    init {
        Gauge.builder("order.queue.size", orderQueue) { queue ->
            queue.size().toDouble()
        }
            .description("Current size of order processing queue")
            .register(meterRegistry)
    }
}

@Service
class PaymentService(private val meterRegistry: MeterRegistry) {

    private val paymentTimer = Timer.builder("payment.processing.time")
        .description("Time taken to process payments")
        .publishPercentiles(0.5, 0.95, 0.99)
        .register(meterRegistry)

    fun processPayment(order: Order): PaymentResult {
        return paymentTimer.recordCallable {
            // 결제 처리 로직
            paymentGateway.charge(order.customerId, order.totalAmount)
        }!!
    }
}

@Service
class OrderAnalytics(private val meterRegistry: MeterRegistry) {

    private val orderAmountSummary = DistributionSummary.builder("order.amount")
        .description("Distribution of order amounts")
        .baseUnit("KRW")
        .publishPercentiles(0.5, 0.75, 0.95)
        .register(meterRegistry)

    fun recordOrderAmount(amount: BigDecimal) {
        orderAmountSummary.record(amount.toDouble())
    }
}

@Component
@Order(Ordered.HIGHEST_PRECEDENCE)
class CorrelationIdFilter : OncePerRequestFilter() {

    override fun doFilterInternal(
        request: HttpServletRequest,
        response: HttpServletResponse,
        filterChain: FilterChain
    ) {
        try {
            val correlationId = request.getHeader("X-Correlation-ID")
                ?: UUID.randomUUID().toString()

            MDC.put("correlationId", correlationId)
            MDC.put("requestPath", request.requestURI)
            MDC.put("requestMethod", request.method)

            response.setHeader("X-Correlation-ID", correlationId)

            filterChain.doFilter(request, response)
        } finally {
            MDC.clear()
        }
    }
}

@Component
class TraceIdMdcFilter : OncePerRequestFilter() {

    override fun doFilterInternal(
        request: HttpServletRequest,
        response: HttpServletResponse,
        filterChain: FilterChain
    ) {
        try {
            val span = Span.current()
            if (span.spanContext.isValid) {
                MDC.put("traceId", span.spanContext.traceId)
                MDC.put("spanId", span.spanContext.spanId)
            }
            filterChain.doFilter(request, response)
        } finally {
            MDC.remove("traceId")
            MDC.remove("spanId")
        }
    }
}

// 나쁜 예
logger.info("Processing")
logger.error("Error occurred")

// 좋은 예
logger.info("Starting order processing", kv("orderId", orderId), kv("customerId", customerId))
logger.error("Payment processing failed", kv("orderId", orderId), kv("errorCode", e.errorCode), e)

import net.logstash.logback.argument.StructuredArguments.kv

@Service
class OrderService(private val logger: Logger = LoggerFactory.getLogger(OrderService::class.java)) {

    fun processOrder(order: Order) {
        logger.info("Order processing started",
            kv("orderId", order.id),
            kv("customerId", order.customerId),
            kv("itemCount", order.items.size),
            kv("totalAmount", order.totalAmount)
        )

        try {
            // 처리 로직
            logger.info("Order processing completed",
                kv("orderId", order.id),
                kv("processingTimeMs", processingTime)
            )
        } catch (e: Exception) {
            logger.error("Order processing failed",
                kv("orderId", order.id),
                kv("errorType", e.javaClass.simpleName),
                kv("errorMessage", e.message),
                e
            )
            throw e
        }
    }
}

@Component
class KafkaCorrelationInterceptor : ProducerInterceptor<String, String> {

    override fun onSend(record: ProducerRecord<String, String>): ProducerRecord<String, String> {
        MDC.get("correlationId")?.let { correlationId ->
            record.headers().add("X-Correlation-ID", correlationId.toByteArray())
        }
        MDC.get("traceId")?.let { traceId ->
            record.headers().add("X-Trace-ID", traceId.toByteArray())
        }
        return record
    }
}

@Component
class OrderEventConsumer {

    @KafkaListener(topics = ["order-events"])
    fun handleOrderEvent(
        @Payload payload: String,
        @Header("X-Correlation-ID") correlationId: String?,
        @Header("X-Trace-ID") traceId: String?
    ) {
        try {
            correlationId?.let { MDC.put("correlationId", it) }
            traceId?.let { MDC.put("traceId", it) }

            logger.info("Processing order event", kv("eventType", "OrderCreated"))
            // 이벤트 처리
        } finally {
            MDC.clear()
        }
    }
}

@RestController
@RequestMapping("/api")
class GatewayController(
    private val orderServiceClient: OrderServiceClient,
    private val tracer: Tracer
) {
    @PostMapping("/orders")
    fun createOrder(@RequestBody request: CreateOrderRequest): ResponseEntity<OrderResponse> {
        val span = tracer.spanBuilder("gateway.createOrder")
            .setSpanKind(SpanKind.SERVER)
            .setAttribute("http.method", "POST")
            .setAttribute("http.route", "/api/orders")
            .startSpan()

        return try {
            span.makeCurrent().use {
                val order = orderServiceClient.createOrder(request)
                span.setAttribute("order.id", order.id)
                ResponseEntity.created(URI.create("/api/orders/${order.id}")).body(order)
            }
        } catch (e: Exception) {
            span.recordException(e)
            span.setStatus(StatusCode.ERROR)
            throw e
        } finally {
            span.end()
        }
    }
}

@Component
class OrderServiceClient(
    private val webClient: WebClient,
    private val openTelemetry: OpenTelemetry
) {
    fun createOrder(request: CreateOrderRequest): OrderResponse {
        return webClient.post()
            .uri("/orders")
            .bodyValue(request)
            .headers { headers ->
                // Trace Context 주입
                openTelemetry.propagators.textMapPropagator.inject(
                    Context.current(),
                    headers
                ) { carrier, key, value ->
                    carrier?.set(key, value)
                }
            }
            .retrieve()
            .bodyToMono(OrderResponse::class.java)
            .block()!!
    }
}

@RestController
@RequestMapping("/orders")
class OrderController(
    private val orderService: OrderService,
    private val tracer: Tracer,
    private val openTelemetry: OpenTelemetry
) {
    @PostMapping
    fun createOrder(
        @RequestBody request: CreateOrderRequest,
        @RequestHeader headers: HttpHeaders
    ): ResponseEntity<OrderResponse> {
        // 부모 Context 추출
        val parentContext = openTelemetry.propagators.textMapPropagator.extract(
            Context.current(),
            headers
        ) { carrier, key -> carrier?.getFirst(key) }

        val span = tracer.spanBuilder("order.create")
            .setParent(parentContext)
            .setSpanKind(SpanKind.SERVER)
            .startSpan()

        return try {
            span.makeCurrent().use {
                val order = orderService.createOrder(request)
                ResponseEntity.ok(OrderResponse(order))
            }
        } finally {
            span.end()
        }
    }
}

@Service
class OrderService(
    private val orderRepository: OrderRepository,
    private val paymentClient: PaymentClient,
    private val inventoryClient: InventoryClient,
    private val tracer: Tracer
) {
    @Transactional
    fun createOrder(request: CreateOrderRequest): Order {
        // 재고 확인
        val inventorySpan = tracer.spanBuilder("order.checkInventory")
            .setSpanKind(SpanKind.CLIENT)
            .startSpan()

        try {
            inventorySpan.makeCurrent().use {
                inventoryClient.checkAndReserve(request.items)
            }
        } finally {
            inventorySpan.end()
        }

        // 주문 저장
        val saveSpan = tracer.spanBuilder("order.save")
            .setAttribute("db.system", "postgresql")
            .startSpan()

        val order = try {
            saveSpan.makeCurrent().use {
                orderRepository.save(Order.create(request))
            }
        } finally {
            saveSpan.end()
        }

        // 결제 처리
        val paymentSpan = tracer.spanBuilder("order.processPayment")
            .setSpanKind(SpanKind.CLIENT)
            .startSpan()

        try {
            paymentSpan.makeCurrent().use {
                paymentClient.charge(order.customerId, order.totalAmount)
            }
        } finally {
            paymentSpan.end()
        }

        return order
    }
}

@Service
class BatchOrderProcessor(
    private val tracer: Tracer
) {
    fun processBatch(orders: List<Order>) {
        val batchSpan = tracer.spanBuilder("batch.process")
            .startSpan()

        try {
            batchSpan.makeCurrent().use {
                orders.parallelStream().forEach { order ->
                    val orderSpan = tracer.spanBuilder("batch.processOrder")
                        .addLink(batchSpan.spanContext)  // 링크로 연결
                        .setAttribute("order.id", order.id)
                        .startSpan()

                    try {
                        orderSpan.makeCurrent().use {
                            processOrder(order)
                        }
                    } finally {
                        orderSpan.end()
                    }
                }
            }
        } finally {
            batchSpan.end()
        }
    }
}

@Configuration
class SamplingConfig {

    @Bean
    fun sdkTracerProvider(): SdkTracerProvider {
        return SdkTracerProvider.builder()
            .setSampler(
                Sampler.parentBased(
                    Sampler.traceIdRatioBased(0.1)  // 10% 샘플링
                )
            )
            .build()
    }
}

// HTTP 관련
span.setAttribute(SemanticAttributes.HTTP_METHOD, "POST")
span.setAttribute(SemanticAttributes.HTTP_URL, "/api/orders")
span.setAttribute(SemanticAttributes.HTTP_STATUS_CODE, 200)

// Database 관련
span.setAttribute(SemanticAttributes.DB_SYSTEM, "postgresql")
span.setAttribute(SemanticAttributes.DB_OPERATION, "SELECT")
span.setAttribute(SemanticAttributes.DB_STATEMENT, "SELECT * FROM orders WHERE id = ?")

// Messaging 관련
span.setAttribute(SemanticAttributes.MESSAGING_SYSTEM, "kafka")
span.setAttribute(SemanticAttributes.MESSAGING_DESTINATION, "order-events")
span.setAttribute(SemanticAttributes.MESSAGING_OPERATION, "publish")

// 비즈니스 컨텍스트
span.setAttribute("order.id", orderId)
span.setAttribute("customer.tier", "premium")
span.setAttribute("order.item_count", items.size.toLong())
span.setAttribute("order.total_amount", totalAmount.toDouble())

try {
    processOrder(order)
} catch (e: PaymentException) {
    span.setStatus(StatusCode.ERROR, "Payment processing failed")
    span.recordException(e, Attributes.builder()
        .put("exception.escaped", false)
        .put("payment.error_code", e.errorCode)
        .build()
    )
    throw e
}