tree

data class Node<T>(val value: T, var left: Node<T>? = null, var right: Node<T>? = null)

interface TreeStrategy<T> {

    fun add(parent: Node<T>, node: Node<T>)

}

class ComparableComparator<T:Comparable<T>> : Comparator<T> {
    override fun compare(o1: T, o2: T): Int = o1.compareTo(o2)
}

class SimpleComparatorTreeStrategy<T>(val comparator: Comparator<T>) : TreeStrategy<T> {

    override fun add(parent: Node<T>, node: Node<T>) {
        val compareResult = comparator.compare(parent.value, node.value)

        val parentLeft = parent.left
        val parentRight = parent.right

        when {
            compareResult.lessThanParent -> if(parentLeft != null) add(parentLeft, node) else parent.left = node
            compareResult.moreThanParent -> if(parentRight != null) add(parentRight, node) else parent.right = node
        }
    }

    private val Int.moreThanParent: Boolean get() = this < 0
    private val Int.lessThanParent: Boolean get() = this >= 0

}

class Tree<T>(val strategy: TreeStrategy<T>) {

    private var root: Node<T>? = null

    fun add(value: T) {
        val root = root

        val node = Node(value)

        if (root == null) {
            this.root = node
        } else {
            strategy.add(root, node)
        }
    }

    fun forEach(action: (T) -> Unit) {
        root?.let { visit(it, action) }
    }

    private fun visit(node: Node<T>, action: (T) -> Unit) {
        node.left?.let { visit(it, action) }

        action(node.value)

        node.right?.let { visit(it, action) }
    }

}

fun <T:Comparable<T>> treeOf(vararg values:T):Tree<T> = Tree<T>(SimpleComparatorTreeStrategy(ComparableComparator()))
        .also { tree -> values.forEach(tree::add) }

fun main(args: Array<String>) {
    treeOf("test1", "test2", "t", "abcd").forEach(::println)
}