// TeamsGUI.kt

private val PLACEHOLDER_ITEM = guiItem(Material.GRAY_STAINED_GLASS_PANE) {
    name = Component.empty()
}

fun renderTeamsUI(
    teamsRegistry: CivilizationTeamRegistry
): GUI {
    val renderPagination = paginationComponent(
        3 to 3,
        7 to 3,
        teamsRegistry.teams.values,
        PLACEHOLDER_ITEM
    ) { createTeamSlot(it) }

    return gui(
        plugin = JavaPlugin.getPlugin(MCCivilization::class.java),
        title = Component.empty(),
        type = GUIType.Chest(rows = 3)
    ) {
        fill(1, 3, 9, 3) {
            item = PLACEHOLDER_ITEM
        }

        slot(5, 3) {
            closeButtonProp()
        }

        renderPagination(emptyList())
    }
}

private fun createTeamSlot(team: CivilizationTeamImpl): GUI.Slot.() -> Unit = {
    item = item(Material.CYAN_BANNER) {
        name = mm.deserialize("<red>${team.id} <gray>(${team.name})")
    }

    onClick = {
        it.sendMessage("Clicked on ${team.id}!")
    }
}

// PaginationComponent.kt

fun <T> paginationComponent(
    backButtonCoordinates: Pair<Int, Int>,
    forwardButtonCoordinates: Pair<Int, Int>,
    values: Collection<T>,
    placeholderItem: GUIItem? = null,
    paginatedItem: (value: T) -> GUI.Slot.() -> Unit
): GUI.(allowRender: Collection<Int>) -> Unit {
    var currentPage = 1

    var firstRender = true
    val usedSlots = mutableListOf<Int>()

    fun GUI.renderBackButton(type: PaginationButtonType) {
        val (xCoordinate, yCoordinate) = when(type) {
            PaginationButtonType.FORWARD -> forwardButtonCoordinates
            PaginationButtonType.BACK -> backButtonCoordinates
        }

        val buttonName = when(type) {
            PaginationButtonType.FORWARD -> mm.deserialize("<light_purple>Forward: <white>Page ${currentPage + 1}")
            PaginationButtonType.BACK -> mm.deserialize("<light_purple>Back: <white>Page ${currentPage - 1}")
        }

        slot(xCoordinate, yCoordinate) {
            item = item(Material.ARROW) {
                name = buttonName
            }

            onClick = {
                when(type) {
                    PaginationButtonType.FORWARD -> currentPage++
                    PaginationButtonType.BACK -> currentPage--
                }

                refresh()
            }
        }
    }

    return fun GUI.(allowRender: Collection<Int>) {
        // clear previous slots if not first ui render.
        if (!firstRender) {
            for (usedSlot in usedSlots) {
                slot(usedSlot) {
                    item = null
                }
            }
            usedSlots.clear()
        } else {
            firstRender = false
        }

        val freeSlots = inventory.contents.withIndex()
            .associate { it.index to it.value }
            .filterValues { it == null || it.type == Material.AIR }
            .keys
            .toMutableSet()

        // remove slots that should not be rendered into.
        if (allowRender.isNotEmpty()) {
            freeSlots.removeIf { !allowRender.contains(it) }
        }

        val index = (currentPage - 1) * freeSlots.size
        val renderItems = values
            .drop(index)

        for((renderIndex, freeSlot) in freeSlots.withIndex()) {
            val renderItem = renderItems.getOrNull(renderIndex)
                ?: break

            slot(freeSlot, paginatedItem(renderItem))
        }
        usedSlots.addAll(freeSlots)

        val maxPages = try {
            ceil(values.size.toDouble() / freeSlots.size)
                .toInt()
        } catch(_: ArithmeticException) {
            1
        }

        if(currentPage < maxPages) {
            renderBackButton(PaginationButtonType.FORWARD)
        } else {
            val (xCoordinate, yCoordinate) = forwardButtonCoordinates
            slot(xCoordinate, yCoordinate) {
                item = placeholderItem
            }
        }

        if(currentPage > 1) {
            renderBackButton(PaginationButtonType.BACK)
        } else {
            val (xCoordinate, yCoordinate) = backButtonCoordinates
            slot(xCoordinate, yCoordinate) {
                item = placeholderItem
            }
        }
    }
}

// CloseButtonProp.kt

/**
 * Render a close button prop in a [GUI.Slot].
 * @param lazyUICallback Lazily retrieve the [GUI] needed to render on close.
 */
fun GUI.Slot.closeButtonProp(lazyUICallback: (() -> GUI)? = null) {
    item = item(Material.BARRIER) {
        name = mm.deserialize("<red>Close")
    }

    onClick = {
        if(lazyUICallback == null) {
            it.closeInventory()
        } else {
            it.openGUI(lazyUICallback())
        }
    }
}

yptgdybu