androidx.compose.runtime

fun Composition(applier: Applier<*>, parent: CompositionContext): Composition

import androidx.compose.runtime.AbstractApplier
import androidx.compose.runtime.Composable
import androidx.compose.runtime.ComposeNode
import androidx.compose.runtime.Composition
import androidx.compose.runtime.CompositionContext
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember

// Provided we have a tree with a node base type like the following
abstract class Node {
    val children = mutableListOf<Node>()
}

// We would implement an Applier class like the following, which would teach compose how to
// manage a tree of Nodes.
class NodeApplier(root: Node) : AbstractApplier<Node>(root) {
    override fun insertTopDown(index: Int, instance: Node) {
        current.children.add(index, instance)
    }

    override fun insertBottomUp(index: Int, instance: Node) {
        // Ignored as the tree is built top-down.
    }

    override fun remove(index: Int, count: Int) {
        current.children.remove(index, count)
    }

    override fun move(from: Int, to: Int, count: Int) {
        current.children.move(from, to, count)
    }

    override fun onClear() {
        root.children.clear()
    }
}

// A function like the following could be created to create a composition provided a root Node.
fun Node.setContent(parent: CompositionContext, content: @Composable () -> Unit): Composition {
    return Composition(NodeApplier(this), parent).apply { setContent(content) }
}

// assuming we have Node sub-classes like "TextNode" and "GroupNode"
class TextNode : Node() {
    var text: String = ""
    var onClick: () -> Unit = {}
}
class GroupNode : Node()

// Composable equivalents could be created
@Composable
fun Text(text: String, onClick: () -> Unit = {}) {
    ComposeNode<TextNode, NodeApplier>(::TextNode) {
        set(text) { this.text = it }
        set(onClick) { this.onClick = it }
    }
}

@Composable
fun Group(content: @Composable () -> Unit) {
    ComposeNode<GroupNode, NodeApplier>(::GroupNode, {}, content)
}

// and then a sample tree could be composed:
fun runApp(root: GroupNode, parent: CompositionContext) {
    root.setContent(parent) {
        var count by remember { mutableStateOf(0) }
        Group {
            Text("Count: $count")
            Text("Increment") { count++ }
        }
    }
}

@TestOnly
fun ControlledComposition(applier: Applier<*>, parent: CompositionContext): ControlledComposition

import androidx.compose.runtime.AbstractApplier
import androidx.compose.runtime.Composable
import androidx.compose.runtime.ComposeNode
import androidx.compose.runtime.Composition
import androidx.compose.runtime.CompositionContext
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember

// Provided we have a tree with a node base type like the following
abstract class Node {
    val children = mutableListOf<Node>()
}

// We would implement an Applier class like the following, which would teach compose how to
// manage a tree of Nodes.
class NodeApplier(root: Node) : AbstractApplier<Node>(root) {
    override fun insertTopDown(index: Int, instance: Node) {
        current.children.add(index, instance)
    }

    override fun insertBottomUp(index: Int, instance: Node) {
        // Ignored as the tree is built top-down.
    }

    override fun remove(index: Int, count: Int) {
        current.children.remove(index, count)
    }

    override fun move(from: Int, to: Int, count: Int) {
        current.children.move(from, to, count)
    }

    override fun onClear() {
        root.children.clear()
    }
}

// A function like the following could be created to create a composition provided a root Node.
fun Node.setContent(parent: CompositionContext, content: @Composable () -> Unit): Composition {
    return Composition(NodeApplier(this), parent).apply { setContent(content) }
}

// assuming we have Node sub-classes like "TextNode" and "GroupNode"
class TextNode : Node() {
    var text: String = ""
    var onClick: () -> Unit = {}
}
class GroupNode : Node()

// Composable equivalents could be created
@Composable
fun Text(text: String, onClick: () -> Unit = {}) {
    ComposeNode<TextNode, NodeApplier>(::TextNode) {
        set(text) { this.text = it }
        set(onClick) { this.onClick = it }
    }
}

@Composable
fun Group(content: @Composable () -> Unit) {
    ComposeNode<GroupNode, NodeApplier>(::GroupNode, {}, content)
}

// and then a sample tree could be composed:
fun runApp(root: GroupNode, parent: CompositionContext) {
    root.setContent(parent) {
        var count by remember { mutableStateOf(0) }
        Group {
            Text("Count: $count")
            Text("Increment") { count++ }
        }
    }
}

fun PausableComposition(applier: Applier<*>, parent: CompositionContext): PausableComposition

fun ReusableComposition(applier: Applier<*>, parent: CompositionContext): ReusableComposition

