# 요청 (필요한 필드만 명시)
GET /products?fields=id,name

// 응답 (요청한 필드만 반환)
[
  { "id": 1, "name": "스마트폰" },
  { "id": 2, "name": "노트북" }
]

# "status 필드만 변경하겠다"고 명시적으로 선언
PATCH /orders/123?update_mask=status
Content-Type: application/json

{ "status": "shipped" }

// 1. ThreadLocal로 요청 컨텍스트 관리
object SparseFieldsetsContext {
    private val requestedFieldsHolder = ThreadLocal<Set<String>>()
    
    fun setRequestedFields(fields: Set<String>) { requestedFieldsHolder.set(fields) }
    fun getRequestedFields(): Set<String> = requestedFieldsHolder.get() ?: emptySet()
    fun clear() { requestedFieldsHolder.remove() }
}

// 2. Interceptor에서 파라미터 파싱
@Component
class SparseFieldsetsInterceptor : HandlerInterceptor {
    override fun preHandle(request: HttpServletRequest, response: HttpServletResponse, handler: Any): Boolean {
        request.getParameter("fields")?.let {
            val fields = it.split(",").map(String::trim).toSet()
            SparseFieldsetsContext.setRequestedFields(fields)
        }
        return true
    }

    override fun afterCompletion(request: HttpServletRequest, response: HttpServletResponse, handler: Any, ex: Exception?) {
        SparseFieldsetsContext.clear() // 메모리 누수 방지, 필수!
    }
}

// Sparse Fieldsets 대상 필드를 감싸는 Wrapper
class JsonWrapper<T>(val value: T)

@JsonInclude(JsonInclude.Include.NON_EMPTY)
data class ProductResponse(
    val id: JsonWrapper<Long>,
    val name: JsonWrapper<String>,
    // 다른 엔티티 조회가 필요한 필드는 Supplier로 감싸서 지연 로딩
    val reviews: JsonWrapper<Supplier<List<ReviewDto>>>
)

// 서비스 레이어 - DTO 생성 시점
@Service
class ProductService(
    private val productRepository: ProductRepository,
    private val reviewRepository: ReviewRepository
) {
    fun getProduct(id: Long): ProductResponse {
        val product = productRepository.findById(id) ?: throw NotFoundException()
        
        return ProductResponse(
            id = JsonWrapper(product.id),
            name = JsonWrapper(product.name),
            // 여기서 리뷰를 조회하지 않음! Supplier 안에 로직만 담아둠
            reviews = JsonWrapper(memoize { 
                reviewRepository.findByProductId(id).map { it.toDto() }
            })
        )
    }
}

// 컨트롤러 - 서비스에서 받은 DTO를 그대로 반환
@RestController
class ProductController(private val productService: ProductService) {
    @GetMapping("/products/{id}")
    @UseSparseFieldsets
    fun getProduct(@PathVariable id: Long): ProductResponse {
        return productService.getProduct(id)
    }
}

class SparseFieldsetsSerializer : JsonSerializer<JsonWrapper<*>>() {
    override fun serialize(wrapper: JsonWrapper<*>, gen: JsonGenerator, serializers: SerializerProvider) {
        val currentFieldName = gen.outputContext.currentName
        val requestedFields = SparseFieldsetsContext.getRequestedFields()

        // 요청된 필드가 아니면 빈 값을 써서 @JsonInclude(NON_EMPTY)에 의해 제외되도록 함
        if (requestedFields.isNotEmpty() && currentFieldName !in requestedFields) {
            return // 아무것도 쓰지 않으면 NON_EMPTY 설정과 함께 필드가 제외됨
        }

        val rawValue = wrapper.value
        // Supplier라면 이때 실행 (지연 로딩 효과!)
        val finalValue = if (rawValue is Supplier<*>) rawValue.get() else rawValue

        if (finalValue != null) {
            serializers.defaultSerializeValue(finalValue, gen)
        } else {
            gen.writeNull()
        }
    }

