@Target(AnnotationTarget.PROPERTY)
annotation class JsonExclude

data class Person(
        @JsonName(name = "first_name") val firstName: String,
        @JsonExclude val age: Int? = null
)

private fun StringBuilder.serializeObject(obj: Any) {
    obj.javaClass.kotlin.memberProperties
            .filter { it.findAnnotation<JsonExclude>() == null }
            .joinToStringBuilder(this, prefix = "{", postfix = "}") {
                serializeProperty(it, obj)
            }
}

package kotlin.reflect

public interface KAnnotatedElement {
    public val annotations: List<Annotation>
}

// 인자로 전달받은 타입에 해당하는 애너테이션이 있으면 그 애너테이션 반환
inline fun <reified T> KAnnotatedElement.findAnnotation(): T?
        = annotations.filterIsInstance<T>().firstOrNull()

@Target(AnnotationTarget.PROPERTY)
annotation class JsonName(val name: String)

data class Person(
        @JsonName(name = "first_name") val firstName: String,
        @JsonExclude val age: Int? = null
)

private fun StringBuilder.serializeObject(obj: Any) {
    obj.javaClass.kotlin.memberProperties
            .filter { it.findAnnotation<JsonExclude>() == null }
            .joinToStringBuilder(this, prefix = "{", postfix = "}") {
                serializeProperty(it, obj)
            }
}

private fun StringBuilder.serializeProperty(
  prop: KProperty1<Any, *>, obj: Any
) {
  // @JsonName 애너테이션이 있으면 그 인스턴스를 얻음
  val jsonNameAnn = prop.findAnnotation<JsonName>()
  
  // 애너테이션에서 name 인자를 찾고, 그런 인자가 없으면 prop.name 을 사용
  val propName = jsonNameAnn?.name ?: prop.name
  serializeString(propName)
  append(": ")

  val value = prop.get(obj)
  val jsonValue = prop.getSerializer()?.toJsonValue(value) ?: value
  serializePropertyValue(jsonValue)
}

inline fun <reified T> KAnnotatedElement.findAnnotation(): T?
        = annotations.filterIsInstance<T>().firstOrNull()

@Target(AnnotationTarget.PROPERTY)
annotation class CustomSerializer(val serializerClass: KClass<out ValueSerializer<*>>)

object DateSerializer : ValueSerializer<Date> {
  private val dateFormat = SimpleDateFormat("dd-mm-yyyy")

  override fun toJsonValue(value: Date): Any? =
    dateFormat.format(value)

  override fun fromJsonValue(jsonValue: Any?): Date =
    dateFormat.parse(jsonValue as String)
}

data class Person(
  val name: String,
  @CustomSerializer(DateSerializer::class) val birthDate: Date
)

// 프로퍼티의 값을 직렬화하는 직렬화기 가져오기
fun KProperty<*>.getSerializer(): ValueSerializer<Any?>? {
    // @CustomSerializer 애너테이션이 있는지 찾음
    val customSerializerAnn: CustomSerializer = findAnnotation<CustomSerializer>() ?: return null
  
    // @CustomSerializer 애너테이션이 있다면 그 애너테이션의 serializerClass 가 직렬화기 인스턴스를 얻기 위해 사용해야 할 클래스임
    val serializerClass: KClass<out ValueSerializer<*>> = customSerializerAnn.serializerClass

    // 직렬화할 클래스가 object 로 선언하여 싱글턴인 경우 objectInstance 를 통해 싱글턴 인스턴스를 얻어서 모든 객체를 직렬화하면 되므로 
    // createInstance() 를 호출할 필요가 없음
    val valueSerializer: ValueSerializer<*> = serializerClass.objectInstance
            ?: serializerClass.createInstance()
    
  return valueSerializer as ValueSerializer<Any?>
}

interface ValueSerializer<T> {
  fun toJsonValue(value: T): Any?
  fun fromJsonValue(jsonValue: Any?): T
}