@TestOnly
fun clearCompositionErrors(): Unit

fun <T : Any?> compositionLocalOf(
    policy: SnapshotMutationPolicy<T> = structuralEqualityPolicy(),
    defaultFactory: () -> T
): ProvidableCompositionLocal<T>

fun <T : Any?> compositionLocalWithComputedDefaultOf(defaultComputation: CompositionLocalAccessorScope.() -> T): ProvidableCompositionLocal<T>

import androidx.compose.runtime.compositionLocalOf
import androidx.compose.runtime.compositionLocalWithComputedDefaultOf

val LocalBaseValue = compositionLocalOf { 10 }
val LocalLargerValue = compositionLocalWithComputedDefaultOf {
    LocalBaseValue.currentValue + 10
}

import androidx.compose.runtime.Composable
import androidx.compose.runtime.CompositionLocalProvider
import androidx.compose.runtime.compositionLocalOf
import androidx.compose.runtime.compositionLocalWithComputedDefaultOf

val LocalValue = compositionLocalOf { 10 }
val LocalLargerValue = compositionLocalOf { 12 }
val LocalComputedValue = compositionLocalWithComputedDefaultOf { LocalValue.currentValue + 4 }

// In this example `LocalLargerValue` needs to be re-provided
// whenever `LocalValue` is provided to keep its value larger
// then `LocalValue`. However, `LocalComputedValue` does not
// need to be re-provided to stay larger than `LocalValue` as
// it is calculated based on the currently provided value for
// `LocalValue`. Whenever `LocalValue` is provided the value
// of `LocalComputedValue` is computed based on the currently
// provided value for `LocalValue`.

@Composable
fun App() {
    // Value is 10, the default value for LocalValue
    val value = LocalValue.current
    // Value is 12, the default value
    val largerValue = LocalLargerValue.current
    // Value is computed to be 14
    val computedValue = LocalComputedValue.current
    CompositionLocalProvider(LocalValue provides 20) {
        // Value is 20 provided above
        val nestedValue = LocalValue.current
        // Value is still 12 as an updated value was not re-provided
        val nestedLargerValue = LocalLargerValue.current
        // Values is computed to be 24; LocalValue.current + 4
        val nestedComputedValue = LocalComputedValue.current
        CompositionLocalProvider(LocalLargerValue provides LocalValue.current + 2) {
            // Value is 22 provided above
            val newLargerValue = LocalLargerValue.current

            CompositionLocalProvider(LocalValue provides 50) {
                // Value is now 50 provided above
                val finalValue = LocalValue.current
                // Value is still 22
                val finalLargerValue = LocalLargerValue.current
                // Value is now computed to be 54
                val finalComputed = LocalComputedValue.current
            }
        }
    }
}

fun <T : Any?> compositionLocalWithHostDefaultOf(key: HostDefaultKey<T>): ProvidableCompositionLocal<T>

@TestOnly
fun currentCompositionErrors(): List<Pair<Exception, Boolean>>

@StateFactoryMarker
fun <T : Any?> derivedStateOf(calculation: () -> T): State<T>

import androidx.compose.material.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.State
import androidx.compose.runtime.derivedStateOf
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember

@Composable
fun CountDisplay(count: State<Int>) {
    Text("Count: ${count.value}")
}

@Composable
fun Example() {
    var a by remember { mutableStateOf(0) }
    var b by remember { mutableStateOf(0) }
    val sum = remember { derivedStateOf { a + b } }
    // Changing either a or b will cause CountDisplay to recompose but not trigger Example
    // to recompose.
    CountDisplay(sum)
}

@StateFactoryMarker
fun <T : Any?> derivedStateOf(
    policy: SnapshotMutationPolicy<T>,
    calculation: () -> T
): State<T>

import androidx.compose.material.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.State
import androidx.compose.runtime.derivedStateOf
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember

@Composable
fun CountDisplay(count: State<Int>) {
    Text("Count: ${count.value}")
}

@Composable
fun Example() {
    var a by remember { mutableStateOf(0) }
    var b by remember { mutableStateOf(0) }
    val sum = remember { derivedStateOf { a + b } }
    // Changing either a or b will cause CountDisplay to recompose but not trigger Example
    // to recompose.
    CountDisplay(sum)
}

@TestOnly
fun disableHotReloadMode(): Unit

@TestOnly
fun invalidateGroupsWithKey(key: Int): Unit

@ComposeCompilerApi
fun isTraceInProgress(): Boolean

@RememberInComposition
fun movableContentOf(content: @Composable () -> Unit): @Composable () -> Unit

