data class User(
    val name: String,
    val surname: String
)

val user = User("Jungwoon", "Park")
val chanedUser = user.copy(surname = "Lee")
print(chanedUser) // User(name=Jungwoon, surname=Lee)

private val _someData = mutableLiveData<Any>()
val someData: LiveData<Any>
    get() = _someData

// Bad case
var user: User
for (i in users.indices) {
    user = users[i]
    print("User at $i is $user")
}

// Better Case
for (i in users.indices) {
    val user = users[i]
    print("User at $i is $user")
}

// Best Case
for ((i, user) in users.withIndex()) {
    print("User at $i is $user")
}

fun factorial(n: Int): Long {
    require(n >= 0) // n이 0보다 크게끔 제한할 수 있습니다.
    return if (n <= 1) 1 else factorial (n - 1) * n
}

fun getUserInfo(token: Token): UserInfo {
    checkNotNull(token)
    // ...
}

@Test
fun `Stack pops correct number of elements`() {
    val stack = Stack(20) { it }
    val ret = stack.pop(10)
    assertEquals(10, ret.size)
}

fun getEmail(member: Member): String {
    return member?.mail ?: "unknown"
}

sealed class Result<out T>
class Success<out T>(val result: T): Result<T>()
class Failure<out T>(val throwable: Throwable): Result<Nothing>()

fun getSign() {
    if (iscorrectSign) {
        return null
    }
    // ...
}

fun getJsonest() {
    if (incorrectJSon) {
        return Failure(JsonParsingException())
    }
    // ...
}

printer?.print() // 안전 호출

if (printer != null) printer.print() // 스마트 캐스팅

val printerName1 = printer?.name ?: "Unnamed"
val printerName2 = printer?.name ?: return
val printerName3 = printer?.name ?: throw Error("Error Messages")

// use를 사용하지 않은 방법
fun countCharactersInFile(path: String): Int {
    val reader = BufferedReader(FileReader(path))
    try {
        return reader.lineSequence().sumBy { it.length }
    } {
        finally {
            reader.close()
        }
    }
}

// use를 사용하지한 방법
fun countCharactersInFile(path: String): Int {
    val reader = BufferedReader(FileReader(path))
    reader.user {
        return reader.lineSequence().sumBy { it.length }
    }
}

// 구현 A
if (person != null && person.isAdult) {
    view.showPerson(person)
} else {
    view.showError()
}

// 구현 B
person?.takeIf { it.isAdult }
    ?.let(view::showPerson)
    ?: view.showError()

fun test(): Unit {
    print("test")
    return Unit // 생략 가능
}

fun test2(): Unit? {
    print("test2")

    // Unit이나 null이나 반드시 return을 해주어야 합니다.
    return Unit
    return null
}

// 만약 사용한다면 다음과 같이 사용할 수 있습니다.

fun test3() {
    // test2()의 리턴값이 null 이면 early return
    test2() ?: return
}

class Node(val name: String) {

    fun makeChild(childName: String) {
        create("$name.$childName").apply {
            print("Created ${this?.name} in ${this@Node.name}") // 여기서 this와 this@Node로 명시
        }
    }

    fun create(name: String): Node? = Node(name)

}

fun main() {
    val node = Node("parent")
    node.makeChild("child") // Created parent.child in parent
}

var name: String? = null
    get() = field?.toUpperCase()
    set(value) {
        if (!value.isNullOrBlank()) {
            field = value
        }
    }

// val 일때는 field가 만들어지지 않습니다.
val fullName: String
    get() = "$name $surname"

// 이렇게 하지 마세요! 이러한 처리는 프로퍼티가 아니라 함수로 구현해야 합니다.
val Tree<Int>.sum: Int
    get() = when (this) {
        is Leaf -> value
        is Node -> left.sum + right.sum
    }

fun sendMail(
    to = "byjungwoon@gmail.com",
    message = "Hello World"
)

// 코틀린에서 많이 사용하는 프로퍼티 위임
val value by lazy { getValue() }
var items: List<Item> by
  Delegates.observable(listOf()) { _, _, _ ->
    notifyDataSetChanged()
}

// 안드로이드에서 뷰와 리소스 바인딩
private val button: Button by bindView(R.id.button)
private val textSize: Button by bindDimention(R.dimen.font_size)