// getSerializer() 를 통해 커스텀 직렬화기를 얻은 후 커스텀 직렬화기의 _toJsonValue()_ 를 호출하여 프로퍼티값을 JSON 형식으로 직렬화함
// 만일 프로퍼티에 커스텀 직렬화기가 지정되어 있지 않다면 프로퍼티값을 그대로 사용함
private fun StringBuilder.serializeProperty(
        prop: KProperty1<Any, *>, obj: Any
) {
    val jsonNameAnn = prop.findAnnotation<JsonName>()
    val propName = jsonNameAnn?.name ?: prop.name
    serializeString(propName)
    append(": ")

    val value = prop.get(obj)
  
    // 프로퍼티에 대해 정의된 커스텀 직렬화기가 있으면 그 커스텀 직렬화기를 사용하고,  
    // 커스텀 직렬화기가 없으면 일반적인 방법으로 프로퍼티 직렬화함
    val jsonValue = prop.getSerializer()?.toJsonValue(value) ?: value
    serializePropertyValue(jsonValue)
}

inline fun <reified T: Any> deserialize(json: Reader): T {
    return deserialize(json, T::class)
}

package com.assu.study.kotlin2me.chap10.jkid.examples.deserialization

import ru.yole.jkid.deserialization.deserialize

data class Author(
  val name: String,
)

data class Book(
  val title: String,
  val author: Author,
)

fun main() {
  val json = """{"title": "TEST1", "author": {"name": "Assu"}}"""

  // 역직렬화할 객체의 타입을 실체화한 타입 파라메터로 deserialize() 에 넘겨서 새로운 객체 인스턴스를 얻음
  val book: Book = deserialize<Book>(json)

  // Book(title=TEST1, author=Author(name=Assu))
  println(book)
}

package ru.yole.jkid.deserialization

// ...

// JSON Parser 콜백 인터페이스
interface JsonObject {
    fun setSimpleProperty(propertyName: String, value: Any?)

    fun createObject(propertyName: String): JsonObject

    fun createArray(propertyName: String): JsonObject
}

class ObjectSeed<out T : Any>(
    targetClass: KClass<T>,
    override val classInfoCache: ClassInfoCache,
) : Seed {
    private val classInfo: ClassInfo<T> = classInfoCache[targetClass]

    private val valueArguments = mutableMapOf<KParameter, Any?>()
    private val seedArguments = mutableMapOf<KParameter, Seed>()

    private val arguments: Map<KParameter, Any?>
        get() = valueArguments + seedArguments.mapValues { it.value.spawn() }

    override fun setSimpleProperty(
        propertyName: String,
        value: Any?,
    ) {
        val param = classInfo.getConstructorParameter(propertyName)
        valueArguments[param] = classInfo.deserializeConstructorArgument(param, value)
    }

    override fun createCompositeProperty(
        propertyName: String,
        isList: Boolean,
    ): Seed {
        val param = classInfo.getConstructorParameter(propertyName)
        val deserializeAs = classInfo.getDeserializeClass(propertyName)
        val seed =
            createSeedForType(
                deserializeAs ?: param.type.javaType,
                isList,
            )
        return seed.apply { seedArguments[param] = this }
    }

    // 생성된 객체 반환
    override fun spawn(): T = classInfo.createInstance(arguments)
}

class ObjectListSeed(
    val elementType: Type,
    override val classInfoCache: ClassInfoCache,
) : Seed {
    private val elements = mutableListOf<Seed>()

    override fun setSimpleProperty(
        propertyName: String,
        value: Any?,
    ): Unit = throw JKidException("Found primitive value in collection of object types")

    override fun createCompositeProperty(
        propertyName: String,
        isList: Boolean,
    ) = createSeedForType(elementType, isList).apply { elements.add(this) }

    // 생성된 리스트 반환
    override fun spawn(): List<*> = elements.map { it.spawn() }
}