    // 빈 값일 때 필드를 제외하기 위한 설정
    override fun isEmpty(provider: SerializerProvider, value: JsonWrapper<*>): Boolean {
        val requestedFields = SparseFieldsetsContext.getRequestedFields()
        // 요청된 필드 목록이 있고, 현재 필드가 포함되지 않으면 "비어있는 것"으로 처리
        return requestedFields.isNotEmpty()
    }
}

import kotlin.reflect.KMutableProperty1
import kotlin.reflect.full.memberProperties

// 범용 Field Mask 적용 유틸리티
// source에서 target으로, fieldMask에 포함된 필드만 복사
fun <T : Any> applyFieldMask(
    target: T,
    source: Map<String, Any?>,  // Request를 Map으로 변환하여 전달
    fieldMask: Set<String>
) {
    target::class.memberProperties
        .filterIsInstance<KMutableProperty1<T, Any?>>()
        .filter { it.name in fieldMask && it.name in source }
        .forEach { prop ->
            prop.set(target, source[prop.name])
        }
}

// 컨트롤러
@PatchMapping("/orders/{id}")
fun updateOrder(
    @PathVariable id: Long,
    @RequestParam("update_mask") updateMask: String,
    @RequestBody request: OrderUpdateRequest
): OrderResponse {
    val fieldsToUpdate = updateMask.split(",").map(String::trim).toSet()
    return orderService.partialUpdate(id, request, fieldsToUpdate)
}

// 서비스
fun partialUpdate(id: Long, request: OrderUpdateRequest, fieldsToUpdate: Set<String>): OrderResponse {
    val order = orderRepository.findById(id) ?: throw NotFoundException()
    
    // fieldMask에 포함된 필드만 request에서 order로 복사
    applyFieldMask(
        target = order,
        source = request.toMap(),  // { "status": "shipped", "memo": "빠른 배송 요청" }
        fieldMask = fieldsToUpdate
    )
    
    return orderRepository.save(order).toResponse()
}

// Request DTO에 toMap() 확장 함수 추가
fun OrderUpdateRequest.toMap(): Map<String, Any?> = mapOf(
    "status" to this.status,
    "memo" to this.memo,
    // ... 다른 필드들
)

@Component
class SparseFieldsetsModule : SimpleModule() {
    override fun setupModule(context: SetupContext) {
        context.addBeanSerializerModifier(object : BeanSerializerModifier() {
            override fun changeProperties(
                config: SerializationConfig,
                beanDesc: BeanDescription,
                beanProperties: List<BeanPropertyWriter>
            ): List<BeanPropertyWriter> {
                for (writer in beanProperties) {
                    if (JsonWrapper::class.java.isAssignableFrom(writer.type.rawClass)) {
                        writer.assignSerializer(SparseFieldsetsSerializer())
                    }
                }
                return beanProperties
            }
        })
    }
}

data class ProductResponse(
    val id: JsonWrapper<Long>,
    val name: JsonWrapper<String> // 어노테이션 생략 가능!
)

@Target(AnnotationTarget.FUNCTION)
@Retention(AnnotationRetention.RUNTIME)
annotation class UseSparseFieldsets

// Interceptor에서 어노테이션 체크
override fun preHandle(request: HttpServletRequest, response: HttpServletResponse, handler: Any): Boolean {
    if (handler is HandlerMethod && handler.hasMethodAnnotation(UseSparseFieldsets::class.java)) {
        // Sparse Fieldsets 로직 수행
    }
    return true
}

// Memoization을 위한 Wrapper 클래스
class Memoized<T>(private val supplier: () -> T) : Supplier<T> {
    private val cached: T by lazy(LazyThreadSafetyMode.NONE) { supplier() }
    override fun get(): T = cached
}

// 편의 함수
fun <T> memoize(supplier: () -> T): Supplier<T> = Memoized(supplier)

// 사용 예시
val reviews = JsonWrapper(memoize { reviewRepository.findByProductId(id) })