// Koin에서 종속성 주입
private val viewModel: MainViewModel by inject()

// 데이터 바인딩
private val port by bindConfiguration("port")

var token String? by LoggingProperty(null)

private class LoggingProperty<T>(var value: T) {
  
  operator fun getValue(
    thisRef: Any?,
    prop: KProperty<*>
  ): T {
    print("${prop.name} returned value $value")
    return value
  }
  
  operator fun setValue(
    thisRef: Any?,
    prop: KProperty<*>,
    newValue: T
  ) {
    val name = prop.name
    print("$name changed from $value to $newValue")
    value = newValue
  }
  
}

private val 'token$delegate' =
  LoggingProperty<String?>(null)

var token: String?
  get() = 'token$delegate'.getValue(this, ::token)
  set(value) {
    'token$delegate'.setValue(this, ::token, value)
  }

inline fun <T, R : Any> Iterable<T>.mapNotNull(
  transform: (T) -> R?
): List<R> {
  return mapNotNullTo(ArrayList<R>(), transform)
}

class Forest(val name: String) {
  fun addTree(name: String) {
    // ...
  }
}

class CoffeeMachine {
  
  fun makeCoffee() {
    // 수백 개의 변수를 선언
    // 복잡한 로직을 처리
    //  낮은 수준의 최적화도 여기에서 처리 
  }
  
}

class CoffeeMachine {
  
  // 높은 레벨
  fun makeCoffee() {
    boilWater()
    brewCoffee()
    pourCoffee()
    pourMilk()
  }
  
