/*
 * The top of the file should start with the current package namespace.
*/
package moe.kisara.learn

// then any desired imports, by default kotlin auto imports these.
import kotlin.*
import kotlin.annotations.*
import kotlin.collections.*
import kotlin.comparisons.*
import kotlin.io.*
import kotlin.ranges.*
import kotlin.sequences.*
import kotlin.text.*

// when targeting the java platform these are also imported
import java.lang.*
import kotlin.jvm.*

// you can alias an import to some other identifier
import moe.kisara.learn.List as KisaraList

// you can declare variables as mutable or immutable
var fooString = "foo"
val barString = "bar"

fooString = "not foo"
// barString = "not bar" // error: val cannot be reassigned

// The type of a declaration can be specified before the assignment.
// this is required when you don't have an initial value bot otherwise
// can be ommited and inferred by the type system.
var myString: String
myString = "hello"

fun hello(name: String) {
  println("hello $name")
}

// Kotlin also introduces a new compact `Range` type like rubys slice.
for (i in 1..10) {
  println(i)
}

// these can be used to retrieve subsections of collections or strings
"hello".slice(1..2) // "el"

fun addInt(a: Int, b: Int): Int {
    return a + b
}

// store addInt to the variable myAddFunction
val myAddFunction: (Int, Int) -> Int = ::addInt
val op1: Int = 5
val op2: Int = 2

println("$op1 + $op2 = ${myAddFunction(op1, op2)}") // 5 + 2 = 7

fun runAdd(func: Int.(Int) -> Int, op1: Int, op2: Int): Int {
  return op1.func(op2)
}

println("$op1 + $op2 = ${runAdd(Int::plus, op1, op2)}") // 5 + 2 = 7

// nullable types are declared by suffixing it with ?
var foo: String? = null

// There are some syntax extensions to make working with null easier.
foo?.length // null if foo is null, else runs `foo.length`

// The `elvis` operator lets you quickly run an `if not null` expression.
foo ?: throw Exception("foo is unassigned")

// you can force a NullPointerException if `foo` is null
foo!!

var bar: Any = "hello"

if (bar is String) {
  // implicit type cast to String within body
  println("$bar is ${bar.length} chars long")
}

val foo: String = "hello"
// val bar: Int = foo as Int // runtime-error: cannot cast string to int
val bar: Int? = foo as? Int // cast failed, bar is null

println(1 shl 2) // 4

fun copy(from: Array<out Any>, to: Array<Any>) {
    assert(from.size == to.size)
    for (i in from.indices)
        to[i] = from[i]
}

val ints: Array<Int> = arrayOf(1, 2, 3)
val any = Array<Any>(3) { "" }
copy(ints, any)

fun fill(dest: Array<in String>, value: String) {
    for (i in dest.indices) {
        dest[i] = value
    }
}

// any T must be Comparable.
fun <T : Comparable<T>> sort(list: List<T>) { ... }

// To supple multiple upper bounds you have to use a where clause.
fun <T> copyWhenGreater(list: List<T>, threshold: T): List<String>
    where T : CharSequence,
          T : Comparable<T> {
    ...
}

fun takeAnyList(list: List<*>) { ... }

fun demoLoop() {
  for (var i in 10 downTo 0 step 2) {
    print("$i ")
  }
}

demoLoop() // 10 8 6 4 2 0

var x = 0
while (x < 10) {
  println(x++)
}

var x = 10
do {
  println(x++)
} while (x < 10)

fun Int.printMe() {
  println("this is $this")
}

5.printMe() // this is 5

fun Int.toString(): String {
  return "a number"
}

println("this is ${5.toString()}") // this is 5

fun add(a: Int, b: Int = 1): Int {
  return a + b
}

println(add(5, 2)) // 7
println(add(5, b=3)) // 8

fun printMe(vararg args: Any) {
  // args is an array of Any: Any[]
  for (arg in args) {
    println(arg)
  }
}

printMe("hello", "world", 5)
printMe(*arrayOf("hello", "world", 5)) // spread an array

fun runMe(func: () -> Unit) {
    func()
}