import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.runtime.movableContentOf
import androidx.compose.runtime.remember

val movableContent = remember(content) { movableContentOf(content) }

if (vertical) {
    Column { movableContent() }
} else {
    Row { movableContent() }
}

import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.runtime.Composable
import androidx.compose.runtime.movableContentOf
import androidx.compose.runtime.remember

val itemMap = remember { mutableMapOf<Item, @Composable () -> Unit>() }
val movableItems =
    remember(items) {
        val itemsToRemove = itemMap.keys.toMutableSet()
        val movableItems =
            items.map { item ->
                itemsToRemove.remove(item)
                itemMap.getOrPut(item) { movableContentOf { ItemView(item) } }
            }
        itemsToRemove.forEach { itemMap.remove(it) }
        movableItems
    }

val itemsPerColumn = 10
val columns = items.size / itemsPerColumn + (if (items.size % itemsPerColumn == 0) 0 else 1)
Row {
    repeat(columns) { column ->
        Column {
            val base = column * itemsPerColumn
            val end = minOf(base + itemsPerColumn, items.size)
            for (index in base until end) {
                movableItems[index]()
            }
        }
    }
}

@RememberInComposition
fun <P : Any?> movableContentOf(content: @Composable (P) -> Unit): @Composable (P) -> Unit

import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.runtime.movableContentOf
import androidx.compose.runtime.remember

val movableContent = remember(content) { movableContentOf(content) }

if (vertical) {
    Column { movableContent() }
} else {
    Row { movableContent() }
}

import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.runtime.Composable
import androidx.compose.runtime.movableContentOf
import androidx.compose.runtime.remember

val itemMap = remember { mutableMapOf<Item, @Composable () -> Unit>() }
val movableItems =
    remember(items) {
        val itemsToRemove = itemMap.keys.toMutableSet()
        val movableItems =
            items.map { item ->
                itemsToRemove.remove(item)
                itemMap.getOrPut(item) { movableContentOf { ItemView(item) } }
            }
        itemsToRemove.forEach { itemMap.remove(it) }
        movableItems
    }

val itemsPerColumn = 10
val columns = items.size / itemsPerColumn + (if (items.size % itemsPerColumn == 0) 0 else 1)
Row {
    repeat(columns) { column ->
        Column {
            val base = column * itemsPerColumn
            val end = minOf(base + itemsPerColumn, items.size)
            for (index in base until end) {
                movableItems[index]()
            }
        }
    }
}

@RememberInComposition
fun <P1 : Any?, P2 : Any?> movableContentOf(content: @Composable (P1, P2) -> Unit): @Composable (P1, P2) -> Unit

import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.runtime.movableContentOf
import androidx.compose.runtime.remember

val movableContent = remember(content) { movableContentOf(content) }

if (vertical) {
    Column { movableContent() }
} else {
    Row { movableContent() }
}

import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.runtime.Composable
import androidx.compose.runtime.movableContentOf
import androidx.compose.runtime.remember

val itemMap = remember { mutableMapOf<Item, @Composable () -> Unit>() }
val movableItems =
    remember(items) {
        val itemsToRemove = itemMap.keys.toMutableSet()
        val movableItems =
            items.map { item ->
                itemsToRemove.remove(item)
                itemMap.getOrPut(item) { movableContentOf { ItemView(item) } }
            }
        itemsToRemove.forEach { itemMap.remove(it) }
        movableItems
    }

val itemsPerColumn = 10
val columns = items.size / itemsPerColumn + (if (items.size % itemsPerColumn == 0) 0 else 1)
Row {
    repeat(columns) { column ->
        Column {
            val base = column * itemsPerColumn
            val end = minOf(base + itemsPerColumn, items.size)
            for (index in base until end) {
                movableItems[index]()
            }
        }
    }
}

@RememberInComposition
fun <P1 : Any?, P2 : Any?, P3 : Any?> movableContentOf(
    content: @Composable (P1, P2, P3) -> Unit
): @Composable (P1, P2, P3) -> Unit

import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.runtime.movableContentOf
import androidx.compose.runtime.remember

val movableContent = remember(content) { movableContentOf(content) }

if (vertical) {
    Column { movableContent() }
} else {
    Row { movableContent() }
}

import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.runtime.Composable
import androidx.compose.runtime.movableContentOf
import androidx.compose.runtime.remember

val itemMap = remember { mutableMapOf<Item, @Composable () -> Unit>() }
val movableItems =
    remember(items) {
        val itemsToRemove = itemMap.keys.toMutableSet()
        val movableItems =
            items.map { item ->
                itemsToRemove.remove(item)
                itemMap.getOrPut(item) { movableContentOf { ItemView(item) } }
            }
        itemsToRemove.forEach { itemMap.remove(it) }
        movableItems
    }

