path: root/src/main/kotlin/gui/entity/FakeWorld.kt

package moe.nea.firmament.gui.entity

import com.mojang.datafixers.util.Pair
import com.mojang.serialization.Lifecycle
import java.util.*
import java.util.function.BooleanSupplier
import java.util.function.Consumer
import java.util.stream.Stream
import kotlin.jvm.optionals.getOrNull
import kotlin.streams.asSequence
import net.minecraft.block.Block
import net.minecraft.block.BlockState
import net.minecraft.component.type.MapIdComponent
import net.minecraft.entity.Entity
import net.minecraft.entity.player.PlayerEntity
import net.minecraft.fluid.Fluid
import net.minecraft.item.map.MapState
import net.minecraft.recipe.BrewingRecipeRegistry
import net.minecraft.recipe.Ingredient
import net.minecraft.recipe.RecipeManager
import net.minecraft.registry.BuiltinRegistries
import net.minecraft.registry.DynamicRegistryManager
import net.minecraft.registry.Registry
import net.minecraft.registry.RegistryKey
import net.minecraft.registry.RegistryKeys
import net.minecraft.registry.RegistryWrapper
import net.minecraft.registry.entry.RegistryEntry
import net.minecraft.registry.entry.RegistryEntryInfo
import net.minecraft.registry.entry.RegistryEntryList
import net.minecraft.registry.entry.RegistryEntryOwner
import net.minecraft.registry.tag.TagKey
import net.minecraft.resource.featuretoggle.FeatureFlags
import net.minecraft.resource.featuretoggle.FeatureSet
import net.minecraft.scoreboard.Scoreboard
import net.minecraft.sound.SoundCategory
import net.minecraft.sound.SoundEvent
import net.minecraft.util.Identifier
import net.minecraft.util.TypeFilter
import net.minecraft.util.function.LazyIterationConsumer
import net.minecraft.util.math.BlockPos
import net.minecraft.util.math.Box
import net.minecraft.util.math.ChunkPos
import net.minecraft.util.math.Direction
import net.minecraft.util.math.Vec3d
import net.minecraft.util.math.random.Random
import net.minecraft.util.profiler.DummyProfiler
import net.minecraft.world.BlockView
import net.minecraft.world.Difficulty
import net.minecraft.world.GameRules
import net.minecraft.world.MutableWorldProperties
import net.minecraft.world.World
import net.minecraft.world.biome.Biome
import net.minecraft.world.biome.BiomeKeys
import net.minecraft.world.chunk.Chunk
import net.minecraft.world.chunk.ChunkManager
import net.minecraft.world.chunk.ChunkStatus
import net.minecraft.world.chunk.EmptyChunk
import net.minecraft.world.chunk.light.LightingProvider
import net.minecraft.world.entity.EntityLookup
import net.minecraft.world.event.GameEvent
import net.minecraft.world.tick.OrderedTick
import net.minecraft.world.tick.QueryableTickScheduler
import net.minecraft.world.tick.TickManager

fun <T> makeRegistry(registryWrapper: RegistryWrapper.Impl<T>, key: RegistryKey<out Registry<T>>): Registry<T> {
    val inverseLookup = registryWrapper.streamEntries()
        .asSequence().map { it.value() to it.registryKey() }
        .toMap()
    val idLookup = registryWrapper.streamEntries()
        .asSequence()
        .map { it.registryKey() }
        .withIndex()
        .associate { it.value to it.index }
    val map = registryWrapper.streamEntries().asSequence().map { it.registryKey() to it.value() }.toMap(mutableMapOf())
    val inverseIdLookup = idLookup.asIterable().associate { (k, v) -> v to k }
    return object : Registry<T> {
        override fun get(key: RegistryKey<T>?): T? {
            return registryWrapper.getOptional(key).getOrNull()?.value()
        }

        override fun iterator(): MutableIterator<T> {
            return object : MutableIterator<T> {
                val iterator = registryWrapper.streamEntries().iterator()
                override fun hasNext(): Boolean {
                    return iterator.hasNext()
                }

                override fun next(): T {
                    return iterator.next().value()
                }

                override fun remove() {
                    TODO("Not yet implemented")
                }
            }
        }

        override fun getRawId(value: T?): Int {
            return idLookup[inverseLookup[value ?: return -1] ?: return -1] ?: return -1
        }

        override fun get(id: Identifier?): T? {
            return get(RegistryKey.of(key, id))
        }

        override fun get(index: Int): T? {
            return get(inverseIdLookup[index] ?: return null)
        }

        override fun size(): Int {
            return idLookup.size
        }

        override fun getKey(): RegistryKey<out Registry<T>> {
            return key
        }

        override fun getEntryInfo(key: RegistryKey<T>?): Optional<RegistryEntryInfo> {
            TODO("Not yet implemented")
        }

        override fun getLifecycle(): Lifecycle {
            return Lifecycle.stable()
        }

        override fun getDefaultEntry(): Optional<RegistryEntry.Reference<T>> {
            return Optional.empty()
        }

        override fun getIds(): MutableSet<Identifier> {
            return idLookup.keys.mapTo(mutableSetOf()) { it.value }
        }

        override fun getEntrySet(): MutableSet<MutableMap.MutableEntry<RegistryKey<T>, T>> {
            return map.entries
        }

        override fun getKeys(): MutableSet<RegistryKey<T>> {
            return map.keys
        }

        override fun getRandom(random: Random?): Optional<RegistryEntry.Reference<T>> {
            return registryWrapper.streamEntries().findFirst()
        }

        override fun containsId(id: Identifier?): Boolean {
            return idLookup.containsKey(RegistryKey.of(key, id ?: return false))
        }

        override fun freeze(): Registry<T> {
            return this
        }

        override fun getEntry(rawId: Int): Optional<RegistryEntry.Reference<T>> {
            val x = inverseIdLookup[rawId] ?: return Optional.empty()
            return Optional.of(RegistryEntry.Reference.standAlone(registryWrapper, x))
        }

        override fun streamEntries(): Stream<RegistryEntry.Reference<T>> {
            return registryWrapper.streamEntries()
        }

        override fun streamTagsAndEntries(): Stream<Pair<TagKey<T>, RegistryEntryList.Named<T>>> {
            return streamTags().map { Pair(it, getOrCreateEntryList(it)) }
        }

        override fun streamTags(): Stream<TagKey<T>> {
            return registryWrapper.streamTagKeys()
        }

        override fun clearTags() {
        }

        override fun getEntryOwner(): RegistryEntryOwner<T> {
            return registryWrapper
        }

        override fun getReadOnlyWrapper(): RegistryWrapper.Impl<T> {
            return registryWrapper
        }

        override fun populateTags(tagEntries: MutableMap<TagKey<T>, MutableList<RegistryEntry<T>>>?) {
        }

        override fun getOrCreateEntryList(tag: TagKey<T>?): RegistryEntryList.Named<T> {
            return getEntryList(tag).orElseGet { RegistryEntryList.of(registryWrapper, tag) }
        }

        override fun getEntryList(tag: TagKey<T>?): Optional<RegistryEntryList.Named<T>> {
            return registryWrapper.getOptional(tag ?: return Optional.empty())
        }

        override fun getEntry(value: T): RegistryEntry<T> {
            return registryWrapper.getOptional(inverseLookup[value]!!).get()
        }

        override fun getEntry(key: RegistryKey<T>?): Optional<RegistryEntry.Reference<T>> {
            return registryWrapper.getOptional(key ?: return Optional.empty())
        }

        override fun getEntry(id: Identifier?)