// An annoymous function is just a function without a name.
runMe(fun() { println("I'm being run") }) // I'm being run

/*
 * if the last argument of a function is a function, then
 * you can supply this function in its own block outside of
 * the () as a lambda.
*/
runMe { println("I'm being run") } // I'm being run

/*
 * if a lambda function takes just one argument, that argument
 * can be accessed as `it` within the lambda body.
*/
fun runMeWithInt(i: Int, func: (Int) -> Unit) {
  func(i)
}

runMeWithInt(5) { println(it + 2) }

fun returnsFirstLambda(l: List<Int>): Int {
    l.map { return it }
    return -1
}

fun returnsFirstAnon(l: List<Int>): Int {
    l.map(fun(i: Int): Int { return i })
    return -1
}

val list = listOf(1,2,3,4,5)
returnsFirstLambda(list) // 1
returnsFirstAnon(list) // -1

infix fun Int.addNum(i: Int): Int {
  return this + i
}

5.addNum(3) // 8
5 addNum 3  // 8

val i = true
println(if (i) "true" else "not true")

val foo: Any = "hello"

when (foo) {
  is Double -> println("is Double")
  !is String -> println("isn't String")
  2 -> println("is 2")
  else -> {
    println("otherwise")
  }
}

with(6) { "value is: ${toString()}" } // value is: 6

// You can alias a complex type using the `typealias` keyword.
// For example you could alias a function to something nicer.

typealias Stringifier<T> = T.() -> String
var s: Stringifier<String> = String::toString
s("hello world") // hello world

// the let function lets you bypass the need for an intermediate
// variable name. run some processes on an instance and then return
// the result.
5.let { it+6 } // 11

// with is a function which executes block with `this` as reciever and
// returns the result.
with(5) { this+6 } // 11

// the run function is the same, except it doesn't pass the instance
// as an argument, it instead passes it as a reciever.
5.run { this+6 } // 11

data class Person(var name: String, var age: Int)

// apply runs the passed lambda with this as the reciever and then
// returns the original instance (ignoring the result of the lambda).
Person("Adam", 20).apply {
    age = 25
    name = "Bruce"
}

// same as apply but `this` is passed as an instance.
Person("Adam", 20).also {
    it.age = 25
    it.name = "Bruce"
}

val myList = listOf("foo", "bar", "baz") // immutable List<String>
myList.get(0) // "foo"
myList.getOrElse(10, "bag") // "bag"
myList[0] // foo
// myList.set(0, "bar") // unresolved function

val myMutableList = mutableListOf("foo", "bar", "baz")
myMutableList.set(0, "bar") // unresolved function

val myMap = mapOf("foo" to 0, "bar" to 1, "baz" to 2)
myMap["foo"] // 0

mutableMapOf<String, Int>().apply {
  this["foo"] = 0
  this["bar"] = 1
  this["baz"] = 2
}

List(5) { i -> i * i } // [0, 1, 4, 9, 16]

val list = listOf(1, 2, 3)
list + 4 // [1, 2, 3, 4]
list - 3 // [1, 2]
list - listOf(1, 2) // [3]

mapOf("foo" to 1, "bar" to 1, "baz" to 2).forEach { key, value ->
  println("$key -> $value")
}

listOf("foo", "bar", "baz").map { println(it) }

Array(8) { it }.filter { it % 2 == 0 } // [0, 2, 4, 6]

val list = (1..5).toMutableList() // [1, 2, 3, 4, 5]

list.shuffled() // [5, 1, 3, 2, 4]

list.sorted() // [1, 2, 3, 4, 5]
list.sorted().reversed() // [5, 4, 3, 2, 1]

/* you can specify you're own comparator for sorting */
list.sortedWith(Comparator { a, b -> if (a < b) +1 else -1 }) // [5, 4, 3, 2, 1]
list.sortedWith(compareBy { it * -1 }) // [5, 4, 3, 2, 1]

/* The `By` suffixed functions first map each entry through
   the lambda and compares using the result. */
listOf("aaa", "bb", "c").sortedBy { it.length } // [c, bb, aaa]

/* the `as` prefixed series of functions return a new List which is
   interfaced to the same underlying list but ordered differently. */