val itemsPerColumn = 10
val columns = items.size / itemsPerColumn + (if (items.size % itemsPerColumn == 0) 0 else 1)
Row {
    repeat(columns) { column ->
        Column {
            val base = column * itemsPerColumn
            val end = minOf(base + itemsPerColumn, items.size)
            for (index in base until end) {
                movableItems[index]()
            }
        }
    }
}

@RememberInComposition
fun <P1 : Any?, P2 : Any?, P3 : Any?, P4 : Any?> movableContentOf(
    content: @Composable (P1, P2, P3, P4) -> Unit
): @Composable (P1, P2, P3, P4) -> Unit

import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.runtime.movableContentOf
import androidx.compose.runtime.remember

val movableContent = remember(content) { movableContentOf(content) }

if (vertical) {
    Column { movableContent() }
} else {
    Row { movableContent() }
}

import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.runtime.Composable
import androidx.compose.runtime.movableContentOf
import androidx.compose.runtime.remember

val itemMap = remember { mutableMapOf<Item, @Composable () -> Unit>() }
val movableItems =
    remember(items) {
        val itemsToRemove = itemMap.keys.toMutableSet()
        val movableItems =
            items.map { item ->
                itemsToRemove.remove(item)
                itemMap.getOrPut(item) { movableContentOf { ItemView(item) } }
            }
        itemsToRemove.forEach { itemMap.remove(it) }
        movableItems
    }

val itemsPerColumn = 10
val columns = items.size / itemsPerColumn + (if (items.size % itemsPerColumn == 0) 0 else 1)
Row {
    repeat(columns) { column ->
        Column {
            val base = column * itemsPerColumn
            val end = minOf(base + itemsPerColumn, items.size)
            for (index in base until end) {
                movableItems[index]()
            }
        }
    }
}

@RememberInComposition
fun <R : Any?> movableContentWithReceiverOf(content: @Composable R.() -> Unit): @Composable R.() -> Unit

import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.runtime.movableContentOf
import androidx.compose.runtime.remember

val movableContent = remember(content) { movableContentOf(content) }

if (vertical) {
    Column { movableContent() }
} else {
    Row { movableContent() }
}

import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.runtime.Composable
import androidx.compose.runtime.movableContentOf
import androidx.compose.runtime.remember

val itemMap = remember { mutableMapOf<Item, @Composable () -> Unit>() }
val movableItems =
    remember(items) {
        val itemsToRemove = itemMap.keys.toMutableSet()
        val movableItems =
            items.map { item ->
                itemsToRemove.remove(item)
                itemMap.getOrPut(item) { movableContentOf { ItemView(item) } }
            }
        itemsToRemove.forEach { itemMap.remove(it) }
        movableItems
    }

val itemsPerColumn = 10
val columns = items.size / itemsPerColumn + (if (items.size % itemsPerColumn == 0) 0 else 1)
Row {
    repeat(columns) { column ->
        Column {
            val base = column * itemsPerColumn
            val end = minOf(base + itemsPerColumn, items.size)
            for (index in base until end) {
                movableItems[index]()
            }
        }
    }
}

@RememberInComposition
fun <R : Any?, P : Any?> movableContentWithReceiverOf(content: @Composable R.(P) -> Unit): @Composable R.(P) -> Unit

import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.runtime.movableContentOf
import androidx.compose.runtime.remember

val movableContent = remember(content) { movableContentOf(content) }

if (vertical) {
    Column { movableContent() }
} else {
    Row { movableContent() }
}

import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.runtime.Composable
import androidx.compose.runtime.movableContentOf
import androidx.compose.runtime.remember

val itemMap = remember { mutableMapOf<Item, @Composable () -> Unit>() }
val movableItems =
    remember(items) {
        val itemsToRemove = itemMap.keys.toMutableSet()
        val movableItems =
            items.map { item ->
                itemsToRemove.remove(item)
                itemMap.getOrPut(item) { movableContentOf { ItemView(item) } }
            }
        itemsToRemove.forEach { itemMap.remove(it) }
        movableItems
    }

val itemsPerColumn = 10
val columns = items.size / itemsPerColumn + (if (items.size % itemsPerColumn == 0) 0 else 1)
Row {
    repeat(columns) { column ->
        Column {
            val base = column * itemsPerColumn
            val end = minOf(base + itemsPerColumn, items.size)
            for (index in base until end) {
                movableItems[index]()
            }
        }
    }
}