package com.assu.study.kotlin2me.chap10.reflection

import kotlin.reflect.KClass
import kotlin.reflect.full.memberProperties // memberProperties 확장 함수 임포트

class Person(
    val name: String,
    val age: Int,
)

fun main() {
    val person = Person("Assu", 20)
    val clazz: Class<Person> = person.javaClass
    val kClazz: KClass<Person> = person.javaClass.kotlin

    // Person
    println(clazz.simpleName)

    // Person
    println(kClazz.simpleName)

    // memberProperties 를 통해 클래스와 모든 조상 클래스 내부에 정의된 비확장 프로퍼티를 가져옴
    // age
    // name
    kClazz.memberProperties.forEach { println(it.name) }
}

package kotlin.reflect

public actual interface KClass<T : Any> : KDeclarationContainer, KAnnotatedElement, KClassifier {
    public actual val simpleName: String?
    public actual val qualifiedName: String?
    override val members: Collection<KCallable<*>>
    public val constructors: Collection<KFunction<T>>
    public val nestedClasses: Collection<KClass<*>>
    
    // ...
}

package kotlin.reflect

public actual interface KCallable<out R> : KAnnotatedElement {
  public fun call(vararg args: Any?): R
  
  // ...
}

package com.assu.study.kotlin2me.chap10.reflection

fun foo(x: Int): Unit = println(x)

fun foo2(
  x: Int,
  y: Int,
): Unit = println(x + y)

fun main() {
  // KFunction1<Int, Unit> 타입 리턴
  val kFunctionFoo1 = ::foo
  
  // 2
  kFunctionFoo1.call(2)

  // 런타임 오류
  // Callable expects 1 arguments, but 2 were provided.
}

package com.assu.study.kotlin2me.chap10.reflection

fun foo3(
  x: Int,
  y: Int,
  z: Int,
): Unit = println(x + y + z)

fun main() {
  // KFunction3<Int, Int, Int, Unit> 타입 리턴
  val kFunctionFoo2 = ::foo3

  // 런타임 오류
  // Callable expects 3 arguments, but 1 were provided.

  // kFunctionFoo2.call(1)

  // 3
  kFunctionFoo2.call(1, 2, 3)
}

package com.assu.study.kotlin2me.chap10.reflection

fun sum(
    x: Int,
    y: Int,
) = x + y

fun main() {
    // KFunction<Int, Int, Int> 타입 리턴
    val kFunction = ::sum

    // 10
    println(kFunction.invoke(1, 2) + kFunction(3, 4))

    // 컴파일 오류
    // No value passed for parameter 'y'

    // kFunction(1)
}

package com.assu.study.kotlin2me.chap10.reflection

import kotlin.reflect.KMutableProperty0

var counter = 0

fun main() {
    val kProperty: KMutableProperty0<Int> = ::counter

    // 리플렉션 기능을 통해 setter 를 호출하면서 21 을 인자로 넘김
    kProperty.setter.call(21)

    // 21
    // get() 을 호출하여 프로퍼티값을 가져옴
    println(kProperty.get())
}

package com.assu.study.kotlin2me.chap10.reflection

import kotlin.reflect.KProperty1

class People(
    val name: String,
    val age: Int,
)

fun main() {
    val people = People("Assu", 20)

    // memberProperty 변수에 프로퍼티 참조 저장
    val memberProperty: KProperty1<People, Int> = People::age

    // people 인스턴스의 프로퍼티값 가져옴
    // 20
    println(memberProperty.get(people))
}

@file:Suppress("IMPLEMENTING_FUNCTION_INTERFACE")
package kotlin.reflect

public actual interface KProperty<out V> : KCallable<V> {
  @SinceKotlin("1.1")
  public val isLateinit: Boolean
 
  @SinceKotlin("1.1")
  public val isConst: Boolean

  public val getter: Getter<V>
  
  public interface Accessor<out V> {
    public val property: KProperty<V>
  }

  public interface Getter<out V> : Accessor<V>, KFunction<V>
}

public actual interface KMutableProperty<V> : KProperty<V> {
  public val setter: Setter<V>

  public interface Setter<V> : KProperty.Accessor<V>, KFunction<Unit>
}


public actual interface KProperty0<out V> : KProperty<V>, () -> V {
  public actual fun get(): V

  @SinceKotlin("1.1")
  public fun getDelegate(): Any?

  override val getter: Getter<V>

  public interface Getter<out V> : KProperty.Getter<V>, () -> V
}

public actual interface KMutableProperty0<V> : KProperty0<V>, KMutableProperty<V> {
  public actual fun set(value: V)

  override val setter: Setter<V>

  public interface Setter<V> : KMutableProperty.Setter<V>, (V) -> Unit
}


public actual interface KProperty1<T, out V> : KProperty<V>, (T) -> V {
  public actual fun get(receiver: T): V

  @SinceKotlin("1.1")
  public fun getDelegate(receiver: T): Any?

  override val getter: Getter<T, V>

  public interface Getter<T, out V> : KProperty.Getter<V>, (T) -> V
}

public actual interface KMutableProperty1<T, V> : KProperty1<T, V>, KMutableProperty<V> {
  public actual fun set(receiver: T, value: V)

  override val setter: Setter<T, V>

  public interface Setter<T, V> : KMutableProperty.Setter<V>, (T, V) -> Unit
}


public actual interface KProperty2<D, E, out V> : KProperty<V>, (D, E) -> V {
  public actual fun get(receiver1: D, receiver2: E): V

  @SinceKotlin("1.1")
  public fun getDelegate(receiver1: D, receiver2: E): Any?

  override val getter: Getter<D, E, V>

  public interface Getter<D, E, out V> : KProperty.Getter<V>, (D, E) -> V
}

public actual interface KMutableProperty2<D, E, V> : KProperty2<D, E, V>, KMutableProperty<V> {
  public actual fun set(receiver1: D, receiver2: E, value: V)

  override val setter: Setter<D, E, V>

  public interface Setter<D, E, V> : KMutableProperty.Setter<V>, (D, E, V) -> Unit
}

package com.assu.study.kotlin2me.chap10.reflection

fun main() {
    val x: Int = 1

    // 최상위 수준이나 클래스 안에 정의된 멤버 프로퍼티만 리플렉션으로 접근 가능
    // 컴파일 오류
    // References to variables and parameters are unsupported
    // (변수와 파라메터에 대한 참조는 지원하지 않음)
  
    // val memberProperty = ::x
}

fun serialize(obj: Any): String = buildString { serializeObject(obj) }

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

fun serialize(obj: Any): String = buildString { serializeObject(obj) }

// 결과 JSON 은 { prop1: value1, prop2: value2 } 와 같은 형태임
private fun StringBuilder.serializeObject(obj: Any) {
    // obj.javaClass.kotlin 은 객체의 KClass 를 얻음
    // kClass.memberProperties 는 클래스의 모든 프로퍼티를 얻음 (Collection<KProperty1<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
) {
  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) //  프로퍼티의 값을 얻음
}

// 어떤 값이 primitive 타입, 문자열, 컬렉션, 중첩된 객체 중 어떤 것인지 판단하여 그에 따라 적절히 그 값을 직렬화
private fun StringBuilder.serializePropertyValue(value: Any?) {
  when (value) {
    null -> append("null")
    is String -> serializeString(value)
    is Number, is Boolean -> append(value.toString())
    is List<*> -> serializeList(value)
    else -> serializeObject(value)
  }
}

// JSON 명세에 따라 특수 문자를 이스케이프해줌
private fun StringBuilder.serializeString(s: String) {
  append('\"')
  s.forEach { append(it.escape()) }
  append('\"')
}