val reversedList = list.asReversed()
reversedList // [5, 4, 3, 2, 1]
list // [1, 2, 3, 4, 5]
list.add(6)
list // [1, 2, 3, 4, 5, 6]
reversedList [6, 5, 4, 3, 2, 1]

/* true if at least one element passes predicate */
list.any { it == 1 }

/* true if no element passes predicate */
list.none { it > 10 }

/* true if every element passes predicate */
list.all { it < 10 }

/* associations convert a list to a map */
fun Int.square(): Int { return this * this }

list.associateWith { it.square() } // {1=1, 2=4, 3=9, 4=16, 5=25}
list.associateBy   { it.square() } // {1=1, 4=2, 9=3, 16=4, 25=5}

/* seperates into two sublists */
list.partition { it < 3 } // ([1, 2], [3, 4, 5])

/* chunk to sublists of length at most 2. */
list.chunked(2) // [[1, 2], [3, 4], [5]]

/* windowed gives you sliding window across the iterable */
list.windowed(2) // [[1, 2], [2, 3], [3, 4], [4, 5]]

/* take or remove elements from a list. */
list.take(2) // [1, 2]
list.takeLast(2) // [4, 5]
list.drop(2) // [3, 4, 5]
list.dropLast(2) // [1, 2, 3]

/* returns either the first element of a list, or the
   first element for which some predicate is true.

   NOTE also aliased to `find()` */
list.first { it % 2 == 0 } // 2

list.last { it % 2 == 0 } // 4

/* accumulate list elements, `fold()` takes an iniial value as well. */
list.reduce { a, b -> a + b } // 1+2+3+4+5 = 15
list.fold(6) { a, b -> a + b } // 1+2+3+4+5+6 = 21

/* use a lambda to calculate a key and then map group each
   entry by that key. */
listOf("foo", "bar", "baz").groupBy { it[0] } // {f=[foo], b=[bar, baz]}

val list (1..10).toList().map {
  it * it
}.filter {
  it % 2 == 0
}

val seq = sequenceOf(1,2,3,4,5,6,7,8,9,10).map {
  it * it
}.filter {
  it % 2 == 0
}

class Foo

val foo: Foo = Foo()
println(foo) // moe.kisara.learn.Foo@7dc5e7b4

class Bar(sVal: String) {
    // instance variables are declared in the class body
    val s = sVal
    val l = s.length

    // methods are also declared here
    fun barString() {
        return String.format("Foo{%s,%d}", this.s, this.l)
    }
}

Bar("hello world").barString() // Foo{hello world,11}

class Baz(sVal: String) {
    init {
        println("first init block: $sVal")
        // you can't access instance fields in an init block before their
        // assigned.
        // println("first init block: ${this.s}")
    }

    val s = sVal

    // multiple blocks are collected into a single primary constructor call
    init {
        println("second init block: ${this.s}")
    }
}

// if you prefix a parameter in the primary constructor with
// val/var, it's automatically assigned at construction.
class Bag(val foo: String)
Bag("hello").foo // hello

// if you want to change the scope or add an annotation to the
// primary constructor, you must explicitly qualify it.
class Foo private @Inject constructor() {}

// secondary constructors (custructor overloads) can be defined in
// the class body.
class MultiConstructor(val foo: String) {
    // an overload with no parameters, must invoke primary constructor.
    constructor() : this("default foo") {}
}

MultiConstructor("hello world").foo // hello world
MultiConstructor().foo // default foo

class WithProperties {
    // kotlin lets you specify an optional getter/setter for a field
    // with its own access specifiers.
    var aString: String = "default-value"
        // the current value of the backing field can be accessed
        // through the `value` keyword
        get() = value
        // you can assign to the backing field through `field`
        private set(value) {
            field = value
        }

    fun setValue(s: String) {
        this.aString = s
    }

    val isEmpty get() = this.aString.isEmpty()
}

val wp = WithProperties()
wp.aString // "default-value"
wp.isEmpty // false

// wp.aString = "" // error: setter is private
wp.setValue("")

wp.aString // ""
wp.isEmpty // true

data class MyIntTuple(val i: Int, val j: Int)