class ValueListSeed(
    elementType: Type,
    override val classInfoCache: ClassInfoCache,
) : Seed {
    private val elements = mutableListOf<Any?>()
    private val serializerForType = serializerForBasicType(elementType)

    override fun setSimpleProperty(
        propertyName: String,
        value: Any?,
    ) {
        elements.add(serializerForType.fromJsonValue(value))
    }

    override fun createCompositeProperty(
        propertyName: String,
        isList: Boolean,
    ): Seed = throw JKidException("Found object value in collection of primitive types")

    // 생성된 리스트 반환
    override fun spawn() = elements
}

interface JsonObject {
    fun setSimpleProperty(
        propertyName: String,
        value: Any?,
    )

    fun createObject(propertyName: String): JsonObject

    fun createArray(propertyName: String): JsonObject
}

interface Seed : JsonObject {
    val classInfoCache: ClassInfoCache

    // 객체 생성 과정이 끝난 후 결과 인스턴스를 얻음
    fun spawn(): Any?

    fun createCompositeProperty(
        propertyName: String,
        isList: Boolean,
    ): JsonObject

    override fun createObject(propertyName: String) = createCompositeProperty(propertyName, false)

    override fun createArray(propertyName: String) = createCompositeProperty(propertyName, true)
}

fun <T : Any> deserialize(
    json: Reader,
    targetClass: KClass<T>,
): T {
    // 파싱을 시작하기 위해 직렬화할 객체의 프로퍼티를 담을 ObjectSeed 하나 생성
    val seed = ObjectSeed(targetClass, ClassInfoCache())
    
    // 파서를 호출하면서 입력 스트림 reader 인 json 과 seed 를 인자로 전달
    Parser(json, seed).parse()
    
    // 결과 객체 생성
    return seed.spawn()
}

// 지금 만들고 있는 객체의 상태 저장
class ObjectSeed<out T : Any>(
  targetClass: KClass<T>, // 결과 클래스의 참조
  // 결과 클래스 안의 프로퍼티에 대한 정보를 저장하는 캐시
  // 나중에 이 캐시 정보를 사용해서 클래스의 인스턴스 생성
  override val classInfoCache: ClassInfoCache,
) : Seed {
  // targetClass 의 인스턴스를 만들 때 필요한 정보 캐싱
  private val classInfo: ClassInfo<T> = classInfoCache[targetClass]

  // 생성자 파라메터와 값을 연결해주는 맵 생성
  // 이를 위해 아래의 변경 가능한 맵 사용

  // 간단한 값 프로퍼티 저장
  private val valueArguments = mutableMapOf<KParameter, Any?>()

  // 복합 프로퍼티 저장
  private val seedArguments = mutableMapOf<KParameter, Seed>()

  // 생성자 파라메터와 그 값을 연결하는 맵 생성
  private val arguments: Map<KParameter, Any?>
    get() = valueArguments + seedArguments.mapValues { it.value.spawn() }

  // 결과를 만들여서 valueArguments 맵에 새 인자 추가
  override fun setSimpleProperty(
    propertyName: String,
    value: Any?,
  ) {
    val param = classInfo.getConstructorParameter(propertyName)

    // 생성자 파라메터 값이 간단한 경우 그 값을 기록
    valueArguments[param] = classInfo.deserializeConstructorArgument(param, value)
  }

  // seedArguments 맵에 새 인자 추가
  override fun createCompositeProperty(
    propertyName: String,
    isList: Boolean,
  ): Seed {
    val param = classInfo.getConstructorParameter(propertyName)

    // 프로퍼티에 대한 DeserializeInterface 애너테이션이 있다면 그 값을 가져옴
    val deserializeAs = classInfo.getDeserializeClass(propertyName)

    // 파라메터 타입에 따라 ObjectSeed, CollectionSeed 생성 (1)
    val seed =
      createSeedForType(  // 파타메터의 타입을 분석하여 적절히 ObjectSeed, ObjectListSeed, ValueListSeed 중 하나 새엇ㅇ
        deserializeAs ?: param.type.javaType,
        isList,
      )

    // (1) 에서 만든 Seed 객체를 seedArguments 맵에 기록
    return seed.apply { seedArguments[param] = this }
  }

  // 인자 맵을 넘겨서 targetClass 타입의 인스턴스 생성
  // 내부에 중첩된 모든 Seed 의 spawn() 을 재귀적으로 호출하여 내부 객체 계층 구조 생성
  // 재귀적으로 복합 (Seed) 인자 만드는 과정: arguments 의 커스텀 getter 안에서 mapValues() 를 사용하여 seedArguments 각 원소에 대해 spawn() 호출
  override fun spawn(): T = classInfo.createInstance(arguments)
}