  // 낮은 레벨
  private fun boilWater() { // ... }
  private fun brewCoffee() { // ... }
  private fun pourCoffee() { // ... }
  private fun pourMilk() { // ... }
  
}

val list = ArrayList<String>()      // 생성자
val list2 = mutableListOf<String>() // 팩토리 함수

class MyLinkedList<T>(
  val head: T,
  val tail: MyLinkedList<T>?
) {

  companion object {
    fun <T> of(vararg elements: T): MyLinkedList<T>? {
      // ...
    }
  }
}

// 사용
val list = MyLinkedList.of(1, 2)

// 교체할 수 없는 인터페이스
interface Tool {
    companion object {
        // ...
    }
}

// 확장 함수로 정의
fun Tool.Companion.createBigTool() : BigTool { }

// 호출
Tool.createBigTool()

class MainActivity: Activity {
  companion object {
    fun getIntent(context: Context = Intent(context, MainActivity::class.java) 
  }
}

List(4) { "User$it" } // [User0, User1, User2 ...]

public inline fun <T> List(
    size: Int,
    init: (index: Int) -> T
): List<T> = MutableList(size, init)

public inline fun <T> MutableList(
    size: Int,
    init: (index: Int) -> T
): MutableList<T> {
    val list = ArrayList<T>(size)
    repeat(size) { index -> list.add(init(index) }
    return list
}

inline fun <reified T> printGenerics(value: T) {
    when (T::class) {
        String::class -> {
            println("String : $value")
        }
        Int::class -> {
            println("Int : $value")
        }
    }
}

printGenerics1("print generics function")
printGenerics1(1000)

data class Student(
  val id: Int,
  val name: String,
  val surname: String
)

class StudentsFactory {
  var nextId = 0  // 여기가 상태
  fun next(name: String, surname: String = Student(nextId++, surname)
}

val factory = StudentsFactory()
val s1 = factory.next("Hello", "World") // Student(id=0, name="Hello", surname="World")
val s2 = factory.next("Hi", "Kotlin") // Student(id=1, name="Hi", surname="Kotlin")

class Pizza {
    
    private val size: String
    private val cheese: Int
    private val olives: Int
    private val bacon: Int

    constructor(size: String, cheese: Int, olives: Int, bacon: Int) {
        this.size = size
        this.cheese = cheese
        this.olives = olives
        this.bacon = bacon
    }
    
    constructor(size: String, cheese: Int, olives: Int): this(size, cheese, olives, 0)
    
    constructor(size: String, cheese: Int): this(size, cheese, 0, 0)
    
    constructor(size: String): this(size, 0, 0, 0)
    
}

// 각각의 아규먼트가 뭔지 알기가 힘듦
val a = Pizza("L", 3, 4, 5)
val b = Pizza("L", 3, 4)
val c = Pizza("L", 3, )
val d = Pizza("L")

class Pizza(
    val size: String,
    val cheese: Int = 0,
    val olives: Int = 0,
    val bacon: Int = 0,
)

// 아규먼트에 이름까지 지정 가능해서 더 한눈에 다가옵니다.
val a = Pizza(
  size = "L",
  cheese = 3,
  olives = 4,
  bacon = 5,
)

val b = Pizza(
  size = "L",
  cheese = 3,
  olives = 4,
)

val c = Pizza(
  size = "L",
  cheese = 3,
)

val d = Pizza(
  size = "L",
)

class Pizza(
    val size: String,
    val cheese: Int = 0,
    val olives: Int = 0,
    val bacon: Int = 0
) {
    class Builder(private val size: String) {
        private var cheese: Int = 0
        private var olives: Int = 0
        private var bacon: Int = 0
        
        fun setCheese(value: Int): Builder = apply {
            cheese = value
        }

        fun setOlives(value: Int): Builder = apply {
            olives = value
        }

        fun setBacon(value: Int): Builder = apply {
            bacon = value
        }
        
        fun build() = Pizza(size, cheese, olives, bacon)
    }
}

// 점층적 생성자 패턴보다 이름이 명시가 되어서 훨씬 보기 좋아졌습니다.
val pizza = Pizza.Builder("L")
  .setCheese(3)
  .setOlives(4)
  .setBacon(5)
  .build()

class Pizza(
    val size: String,
    val cheese: Int = 0,
    val olives: Int = 0,
    val bacon: Int = 0,
)

val pizza = Pizza(
  size = "L",
  cheese = 3,
  olives = 4,
  bacon = 5,
)

class ProfilerLoader {
    fun load() {
        // 프로그래스 바를 보여 줌
        // 프로파일을 읽어 들임
        // 프로그레스 바를 숨김
    }
}

class ImageLoader {
    fun load() {
        // 프로그래스 바를 보여 줌
        // 이미지를 읽어 들임
        // 프로그레스 바를 숨김
    }
}

abstract class LoaderWithProgress {
    fun load() {
        // 프로그래스 바를 보여 줌
        innerLoad()
        // 프로그래스 바를 숨김
    }

    abstract fun innerLoad()
}


class ProfilerLoader: LoaderWithProgress() {
    override fun innerLoad() {
        // 프로파일을 읽어 들임
    }
}

class ImageLoader: LoaderWithProgress() {
    override fun innerLoad() {
        // 이미지를 읽어 들임
    }
}

class Progress {
    
    fun showProgress() {
        // ...
    }
    
    fun hideProgress() {
        // ...
    }
}


class ProfilerLoader {
    private val progress = Progress()
    
    fun load() {
        progress.showProgress()
        // 프로파일을 읽어 들임        
        progress.hideProgress()
    }
}

class ImageLoader {
    private val progress = Progress()

    fun load() {
        progress.showProgress()
        // 이미지를 읽어 들임        
        progress.hideProgress()
    }
}

data class Player(
    val id: Int,
    val name: String,
    val points: Int,
)

//  하나의 메서드만 가지는 인터페이스 SAM(Single Abstract Method)
interface OnClick {
    fun clicked(view: View)
}

fun setOnClickListener(listener: OnClick) {
    // ...
}

setOnClickListener(object : OnClick {
    override fun clicked(view: View) {
        // ...
    }
})

fun setOnClickListener(listener: (View) -> Unit) {
  // ...
}

setOnClickListener { //... }
setOnClickListener(fun(view) { // ... } )

setOnClickListener(::println)
setOnClickListener(this::showUsers)

class ClickListener: (View) -> Unit {
    override fun invoke(view: View) {
        // ...
    }
}

setOnClickListener(ClickListener())

class ValueMatcher<T> private constructor(
    private val value: T? = null,
    private val matcher: Matcher
) {
    
    companion object {
        fun <T> equal(value: T)
            = ValueMatcher<T>(value = value, matcher = Matcher.EQUAL)

        fun <T> notEqual(value: T)
                = ValueMatcher<T>(value = value, matcher = Matcher.NOT_EQUAL)

        fun <T> emptyList(value: T)
                = ValueMatcher<T>(value = value, matcher = Matcher.LIST_EMPTY)

        fun <T> notEmptyList(value: T)
                = ValueMatcher<T>(value = value, matcher = Matcher.LIST_NOT_EMPTY)
    }
    
    enum class Matcher {
        EQUAL,
        NOT_EQUAL,
        LIST_EMPTY,
        LIST_NOT_EMPTY
    }
    
    fun match(value: T?) = when(matcher) {
        Matcher.EQUAL -> value == this.value
        Matcher.NOT_EQUAL -> value != this.value
        Matcher.LIST_EMPTY -> value is List<*> && value.isEmpty()
        Matcher.LIST_NOT_EMPTY -> value is List<*> && value.isNotEmpty()
    }
    
}

sealed class ValueMatcher<T> {
   abstract fun match(value: T): Boolean
   
   class Equal<T>(private val value: T) : ValueMatcher<T>() {
       override fun match(value: T): Boolean {
           return value == this.value
       }
   }

    class NotEqual<T>(private val value: T) : ValueMatcher<T>() {
        override fun match(value: T): Boolean {
            return value != this.value
        }
    }

    class EmptyList<T>(private val value: T) : ValueMatcher<T>() {
        override fun match(value: T): Boolean {
            return value is List<*> && value.isEmpty()
        }
    }

    class NotEmptyList<T>(private val value: T) : ValueMatcher<T>() {
        override fun match(value: T): Boolean {
            return value is List<*> && value.isNotEmpty()
        }
    }
}

interface PhoneBook {
    fun String.isPhoneNumber(): Boolean
}

class Fizz: PhoneBook {
    override fun String.isPhoneNumber(): Boolean {
        return length == 7 && all { it.isDigit() }
    }
}

val str1 = "Hello World"
val str2 = "Hello World"
print(str1 == str2)  // true
print(str1 === str2) // true, str2를 캐시로부터 읽어들이기 때문에

val i1 = 1
val i2 = 1
print(i1 == i2)  // true
print(i1 === i2)  // true, i2를 캐시로부터 읽어 들이기 때문에

val j1 = 1234
val j2 = 1234
print(j1 == j2)  // true
print(j1 === j2)  // false, 범위를 벗어나서 캐시를 하지 않습니다.

inline fun repeat(times: Int, action: (Int) -> Unit) {
    for (index in 0 until times) {
        action(index)
    }
}

// 함수 호출하는 부분
repeat(10) {
    print(it)
}

// 컴파일 당시
for (index in 0 until 10) {
    print(index)
}

inline class Name(private val value: String) {
    fun greet() {
        print("Hello, I am $value")
    }
}

val name: Name = Name("Marcin")
name.greet()
        
// 컴파일 때 다음과 같은 형태로 변경
val name: Name = Name("Marcin")
Name.'greet-impl'(name)

// time이 Int이므로 어떤 시간이 올지 혼동이 올 수 있습니다.
interface Timer {
    fun callAfter(time: Int, callback: () -> Unit)
}


// 직접 inline class를 통해서 타입에 재한을 줌
inline class Millis(val mills: Int)

interface Timer {
    fun callAfter(time: Millis, callback: () -> Unit)
}

// 모두 Int 타입이므로 실수로 잘못된 값을 넣을 수 있습니다.
@Entity(tableName = "grades")
class Grades(
    @ColumnInfo(name = "studentId")
    val studentId: Int,
    @ColumnInfo(name = "teacherId")
    val teacherId: Int,
    @ColumnInfo(name = "schoolId")
    val schoolId: Int,
)

// 인라인 클래스로 대체
inline class StudentId(val studentId: Int)
inline class TeacherId(val teacherId: Int)
inline class SchoolId(val schoolId: Int)

@Entity(tableName = "grades")
class Grades(
    @ColumnInfo(name = "studentId")
    val studentId: StudentId,
    @ColumnInfo(name = "teacherId")
    val teacherId: TeacherId,
    @ColumnInfo(name = "schoolId")
    val schoolId: SchoolId,
)

// 매번 연산
interface Iterable<out T> {
    operator fun iterator(): Iterator<T>
}

// 결과가 불릴때까지 연산이 지연
interface Sequence<out T> {
    operator fun iterator(): Iterator<T>
}