val a = MyIntTuple(0, 0)
val b = MyIntTuple(0, 0)
val c = MyIntTuple(2, 2)

println(a) // MyIntTuple(i=0, j=0)

a == b // true
a != c // true

// you can also destructure data-class instances
val (x, y) = a
x // 0
y // 0

val map = mapOf("hello" to 0, "val" to 1)
for ((key, value) in map) {
    println("$key -> $value")
}

open class Foo(val opt: Int) {
    open fun deriveMe() {
        println("deriveMe in Foo: ${this.opt}")
    }

    fun finalMethod() {
        println("finalMethod in Foo: ${this.opt}")
    }
}

// must supply a value for super primary constructor or generic values.
class Bar : Foo(1) {
    // overriden functions are open by default, to prevent this mark them
    // as final.
    final override fun deriveMe() {
        println("deriveMe in Bar: ${this.opt}")
    }
}

val foo = Foo(0)
foo.deriveMe() // deriveMe in Foo: 0
foo.finalMethod() // finalMethod in Foo: 0

val bar = Bar()
bar.deriveMe() // deriveMe in Bar: 1
bar.finalMethod() // finalMethod in Foo: 1

abstract class Shape {
    abstract fun area(): Int
}

class Rectangle(val width: Int, height: Int) : Shape() {
    override fun area(): Int {
        return this.width * this.height
    }
}

val sh: Shape = Rectangle(5, 5)
sh.area() // 25

enum class ProtocolState {
    WAITING {
        override fun signal() = TALKING
    },

    TALKING {
        override fun signal() = WAITING
    };

    abstract fun signal(): ProtocolState
}

val ps = ProtocolState.WAITING;
when (ps) {
    ProtocolState.WAITING -> println("waiting")
    ProtocolState.TALKING -> println("talking")
}

sealed class Expr
data class Const(val number: Double) : Expr()
data class Sum(val e1: Expr, val e2: Expr) : Expr()
object NotANumber : Expr()

fun eval(expr: Expr): Double = when(expr) {
    is Const -> expr.number
    is Sum -> eval(expr.e1) + eval(expr.e2)
    NotANumber -> Double.NaN
    // the `else` clause is not required because we've covered all the cases
}

interface Animal {
    // abstract function
    fun move()

    // abstract field
    val species: String
}

interface Mamal : Animal {
    // create a new field with a default value
    // NOTE: you can't assign it as an initializer, it must
    //       be a property.
    val legCount: Int get() = 2

    // assign inherited field
    override val species: String get() = "Mamalian"
}

class Tiger(val name: String) : Mamal {
    override val species: String = "Tiger"
    override val legCount: Int = 4

    override fun move() {
        println("$name is moving")
    }
}

val tiger = Tiger("Atsushi")
tiger.species // tiger
tiger.legCount // 4
tiger.move() // Atsushi is moving

class Foo(private val value: Int) {
    class Bar {
        fun baz() {
            println(value)
        }
    }
}

Foo.Bar().baz() // hello

class Foo(private val value: Int) {
    inner class Bar {
        fun baz() {
            println(value)
        }
    }
}

Foo(1).Bar().baz() // 1

object MySingleton {
    var username: String = "mohkale"
    // please god, no! ＼(º □ º l|l)/
    var password: String = "password"
}

MySingleton.username // mohkale
MySingleton.password // password
MySingleton.password = "something-much-more-secure"

// we can use singletons to construct ad-hoc types at runtime.
fun String.isCycle(): Boolean {
    val pos = object {
        var x: Int = 0
        var y: Int = 0
    }

    for (ch in this) {
        when (ch) {
            'L' -> pos.x -= 1
            'R' -> pos.x += 1
            'U' -> pos.y -= 1
            'D' -> pos.y += 1
        }
    }

    return pos.x == 0 && pos.y == 0
}

"LRUD".isCycle() // true

// the rules for anonymous singleton types is somewhat complicated
class C {
    // Private function, so the return type is the anonymous
    // object type. we can access `foo().x` at runtime.
    private fun foo() = object {
        val x: String = "x"
    }