// 파타메터의 타입을 분석하여 적절히 ObjectSeed, ObjectListSeed, ValueListSeed 중 하나 생성
fun Seed.createSeedForType(
    paramType: Type,
    isList: Boolean,
): Seed {
    val paramClass = paramType.asJavaClass()

    if (List::class.java.isAssignableFrom(paramClass)) {
        if (!isList) throw JKidException("An array expected, not a composite object")
        val parameterizedType =
            paramType as? ParameterizedType
                ?: throw UnsupportedOperationException("Unsupported parameter type $this")

        val elementType = parameterizedType.actualTypeArguments.single()
        if (elementType.isPrimitiveOrString()) {
            return ValueListSeed(elementType, classInfoCache)
        }
        return ObjectListSeed(elementType, classInfoCache)
    }
    if (isList) throw JKidException("Object of the type ${paramType.typeName} expected, not an array")
    return ObjectSeed(paramClass.kotlin, classInfoCache)
}

package kotlin.reflect

public actual interface KCallable<out R> : KAnnotatedElement {

    // ...
    
    public fun call(vararg args: Any?): R
    public fun callBy(args: Map<KParameter, Any?>): R
}

fun serializerForType(type: Type): ValueSerializer<out Any?>? =
        when (type) {
            Byte::class.java, Byte::class.javaObjectType -> ByteSerializer
            Short::class.java, Short::class.javaObjectType -> ShortSerializer
            Int::class.java, Int::class.javaObjectType -> IntSerializer
            Long::class.java, Long::class.javaObjectType -> LongSerializer
            Float::class.java, Float::class.javaObjectType -> FloatSerializer
            Double::class.java, Double::class.javaObjectType -> DoubleSerializer
            Boolean::class.java, Boolean::class.javaObjectType -> BooleanSerializer
            String::class.java -> StringSerializer
            else -> null
        }

object IntSerializer : ValueSerializer<Int> {
  override fun fromJsonValue(jsonValue: Any?) = jsonValue.expectNumber().toInt()
  override fun toJsonValue(value: Int) = value
}


object BooleanSerializer : ValueSerializer<Boolean> {
    override fun fromJsonValue(jsonValue: Any?): Boolean {
        if (jsonValue !is Boolean) throw JKidException("Expected boolean, was: $jsonValue")
        return jsonValue
    }

    override fun toJsonValue(value: Boolean) = value
}

class ClassInfo<T : Any>(
  cls: KClass<T>,
) {
    // ...
    private val constructor =
      cls.primaryConstructor
        ?: throw JKidException("Class ${cls.qualifiedName} doesn't have a primary constructor")
  
    fun createInstance(arguments: Map<KParameter, Any?>): T {
        ensureAllParametersPresent(arguments)
        return constructor.callBy(arguments)
    }
}

class ClassInfoCache {
  private val cacheData = mutableMapOf<KClass<*>, ClassInfo<*>>()

  @Suppress("UNCHECKED_CAST")
  operator fun <T : Any> get(cls: KClass<T>): ClassInfo<T> =
  // cls 에 대한 항목이 cacheData 맵에 있으면 그 항목을 반환
    // 그런 항목이 없다면 전달받은 람다를 호출하여 key 에 대한 값을 계산한 후 그 결과값을 맵에 저장한 다음 반환함
    cacheData.getOrPut(cls) { ClassInfo(cls) } as ClassInfo<T>
}