    // Public function, so the return type is Any
    fun publicFoo() = object {
        val x: String = "x"
    }
}

class Klass {
    companion object Foo {
        fun foo() {
            println("hello world")
        }
    }
}

Klass.foo() // hello world
Klass.Foo.foo() // hello world

// if you don't give the companion object a name, it uses `Companion`.
class Qlass {
    companion object {
        fun foo() {
            println("hello world")
        }
    }
}

Qlass.Companion.foo()

inline class Password(val value: String)

interface Base {
    fun print()
}

class BaseImpl(val x: Int) : Base {
    override fun print() { print(x) }
}

class Derived(b: Base) : Base by b

Derived(BaseImpl(10)).print()

fun fact(i: Int): Int = if (i <= 0) i else i + fact(i-1)

class Foo {
    val fact10: Int by lazy { fact(10) }
}

// the fact10 value is only calculated when its first accessed.
Foo().fact10

// delegates can even be used to extract entries from a map
val map = mapOf("a" to 0, "b" to 1)
val b: Int by map // 1

fun foo() {
    listOf(1, 2, 3, 4, 5).forEach lit@{
        if (it == 3) return@lit // continue after the foreach loop.
        print(it)
    }
    print(" done with explicit label")
}

loop@ for (i in 1..100) {
    for (j in 1..100) {
        if (...) break@loop
    }
}

class Foo(private val value: Int) {
    inner class Bar {
        private val value: Int = 0

        fun baz() {
            println(value) // Foo.Bar.value
            println(this@Foo.value) // Foo.value
        }
    }
}

// launch spawns a new coroutine, GlobalScope is the
// default and can be ommited.
val crt = GlobalScope.launch {
    delay(1000) // pauses current coroutine
    println("coroutine done")
}
println("main thread done")

crt.cancel() // propogates CancelException to coroutine
crt.join() // pause current coroutine until ctx finishes
// crt.cancelAndJoin() // alias for above

/* cancellation requires cooperation from the implementation. You have
 * to continually check if a cancellation is requested, if it is then a
 * CancellationException is thrown and the coroutine is silently killed. 
*/

// This coroutine never uses any of the suspend functions or checks if the
// coroutine is cancelled so even if you try to cancel it, it'll continue.
launch {
    var nextPrintTime = startTime
    var i = 0
    while (i < 5) {
        if (System.currentTimeMillis() >= nextPrintTime) {
            println("I'm sleeping ${i++} ...")
            nextPrintTime += 500L
        }
    }
}

/* the `isActive` field within the context of a coroutine can let you know
 * if the coroutine has not been cancelled yet.
*/

// This implementation can be cancelled.
launch {
    var nextPrintTime = startTime
    var i = 0
    while (i < 5 && isActive) {
        if (System.currentTimeMillis() >= nextPrintTime) {
            println("I'm sleeping ${i++} ...")
            nextPrintTime += 500L
        }
    }
}.join()

suspend fun printWorld() {
    delay(1000L)
    println("World!")
}

fun main() { doWorld() }
// Error Suspend function 'doWorld' should be called only
// from a coroutine or another suspend function

// runBlocking spawns a new coroutine, and blocks the calling
// coroutine until it finishes.
fun main() = runBlocking {
    printWorld()
}

suspend fun someLongCalculation() {
    return 5
}

val a = async { someLongCalculation() }
val b = async { someLongCalculation() }
val res = a.await() + b.await()

launch {
    try {
        repeat(1000) { i ->
            println("I'm sleeping $i ...")
            delay(500L)
        }
    } finally {
        // to invoke suspending functions in a cancelled coroutine,
        // you must use a non-cancelled context.
        withContext(NonCancellable) {
            println("cancelled")
            delay(1000L)
            println("returning")
        }
    }
}

// spawn a new coroutine scope, synchronously waits until all
// coroutines spawned within it are completed.
coroutineScope {
    launch {
        delay(500L)
        println("Task from nested launch")
    }

    delay(100L)
    println("Task from coroutine scope")
}

val channel = Channel<Int>()
launch {
    for (x in 1..5) channel.send(x * x)
    channel.close() // we're done sending
}

for (y in channel) println(y)