class ClassInfo<T : Any>(
  cls: KClass<T>,
) {
  private val className = cls.qualifiedName
  private val constructor: KFunction<T> =
    cls.primaryConstructor
      ?: throw JKidException("Class ${cls.qualifiedName} doesn't have a primary constructor")

  // JSON 파일의 각 key 에 해당하는 파라메터 저장
  private val jsonNameToParamMap = hashMapOf<String, KParameter>()

  // 각 파라메터에 대한 직렬화기 저장
  private val paramToSerializerMap = hashMapOf<KParameter, ValueSerializer<out Any?>>()

  // @DeserializeInterface 애너테이션 인자로 지정한 클래스 저장
  private val jsonNameToDeserializeClassMap = hashMapOf<String, Class<out Any>?>()

  // 초기화 시 각 생성자 파라메터에 해당하는 프로퍼티를 찾아서 애너테이션을 가져옴
  init {
    constructor.parameters.forEach { cacheDataForParameter(cls, it) }
  }

  private fun cacheDataForParameter(
    cls: KClass<*>,
    param: KParameter,
  ) {
    val paramName =
      param.name
        ?: throw JKidException("Class $className has constructor parameter without name")

    val property = cls.declaredMemberProperties.find { it.name == paramName } ?: return
    val name = property.findAnnotation<JsonName>()?.name ?: paramName
    jsonNameToParamMap[name] = param

    val deserializeClass = property.findAnnotation<DeserializeInterface>()?.targetClass?.java
    jsonNameToDeserializeClassMap[name] = deserializeClass

    val valueSerializer =
      property.getSerializer()
        ?: serializerForType(param.type.javaType)
        ?: return
    paramToSerializerMap[param] = valueSerializer
  }

  fun getConstructorParameter(propertyName: String): KParameter =
    jsonNameToParamMap[propertyName]
      ?: throw JKidException("Constructor parameter $propertyName is not found for class $className")

  fun getDeserializeClass(propertyName: String) = jsonNameToDeserializeClassMap[propertyName]

  fun deserializeConstructorArgument(
    param: KParameter,
    value: Any?,
  ): Any? {
    val serializer = paramToSerializerMap[param]
    if (serializer != null) return serializer.fromJsonValue(value)

    validateArgumentType(param, value)
    return value
  }

  private fun validateArgumentType(
    param: KParameter,
    value: Any?,
  ) {
    if (value == null && !param.type.isMarkedNullable) {
      throw JKidException("Received null value for non-null parameter ${param.name}")
    }
    if (value != null && value.javaClass != param.type.javaType) {
      throw JKidException(
        "Type mismatch for parameter ${param.name}: " +
                "expected ${param.type.javaType}, found ${value.javaClass}",
      )
    }
  }

  fun createInstance(arguments: Map<KParameter, Any?>): T {
    ensureAllParametersPresent(arguments)
    return constructor.callBy(arguments)
  }

  // 생성자에 필요한 필수 파라메터가 맵에 모두 있는지 검증
  // 리플렉션 캐시를 사용하면 이 함수에서 수행하는 과정(역직렬화를 제어하는 애너테이션을 찾는 과정) 을 JSON 데이터에서 발견한
  // 모든 프로퍼티에 대해 반복할 필요없이 프로퍼티 이름별로 단 한번만 수행 가능
  private fun ensureAllParametersPresent(arguments: Map<KParameter, Any?>) {
    for (param in constructor.parameters) {
      // 파라메터에 디폴트 값이 있으면 param.isOptional 이 true 이므로 그런 파라메터에 대한 인자가 인자 맵에 없어도 문제없음
      // 파라메터가 null 이 될 수 있는 값이라면 type.isMarkedNullable 이 true 이므로 디폴트 파라메터 값으로 null 을 사용함
      // 이 두 가지 경우가 모두 아니라면 예외 발생
      if (arguments[param] == null && !param.isOptional && !param.type.isMarkedNullable) {
        throw JKidException("Missing value for parameter ${param.name}")
      }
    }
  }
}