package net.minecraft.gametest.framework;

import com.mojang.authlib.GameProfile;
import com.mojang.brigadier.exceptions.CommandSyntaxException;
import com.mojang.datafixers.util.Either;
import io.netty.channel.embedded.EmbeddedChannel;
import java.util.List;
import java.util.Objects;
import java.util.UUID;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.IntPredicate;
import java.util.function.Predicate;
import java.util.function.Supplier;
import java.util.stream.LongStream;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import net.minecraft.core.BlockPos;
import net.minecraft.core.Direction;
import net.minecraft.core.Holder;
import net.minecraft.core.registries.Registries;
import net.minecraft.network.Connection;
import net.minecraft.network.chat.Component;
import net.minecraft.network.protocol.PacketFlow;
import net.minecraft.resources.ResourceKey;
import net.minecraft.server.commands.FillBiomeCommand;
import net.minecraft.server.level.ServerLevel;
import net.minecraft.server.level.ServerPlayer;
import net.minecraft.server.network.CommonListenerCookie;
import net.minecraft.tags.BlockTags;
import net.minecraft.tags.TagKey;
import net.minecraft.world.InteractionHand;
import net.minecraft.world.InteractionResult;
import net.minecraft.world.damagesource.DamageSource;
import net.minecraft.world.effect.MobEffect;
import net.minecraft.world.effect.MobEffectInstance;
import net.minecraft.world.entity.Entity;
import net.minecraft.world.entity.EntitySpawnReason;
import net.minecraft.world.entity.EntityType;
import net.minecraft.world.entity.LivingEntity;
import net.minecraft.world.entity.Mob;
import net.minecraft.world.entity.item.ItemEntity;
import net.minecraft.world.entity.npc.InventoryCarrier;
import net.minecraft.world.entity.player.Player;
import net.minecraft.world.item.Item;
import net.minecraft.world.item.ItemStack;
import net.minecraft.world.item.alchemy.PotionContents;
import net.minecraft.world.item.context.UseOnContext;
import net.minecraft.world.level.GameType;
import net.minecraft.world.level.biome.Biome;
import net.minecraft.world.level.block.Block;
import net.minecraft.world.level.block.Blocks;
import net.minecraft.world.level.block.ButtonBlock;
import net.minecraft.world.level.block.LeverBlock;
import net.minecraft.world.level.block.Mirror;
import net.minecraft.world.level.block.Rotation;
import net.minecraft.world.level.block.entity.BaseContainerBlockEntity;
import net.minecraft.world.level.block.entity.BlockEntity;
import net.minecraft.world.level.block.state.BlockState;
import net.minecraft.world.level.block.state.properties.Property;
import net.minecraft.world.level.levelgen.Heightmap;
import net.minecraft.world.level.levelgen.structure.BoundingBox;
import net.minecraft.world.level.levelgen.structure.templatesystem.StructureTemplate;
import net.minecraft.world.level.pathfinder.Path;
import net.minecraft.world.phys.AABB;
import net.minecraft.world.phys.BlockHitResult;
import net.minecraft.world.phys.Vec3;

public class GameTestHelper {
    private final GameTestInfo testInfo;
    private boolean finalCheckAdded;

    public GameTestHelper(GameTestInfo p_127597_) {
        this.testInfo = p_127597_;
    }

    public GameTestAssertException assertionException(Component p_396338_) {
        return new GameTestAssertException(p_396338_, this.testInfo.getTick());
    }

    public GameTestAssertException assertionException(String p_391256_, Object... p_396991_) {
        return this.assertionException(Component.translatableEscape(p_391256_, p_396991_));
    }

    public GameTestAssertPosException assertionException(BlockPos p_397296_, Component p_395659_) {
        return new GameTestAssertPosException(p_395659_, this.absolutePos(p_397296_), p_397296_, this.testInfo.getTick());
    }

    public GameTestAssertPosException assertionException(BlockPos p_395825_, String p_391999_, Object... p_394029_) {
        return this.assertionException(p_395825_, Component.translatableEscape(p_391999_, p_394029_));
    }

    public ServerLevel getLevel() {
        return this.testInfo.getLevel();
    }

    public BlockState getBlockState(BlockPos p_177233_) {
        return this.getLevel().getBlockState(this.absolutePos(p_177233_));
    }

    public <T extends BlockEntity> T getBlockEntity(BlockPos p_177348_, Class<T> p_395786_) {
        BlockEntity blockentity = this.getLevel().getBlockEntity(this.absolutePos(p_177348_));
        if (blockentity == null) {
            throw this.assertionException(p_177348_, "test.error.missing_block_entity");
        } else if (p_395786_.isInstance(blockentity)) {
            return p_395786_.cast(blockentity);
        } else {
            throw this.assertionException(p_177348_, "test.error.wrong_block_entity", blockentity.getType().builtInRegistryHolder().getRegisteredName());
        }
    }

    public void killAllEntities() {
        this.killAllEntitiesOfClass(Entity.class);
    }

    public void killAllEntitiesOfClass(Class<? extends Entity> p_289538_) {
        AABB aabb = this.getBounds();
        List<? extends Entity> list = this.getLevel().getEntitiesOfClass(p_289538_, aabb.inflate(1.0), p_177131_ -> !(p_177131_ instanceof Player));
        list.forEach(p_358470_ -> p_358470_.kill(this.getLevel()));
    }

    public ItemEntity spawnItem(Item p_329778_, Vec3 p_334689_) {
        ServerLevel serverlevel = this.getLevel();
        Vec3 vec3 = this.absoluteVec(p_334689_);
        ItemEntity itementity = new ItemEntity(serverlevel, vec3.x, vec3.y, vec3.z, new ItemStack(p_329778_, 1));
        itementity.setDeltaMovement(0.0, 0.0, 0.0);
        serverlevel.addFreshEntity(itementity);
        return itementity;
    }

    public ItemEntity spawnItem(Item p_177190_, float p_177191_, float p_177192_, float p_177193_) {
        return this.spawnItem(p_177190_, new Vec3(p_177191_, p_177192_, p_177193_));
    }

    public ItemEntity spawnItem(Item p_251435_, BlockPos p_250287_) {
        return this.spawnItem(p_251435_, p_250287_.getX(), p_250287_.getY(), p_250287_.getZ());
    }

    public <E extends Entity> E spawn(EntityType<E> p_177177_, BlockPos p_177178_) {
        return this.spawn(p_177177_, Vec3.atBottomCenterOf(p_177178_));
    }

    public <E extends Entity> E spawn(EntityType<E> p_177174_, Vec3 p_177175_) {
        ServerLevel serverlevel = this.getLevel();
        E e = p_177174_.create(serverlevel, EntitySpawnReason.STRUCTURE);
        if (e == null) {
            throw this.assertionException(BlockPos.containing(p_177175_), "test.error.spawn_failure", p_177174_.builtInRegistryHolder().getRegisteredName());
        } else {
            if (e instanceof Mob mob) {
                mob.setPersistenceRequired();
            }

            Vec3 vec3 = this.absoluteVec(p_177175_);
            e.snapTo(vec3.x, vec3.y, vec3.z, e.getYRot(), e.getXRot());
            serverlevel.addFreshEntity(e);
            return e;
        }
    }

    public void hurt(Entity p_369429_, DamageSource p_367525_, float p_361355_) {
        p_369429_.hurtServer(this.getLevel(), p_367525_, p_361355_);
    }

    public void kill(Entity p_364190_) {
        p_364190_.kill(this.getLevel());
    }

    public <E extends Entity> E findOneEntity(EntityType<E> p_333077_) {
        return this.findClosestEntity(p_333077_, 0, 0, 0, 2.147483647E9);
    }

    public <E extends Entity> E findClosestEntity(EntityType<E> p_335109_, int p_329434_, int p_334603_, int p_333149_, double p_331586_) {
        List<E> list = this.findEntities(p_335109_, p_329434_, p_334603_, p_333149_, p_331586_);
        if (list.isEmpty()) {
            throw this.assertionException("test.error.expected_entity_around", p_335109_.getDescription(), p_329434_, p_334603_, p_333149_);
        } else if (list.size() > 1) {
            throw this.assertionException("test.error.too_many_entities", p_335109_.toShortString(), p_329434_, p_334603_, p_333149_, list.size());
        } else {
            Vec3 vec3 = this.absoluteVec(new Vec3(p_329434_, p_334603_, p_333149_));
            list.sort((p_325933_, p_325934_) -> {
                double d0 = p_325933_.position().distanceTo(vec3);
                double d1 = p_325934_.position().distanceTo(vec3);
                return Double.compare(d0, d1);
            });
            return list.get(0);
        }
    }

    public <E extends Entity> List<E> findEntities(EntityType<E> p_327745_, int p_330471_, int p_329385_, int p_328777_, double p_336258_) {
        return this.findEntities(p_327745_, Vec3.atBottomCenterOf(new BlockPos(p_330471_, p_329385_, p_328777_)), p_336258_);
    }

    public <E extends Entity> List<E> findEntities(EntityType<E> p_327849_, Vec3 p_331515_, double p_330795_) {
        ServerLevel serverlevel = this.getLevel();
        Vec3 vec3 = this.absoluteVec(p_331515_);
        AABB aabb = this.testInfo.getStructureBounds();
        AABB aabb1 = new AABB(vec3.add(-p_330795_, -p_330795_, -p_330795_), vec3.add(p_330795_, p_330795_, p_330795_));
        return serverlevel.getEntities(p_327849_, aabb, p_325936_ -> p_325936_.getBoundingBox().intersects(aabb1) && p_325936_.isAlive());
    }

    public <E extends Entity> E spawn(EntityType<E> p_177169_, int p_177170_, int p_177171_, int p_177172_) {
        return this.spawn(p_177169_, new BlockPos(p_177170_, p_177171_, p_177172_));
    }

    public <E extends Entity> E spawn(EntityType<E> p_177164_, float p_177165_, float p_177166_, float p_177167_) {
        return this.spawn(p_177164_, new Vec3(p_177165_, p_177166_, p_177167_));
    }

    public <E extends Mob> E spawnWithNoFreeWill(EntityType<E> p_177330_, BlockPos p_177331_) {
        E e = (E)this.spawn(p_177330_, p_177331_);
        e.removeFreeWill();
        return e;
    }

    public <E extends Mob> E spawnWithNoFreeWill(EntityType<E> p_177322_, int p_177323_, int p_177324_, int p_177325_) {
        return this.spawnWithNoFreeWill(p_177322_, new BlockPos(p_177323_, p_177324_, p_177325_));
    }

    public <E extends Mob> E spawnWithNoFreeWill(EntityType<E> p_177327_, Vec3 p_177328_) {
        E e = (E)this.spawn(p_177327_, p_177328_);
        e.removeFreeWill();
        return e;
    }

    public <E extends Mob> E spawnWithNoFreeWill(EntityType<E> p_177317_, float p_177318_, float p_177319_, float p_177320_) {
        return this.spawnWithNoFreeWill(p_177317_, new Vec3(p_177318_, p_177319_, p_177320_));
    }

    public void moveTo(Mob p_335410_, float p_330841_, float p_334132_, float p_332530_) {
        Vec3 vec3 = this.absoluteVec(new Vec3(p_330841_, p_334132_, p_332530_));
        p_335410_.snapTo(vec3.x, vec3.y, vec3.z, p_335410_.getYRot(), p_335410_.getXRot());
    }

    public GameTestSequence walkTo(Mob p_177186_, BlockPos p_177187_, float p_177188_) {
        return this.startSequence().thenExecuteAfter(2, () -> {
            Path path = p_177186_.getNavigation().createPath(this.absolutePos(p_177187_), 0);
            p_177186_.getNavigation().moveTo(path, p_177188_);
        });
    }

    public void pressButton(int p_177104_, int p_177105_, int p_177106_) {
        this.pressButton(new BlockPos(p_177104_, p_177105_, p_177106_));
    }

    public void pressButton(BlockPos p_177386_) {
        this.assertBlockTag(BlockTags.BUTTONS, p_177386_);
        BlockPos blockpos = this.absolutePos(p_177386_);
        BlockState blockstate = this.getLevel().getBlockState(blockpos);
        ButtonBlock buttonblock = (ButtonBlock)blockstate.getBlock();
        buttonblock.press(blockstate, this.getLevel(), blockpos, null);
    }

    public void useBlock(BlockPos p_177409_) {
        this.useBlock(p_177409_, this.makeMockPlayer(GameType.CREATIVE));
    }

    public void useBlock(BlockPos p_250131_, Player p_251507_) {
        BlockPos blockpos = this.absolutePos(p_250131_);
        this.useBlock(p_250131_, p_251507_, new BlockHitResult(Vec3.atCenterOf(blockpos), Direction.NORTH, blockpos, true));
    }

    public void useBlock(BlockPos p_262023_, Player p_261901_, BlockHitResult p_262040_) {
        BlockPos blockpos = this.absolutePos(p_262023_);
        BlockState blockstate = this.getLevel().getBlockState(blockpos);
        InteractionHand interactionhand = InteractionHand.MAIN_HAND;
        InteractionResult interactionresult = blockstate.useItemOn(p_261901_.getItemInHand(interactionhand), this.getLevel(), p_261901_, interactionhand, p_262040_);
        if (!interactionresult.consumesAction()) {
            if (!(interactionresult instanceof InteractionResult.TryEmptyHandInteraction)
                || !blockstate.useWithoutItem(this.getLevel(), p_261901_, p_262040_).consumesAction()) {
                UseOnContext useoncontext = new UseOnContext(p_261901_, interactionhand, p_262040_);
                p_261901_.getItemInHand(interactionhand).useOn(useoncontext);
            }
        }
    }

    public LivingEntity makeAboutToDrown(LivingEntity p_177184_) {
        p_177184_.setAirSupply(0);
        p_177184_.setHealth(0.25F);
        return p_177184_;
    }

    public LivingEntity withLowHealth(LivingEntity p_286794_) {
        p_286794_.setHealth(0.25F);
        return p_286794_;
    }

    public Player makeMockPlayer(final GameType p_333981_) {
        return new Player(this.getLevel(), BlockPos.ZERO, 0.0F, new GameProfile(UUID.randomUUID(), "test-mock-player")) {
            @Nonnull
            @Override
            public GameType gameMode() {
                return p_333981_;
            }

            @Override
            public boolean isClientAuthoritative() {
                return false;
            }
        };
    }

    @Deprecated(
        forRemoval = true
    )
    public ServerPlayer makeMockServerPlayerInLevel() {
        CommonListenerCookie commonlistenercookie = CommonListenerCookie.createInitial(new GameProfile(UUID.randomUUID(), "test-mock-player"), false);
        ServerPlayer serverplayer = new ServerPlayer(
            this.getLevel().getServer(), this.getLevel(), commonlistenercookie.gameProfile(), commonlistenercookie.clientInformation()
        ) {
            @Override
            public GameType gameMode() {
                return GameType.CREATIVE;
            }
        };
        Connection connection = new Connection(PacketFlow.SERVERBOUND);
        new EmbeddedChannel(connection);
        this.getLevel().getServer().getPlayerList().placeNewPlayer(connection, serverplayer, commonlistenercookie);
        return serverplayer;
    }

    public void pullLever(int p_177303_, int p_177304_, int p_177305_) {
        this.pullLever(new BlockPos(p_177303_, p_177304_, p_177305_));
    }

    public void pullLever(BlockPos p_177422_) {
        this.assertBlockPresent(Blocks.LEVER, p_177422_);
        BlockPos blockpos = this.absolutePos(p_177422_);
        BlockState blockstate = this.getLevel().getBlockState(blockpos);
        LeverBlock leverblock = (LeverBlock)blockstate.getBlock();
        leverblock.pull(blockstate, this.getLevel(), blockpos, null);
    }

    public void pulseRedstone(BlockPos p_177235_, long p_177236_) {
        this.setBlock(p_177235_, Blocks.REDSTONE_BLOCK);
        this.runAfterDelay(p_177236_, () -> this.setBlock(p_177235_, Blocks.AIR));
    }

    public void destroyBlock(BlockPos p_177435_) {
        this.getLevel().destroyBlock(this.absolutePos(p_177435_), false, null);
    }

    public void setBlock(int p_177108_, int p_177109_, int p_177110_, Block p_177111_) {
        this.setBlock(new BlockPos(p_177108_, p_177109_, p_177110_), p_177111_);
    }

    public void setBlock(int p_177113_, int p_177114_, int p_177115_, BlockState p_177116_) {
        this.setBlock(new BlockPos(p_177113_, p_177114_, p_177115_), p_177116_);
    }

    public void setBlock(BlockPos p_177246_, Block p_177247_) {
        this.setBlock(p_177246_, p_177247_.defaultBlockState());
    }

    public void setBlock(BlockPos p_177253_, BlockState p_177254_) {
        this.getLevel().setBlock(this.absolutePos(p_177253_), p_177254_, 3);
    }

    public void setNight() {
        this.setDayTime(13000);
    }

    public void setDayTime(int p_177102_) {
        this.getLevel().setDayTime(p_177102_);
    }

    public void assertBlockPresent(Block p_177204_, int p_177205_, int p_177206_, int p_177207_) {
        this.assertBlockPresent(p_177204_, new BlockPos(p_177205_, p_177206_, p_177207_));
    }

    public void assertBlockPresent(Block p_177209_, BlockPos p_177210_) {
        BlockState blockstate = this.getBlockState(p_177210_);
        this.assertBlock(
            p_177210_,
            p_177216_ -> blockstate.is(p_177209_),
            p_389750_ -> Component.translatable("test.error.expected_block", p_177209_.getName(), p_389750_.getName())
        );
    }

    public void assertBlockNotPresent(Block p_177337_, int p_177338_, int p_177339_, int p_177340_) {
        this.assertBlockNotPresent(p_177337_, new BlockPos(p_177338_, p_177339_, p_177340_));
    }

    public void assertBlockNotPresent(Block p_177342_, BlockPos p_177343_) {
        this.assertBlock(
            p_177343_,
            p_177251_ -> !this.getBlockState(p_177343_).is(p_177342_),
            p_389752_ -> Component.translatable("test.error.unexpected_block", p_177342_.getName())
        );
    }

    public void assertBlockTag(TagKey<Block> p_395167_, BlockPos p_394420_) {
        this.assertBlockState(
            p_394420_,
            p_389762_ -> p_389762_.is(p_395167_),
            p_389754_ -> Component.translatable("test.error.expected_block_tag", p_395167_.location(), p_389754_.getBlock().getName())
        );
    }

    public void succeedWhenBlockPresent(Block p_177378_, int p_177379_, int p_177380_, int p_177381_) {
        this.succeedWhenBlockPresent(p_177378_, new BlockPos(p_177379_, p_177380_, p_177381_));
    }

    public void succeedWhenBlockPresent(Block p_177383_, BlockPos p_177384_) {
        this.succeedWhen(() -> this.assertBlockPresent(p_177383_, p_177384_));
    }

    public void assertBlock(BlockPos p_177272_, Predicate<Block> p_177273_, Function<Block, Component> p_395351_) {
        this.assertBlockState(p_177272_, p_177296_ -> p_177273_.test(p_177296_.getBlock()), p_389756_ -> p_395351_.apply(p_389756_.getBlock()));
    }

    public <T extends Comparable<T>> void assertBlockProperty(BlockPos p_177256_, Property<T> p_177257_, T p_177258_) {
        BlockState blockstate = this.getBlockState(p_177256_);
        boolean flag = blockstate.hasProperty(p_177257_);
        if (!flag) {
            throw this.assertionException(p_177256_, "test.error.block_property_missing", p_177257_.getName(), p_177258_);
        } else if (!blockstate.<T>getValue(p_177257_).equals(p_177258_)) {
            throw this.assertionException(p_177256_, "test.error.block_property_mismatch", p_177257_.getName(), p_177258_, blockstate.getValue(p_177257_));
        }
    }

    public <T extends Comparable<T>> void assertBlockProperty(BlockPos p_177260_, Property<T> p_177261_, Predicate<T> p_177262_, Component p_393167_) {
        this.assertBlockState(p_177260_, p_277264_ -> {
            if (!p_277264_.hasProperty(p_177261_)) {
                return false;
            } else {
                T t = p_277264_.getValue(p_177261_);
                return p_177262_.test(t);
            }
        }, p_397227_ -> p_393167_);
    }

    public void assertBlockState(BlockPos p_396349_, BlockState p_394832_) {
        BlockState blockstate = this.getBlockState(p_396349_);
        if (!blockstate.equals(p_394832_)) {
            throw this.assertionException(p_396349_, "test.error.state_not_equal", p_394832_, blockstate);
        }
    }

    public void assertBlockState(BlockPos p_177358_, Predicate<BlockState> p_177359_, Function<BlockState, Component> p_392520_) {
        BlockState blockstate = this.getBlockState(p_177358_);
        if (!p_177359_.test(blockstate)) {
            throw this.assertionException(p_177358_, p_392520_.apply(blockstate));
        }
    }

    public <T extends BlockEntity> void assertBlockEntityData(BlockPos p_345406_, Class<T> p_391986_, Predicate<T> p_342583_, Supplier<Component> p_343096_) {
        T t = this.getBlockEntity(p_345406_, p_391986_);
        if (!p_342583_.test(t)) {
            throw this.assertionException(p_345406_, p_343096_.get());
        }
    }

    public void assertRedstoneSignal(BlockPos p_289644_, Direction p_289642_, IntPredicate p_289645_, Supplier<Component> p_289684_) {
        BlockPos blockpos = this.absolutePos(p_289644_);
        ServerLevel serverlevel = this.getLevel();
        BlockState blockstate = serverlevel.getBlockState(blockpos);
        int i = blockstate.getSignal(serverlevel, blockpos, p_289642_);
        if (!p_289645_.test(i)) {
            throw this.assertionException(p_289644_, p_289684_.get());
        }
    }

    public void assertEntityPresent(EntityType<?> p_177157_) {
        List<? extends Entity> list = this.getLevel().getEntities(p_177157_, this.getBounds(), Entity::isAlive);
        if (list.isEmpty()) {
            throw this.assertionException("test.error.expected_entity_in_test", p_177157_.getDescription());
        }
    }

    public void assertEntityPresent(EntityType<?> p_177370_, int p_177371_, int p_177372_, int p_177373_) {
        this.assertEntityPresent(p_177370_, new BlockPos(p_177371_, p_177372_, p_177373_));
    }

    public void assertEntityPresent(EntityType<?> p_177375_, BlockPos p_177376_) {
        BlockPos blockpos = this.absolutePos(p_177376_);
        List<? extends Entity> list = this.getLevel().getEntities(p_177375_, new AABB(blockpos), Entity::isAlive);
        if (list.isEmpty()) {
            throw this.assertionException(p_177376_, "test.error.expected_entity", p_177375_.getDescription());
        }
    }

    public void assertEntityPresent(EntityType<?> p_252010_, AABB p_367168_) {
        AABB aabb = this.absoluteAABB(p_367168_);
        List<? extends Entity> list = this.getLevel().getEntities(p_252010_, aabb, Entity::isAlive);
        if (list.isEmpty()) {
            throw this.assertionException(BlockPos.containing(p_367168_.getCenter()), "test.error.expected_entity", p_252010_.getDescription());
        }
    }

    public void assertEntitiesPresent(EntityType<?> p_313026_, int p_310037_) {
        List<? extends Entity> list = this.getLevel().getEntities(p_313026_, this.getBounds(), Entity::isAlive);
        if (list.size() != p_310037_) {
            throw this.assertionException("test.error.expected_entity_count", p_310037_, p_313026_.getDescription(), list.size());
        }
    }

    public void assertEntitiesPresent(EntityType<?> p_239372_, BlockPos p_239373_, int p_239374_, double p_239375_) {
        BlockPos blockpos = this.absolutePos(p_239373_);
        List<? extends Entity> list = this.getEntities((EntityType<? extends Entity>)p_239372_, p_239373_, p_239375_);
        if (list.size() != p_239374_) {
            throw this.assertionException(p_239373_, "test.error.expected_entity_count", p_239374_, p_239372_.getDescription(), list.size());
        }
    }

    public void assertEntityPresent(EntityType<?> p_177180_, BlockPos p_177181_, double p_177182_) {
        List<? extends Entity> list = this.getEntities((EntityType<? extends Entity>)p_177180_, p_177181_, p_177182_);
        if (list.isEmpty()) {
            BlockPos blockpos = this.absolutePos(p_177181_);
            throw this.assertionException(p_177181_, "test.error.expected_entity", p_177180_.getDescription());
        }
    }

    public <T extends Entity> List<T> getEntities(EntityType<T> p_238400_, BlockPos p_238401_, double p_238402_) {
        BlockPos blockpos = this.absolutePos(p_238401_);
        return this.getLevel().getEntities(p_238400_, new AABB(blockpos).inflate(p_238402_), Entity::isAlive);
    }

    public <T extends Entity> List<T> getEntities(EntityType<T> p_330219_) {
        return this.getLevel().getEntities(p_330219_, this.getBounds(), Entity::isAlive);
    }

    public void assertEntityInstancePresent(Entity p_177133_, int p_177134_, int p_177135_, int p_177136_) {
        this.assertEntityInstancePresent(p_177133_, new BlockPos(p_177134_, p_177135_, p_177136_));
    }

    public void assertEntityInstancePresent(Entity p_177141_, BlockPos p_177142_) {
        BlockPos blockpos = this.absolutePos(p_177142_);
        List<? extends Entity> list = this.getLevel().getEntities(p_177141_.getType(), new AABB(blockpos), Entity::isAlive);
        list.stream()
            .filter(p_177139_ -> p_177139_ == p_177141_)
            .findFirst()
            .orElseThrow(() -> this.assertionException(p_177142_, "test.error.expected_entity", p_177141_.getType().getDescription()));
    }

    public void assertItemEntityCountIs(Item p_177199_, BlockPos p_177200_, double p_177201_, int p_177202_) {
        BlockPos blockpos = this.absolutePos(p_177200_);
        List<ItemEntity> list = this.getLevel().getEntities(EntityType.ITEM, new AABB(blockpos).inflate(p_177201_), Entity::isAlive);
        int i = 0;

        for (ItemEntity itementity : list) {
            ItemStack itemstack = itementity.getItem();
            if (itemstack.is(p_177199_)) {
                i += itemstack.getCount();
            }
        }

        if (i != p_177202_) {
            throw this.assertionException(p_177200_, "test.error.expected_items_count", p_177202_, p_177199_.getName(), i);
        }
    }

    public void assertItemEntityPresent(Item p_177195_, BlockPos p_177196_, double p_177197_) {
        BlockPos blockpos = this.absolutePos(p_177196_);

        for (Entity entity : this.getLevel().getEntities(EntityType.ITEM, new AABB(blockpos).inflate(p_177197_), Entity::isAlive)) {
            ItemEntity itementity = (ItemEntity)entity;
            if (itementity.getItem().getItem().equals(p_177195_)) {
                return;
            }
        }

        throw this.assertionException(p_177196_, "test.error.expected_item", p_177195_.getName());
    }

    public void assertItemEntityNotPresent(Item p_236779_, BlockPos p_236780_, double p_236781_) {
        BlockPos blockpos = this.absolutePos(p_236780_);

        for (Entity entity : this.getLevel().getEntities(EntityType.ITEM, new AABB(blockpos).inflate(p_236781_), Entity::isAlive)) {
            ItemEntity itementity = (ItemEntity)entity;
            if (itementity.getItem().getItem().equals(p_236779_)) {
                throw this.assertionException(p_236780_, "test.error.unexpected_item", p_236779_.getName());
            }
        }
    }

    public void assertItemEntityPresent(Item p_310630_) {
        for (Entity entity : this.getLevel().getEntities(EntityType.ITEM, this.getBounds(), Entity::isAlive)) {
            ItemEntity itementity = (ItemEntity)entity;
            if (itementity.getItem().getItem().equals(p_310630_)) {
                return;
            }
        }

        throw this.assertionException("test.error.expected_item", p_310630_.getName());
    }

    public void assertItemEntityNotPresent(Item p_312600_) {
        for (Entity entity : this.getLevel().getEntities(EntityType.ITEM, this.getBounds(), Entity::isAlive)) {
            ItemEntity itementity = (ItemEntity)entity;
            if (itementity.getItem().getItem().equals(p_312600_)) {
                throw this.assertionException("test.error.unexpected_item", p_312600_.getName());
            }
        }
    }

    public void assertEntityNotPresent(EntityType<?> p_177310_) {
        List<? extends Entity> list = this.getLevel().getEntities(p_177310_, this.getBounds(), Entity::isAlive);
        if (!list.isEmpty()) {
            throw this.assertionException(list.getFirst().blockPosition(), "test.error.unexpected_entity", p_177310_.getDescription());
        }
    }

    public void assertEntityNotPresent(EntityType<?> p_177398_, int p_177399_, int p_177400_, int p_177401_) {
        this.assertEntityNotPresent(p_177398_, new BlockPos(p_177399_, p_177400_, p_177401_));
    }

    public void assertEntityNotPresent(EntityType<?> p_177403_, BlockPos p_177404_) {
        BlockPos blockpos = this.absolutePos(p_177404_);
        List<? extends Entity> list = this.getLevel().getEntities(p_177403_, new AABB(blockpos), Entity::isAlive);
        if (!list.isEmpty()) {
            throw this.assertionException(p_177404_, "test.error.unexpected_entity", p_177403_.getDescription());
        }
    }

    public void assertEntityNotPresent(EntityType<?> p_328558_, AABB p_361757_) {
        AABB aabb = this.absoluteAABB(p_361757_);
        List<? extends Entity> list = this.getLevel().getEntities(p_328558_, aabb, Entity::isAlive);
        if (!list.isEmpty()) {
            throw this.assertionException(list.getFirst().blockPosition(), "test.error.unexpected_entity", p_328558_.getDescription());
        }
    }

    public void assertEntityTouching(EntityType<?> p_177159_, double p_177160_, double p_177161_, double p_177162_) {
        Vec3 vec3 = new Vec3(p_177160_, p_177161_, p_177162_);
        Vec3 vec31 = this.absoluteVec(vec3);
        Predicate<? super Entity> predicate = p_177346_ -> p_177346_.getBoundingBox().intersects(vec31, vec31);
        List<? extends Entity> list = this.getLevel().getEntities(p_177159_, this.getBounds(), predicate);
        if (list.isEmpty()) {
            throw this.assertionException(
                "test.error.expected_entity_touching", p_177159_.getDescription(), vec31.x(), vec31.y(), vec31.z(), p_177160_, p_177161_, p_177162_
            );
        }
    }

    public void assertEntityNotTouching(EntityType<?> p_177312_, double p_177313_, double p_177314_, double p_177315_) {
        Vec3 vec3 = new Vec3(p_177313_, p_177314_, p_177315_);
        Vec3 vec31 = this.absoluteVec(vec3);
        Predicate<? super Entity> predicate = p_177231_ -> !p_177231_.getBoundingBox().intersects(vec31, vec31);
        List<? extends Entity> list = this.getLevel().getEntities(p_177312_, this.getBounds(), predicate);
        if (list.isEmpty()) {
            throw this.assertionException(
                "test.error.expected_entity_not_touching",
                p_177312_.getDescription(),
                vec31.x(),
                vec31.y(),
                vec31.z(),
                p_177313_,
                p_177314_,
                p_177315_
            );
        }
    }

    public <E extends Entity, T> void assertEntityData(BlockPos p_362770_, EntityType<E> p_363965_, Predicate<E> p_367551_) {
        BlockPos blockpos = this.absolutePos(p_362770_);
        List<E> list = this.getLevel().getEntities(p_363965_, new AABB(blockpos), Entity::isAlive);
        if (list.isEmpty()) {
            throw this.assertionException(p_362770_, "test.error.expected_entity", p_363965_.getDescription());
        } else {
            for (E e : list) {
                if (!p_367551_.test(e)) {
                    throw this.assertionException(e.blockPosition(), "test.error.expected_entity_data_predicate", e.getName());
                }
            }
        }
    }

    public <E extends Entity, T> void assertEntityData(BlockPos p_177238_, EntityType<E> p_177239_, Function<? super E, T> p_177240_, @Nullable T p_177241_) {
        BlockPos blockpos = this.absolutePos(p_177238_);
        List<E> list = this.getLevel().getEntities(p_177239_, new AABB(blockpos), Entity::isAlive);
        if (list.isEmpty()) {
            throw this.assertionException(p_177238_, "test.error.expected_entity", p_177239_.getDescription());
        } else {
            for (E e : list) {
                T t = p_177240_.apply(e);
                if (!Objects.equals(t, p_177241_)) {
                    throw this.assertionException(p_177238_, "test.error.expected_entity_data", p_177241_, t);
                }
            }
        }
    }

    public <E extends LivingEntity> void assertEntityIsHolding(BlockPos p_263501_, EntityType<E> p_263510_, Item p_263517_) {
        BlockPos blockpos = this.absolutePos(p_263501_);
        List<E> list = this.getLevel().getEntities(p_263510_, new AABB(blockpos), Entity::isAlive);
        if (list.isEmpty()) {
            throw this.assertionException(p_263501_, "test.error.expected_entity", p_263510_.getDescription());
        } else {
            for (E e : list) {
                if (e.isHolding(p_263517_)) {
                    return;
                }
            }

            throw this.assertionException(p_263501_, "test.error.expected_entity_holding", p_263517_.getName());
        }
    }

    public <E extends Entity & InventoryCarrier> void assertEntityInventoryContains(BlockPos p_263495_, EntityType<E> p_263521_, Item p_263502_) {
        BlockPos blockpos = this.absolutePos(p_263495_);
        List<E> list = this.getLevel().getEntities(p_263521_, new AABB(blockpos), p_263479_ -> p_263479_.isAlive());
        if (list.isEmpty()) {
            throw this.assertionException(p_263495_, "test.error.expected_entity", p_263521_.getDescription());
        } else {
            for (E e : list) {
                if (e.getInventory().hasAnyMatching(p_263481_ -> p_263481_.is(p_263502_))) {
                    return;
                }
            }

            throw this.assertionException(p_263495_, "test.error.expected_entity_having", p_263502_.getName());
        }
    }

    public void assertContainerEmpty(BlockPos p_177441_) {
        BaseContainerBlockEntity basecontainerblockentity = this.getBlockEntity(p_177441_, BaseContainerBlockEntity.class);
        if (!basecontainerblockentity.isEmpty()) {
            throw this.assertionException(p_177441_, "test.error.expected_empty_container");
        }
    }

    public void assertContainerContainsSingle(BlockPos p_393278_, Item p_397233_) {
        BaseContainerBlockEntity basecontainerblockentity = this.getBlockEntity(p_393278_, BaseContainerBlockEntity.class);
        if (basecontainerblockentity.countItem(p_397233_) != 1) {
            throw this.assertionException(p_393278_, "test.error.expected_container_contents_single", p_397233_.getName());
        }
    }

    public void assertContainerContains(BlockPos p_177243_, Item p_177244_) {
        BaseContainerBlockEntity basecontainerblockentity = this.getBlockEntity(p_177243_, BaseContainerBlockEntity.class);
        if (basecontainerblockentity.countItem(p_177244_) == 0) {
            throw this.assertionException(p_177243_, "test.error.expected_container_contents", p_177244_.getName());
        }
    }

    public void assertSameBlockStates(BoundingBox p_177225_, BlockPos p_177226_) {
        BlockPos.betweenClosedStream(p_177225_)
            .forEach(
                p_177267_ -> {
                    BlockPos blockpos = p_177226_.offset(
                        p_177267_.getX() - p_177225_.minX(),
                        p_177267_.getY() - p_177225_.minY(),
                        p_177267_.getZ() - p_177225_.minZ()
                    );
                    this.assertSameBlockState(p_177267_, blockpos);
                }
            );
    }

    public void assertSameBlockState(BlockPos p_177269_, BlockPos p_177270_) {
        BlockState blockstate = this.getBlockState(p_177269_);
        BlockState blockstate1 = this.getBlockState(p_177270_);
        if (blockstate != blockstate1) {
            throw this.assertionException(p_177269_, "test.error.state_not_equal", blockstate1, blockstate);
        }
    }

    public void assertAtTickTimeContainerContains(long p_177124_, BlockPos p_177125_, Item p_177126_) {
        this.runAtTickTime(p_177124_, () -> this.assertContainerContainsSingle(p_177125_, p_177126_));
    }

    public void assertAtTickTimeContainerEmpty(long p_177121_, BlockPos p_177122_) {
        this.runAtTickTime(p_177121_, () -> this.assertContainerEmpty(p_177122_));
    }

    public <E extends Entity, T> void succeedWhenEntityData(BlockPos p_177350_, EntityType<E> p_177351_, Function<E, T> p_177352_, T p_177353_) {
        this.succeedWhen(() -> this.assertEntityData(p_177350_, p_177351_, p_177352_, p_177353_));
    }

    public void assertEntityPosition(Entity p_344935_, AABB p_345349_, Component p_393630_) {
        if (!p_345349_.contains(this.relativeVec(p_344935_.position()))) {
            throw this.assertionException(p_393630_);
        }
    }

    public <E extends Entity> void assertEntityProperty(E p_177148_, Predicate<E> p_393110_, Component p_397208_) {
        if (!p_393110_.test(p_177148_)) {
            throw this.assertionException(p_177148_.blockPosition(), "test.error.entity_property", p_177148_.getName(), p_397208_);
        }
    }

    public <E extends Entity, T> void assertEntityProperty(E p_177153_, Function<E, T> p_396986_, T p_393513_, Component p_392760_) {
        T t = p_396986_.apply(p_177153_);
        if (!t.equals(p_393513_)) {
            throw this.assertionException(p_177153_.blockPosition(), "test.error.entity_property_details", p_177153_.getName(), p_392760_, t, p_393513_);
        }
    }

    public void assertLivingEntityHasMobEffect(LivingEntity p_300128_, Holder<MobEffect> p_331754_, int p_298143_) {
        MobEffectInstance mobeffectinstance = p_300128_.getEffect(p_331754_);
        if (mobeffectinstance == null || mobeffectinstance.getAmplifier() != p_298143_) {
            throw this.assertionException("test.error.expected_entity_effect", p_300128_.getName(), PotionContents.getPotionDescription(p_331754_, p_298143_));
        }
    }

    public void succeedWhenEntityPresent(EntityType<?> p_177414_, int p_177415_, int p_177416_, int p_177417_) {
        this.succeedWhenEntityPresent(p_177414_, new BlockPos(p_177415_, p_177416_, p_177417_));
    }

    public void succeedWhenEntityPresent(EntityType<?> p_177419_, BlockPos p_177420_) {
        this.succeedWhen(() -> this.assertEntityPresent(p_177419_, p_177420_));
    }

    public void succeedWhenEntityNotPresent(EntityType<?> p_177427_, int p_177428_, int p_177429_, int p_177430_) {
        this.succeedWhenEntityNotPresent(p_177427_, new BlockPos(p_177428_, p_177429_, p_177430_));
    }

    public void succeedWhenEntityNotPresent(EntityType<?> p_177432_, BlockPos p_177433_) {
        this.succeedWhen(() -> this.assertEntityNotPresent(p_177432_, p_177433_));
    }

    public void succeed() {
        this.testInfo.succeed();
    }

    private void ensureSingleFinalCheck() {
        if (this.finalCheckAdded) {
            throw new IllegalStateException("This test already has final clause");
        } else {
            this.finalCheckAdded = true;
        }
    }

    public void succeedIf(Runnable p_177280_) {
        this.ensureSingleFinalCheck();
        this.testInfo.createSequence().thenWaitUntil(0L, p_177280_).thenSucceed();
    }

    public void succeedWhen(Runnable p_177362_) {
        this.ensureSingleFinalCheck();
        this.testInfo.createSequence().thenWaitUntil(p_177362_).thenSucceed();
    }

    public void succeedOnTickWhen(int p_177118_, Runnable p_177119_) {
        this.ensureSingleFinalCheck();
        this.testInfo.createSequence().thenWaitUntil(p_177118_, p_177119_).thenSucceed();
    }

    public void runAtTickTime(long p_177128_, Runnable p_177129_) {
        this.testInfo.setRunAtTickTime(p_177128_, p_177129_);
    }

    public void runAfterDelay(long p_177307_, Runnable p_177308_) {
        this.runAtTickTime(this.testInfo.getTick() + p_177307_, p_177308_);
    }

    public void randomTick(BlockPos p_177447_) {
        BlockPos blockpos = this.absolutePos(p_177447_);
        ServerLevel serverlevel = this.getLevel();
        serverlevel.getBlockState(blockpos).randomTick(serverlevel, blockpos, serverlevel.random);
    }

    public void tickBlock(BlockPos p_396550_) {
        BlockPos blockpos = this.absolutePos(p_396550_);
        ServerLevel serverlevel = this.getLevel();
        serverlevel.getBlockState(blockpos).tick(serverlevel, blockpos, serverlevel.random);
    }

    public void tickPrecipitation(BlockPos p_311105_) {
        BlockPos blockpos = this.absolutePos(p_311105_);
        ServerLevel serverlevel = this.getLevel();
        serverlevel.tickPrecipitation(blockpos);
    }

    public void tickPrecipitation() {
        AABB aabb = this.getRelativeBounds();
        int i = (int)Math.floor(aabb.maxX);
        int j = (int)Math.floor(aabb.maxZ);
        int k = (int)Math.floor(aabb.maxY);

        for (int l = (int)Math.floor(aabb.minX); l < i; l++) {
            for (int i1 = (int)Math.floor(aabb.minZ); i1 < j; i1++) {
                this.tickPrecipitation(new BlockPos(l, k, i1));
            }
        }
    }

    public int getHeight(Heightmap.Types p_236775_, int p_236776_, int p_236777_) {
        BlockPos blockpos = this.absolutePos(new BlockPos(p_236776_, 0, p_236777_));
        return this.relativePos(this.getLevel().getHeightmapPos(p_236775_, blockpos)).getY();
    }

    public void fail(Component p_397357_, BlockPos p_177291_) {
        throw this.assertionException(p_177291_, p_397357_);
    }

    public void fail(Component p_393216_, Entity p_177288_) {
        throw this.assertionException(p_177288_.blockPosition(), p_393216_);
    }

    public void fail(Component p_391587_) {
        throw this.assertionException(p_391587_);
    }

    public void failIf(Runnable p_177393_) {
        this.testInfo.createSequence().thenWaitUntil(p_177393_).thenFail(() -> this.assertionException("test.error.fail"));
    }

    public void failIfEver(Runnable p_177411_) {
        LongStream.range(this.testInfo.getTick(), this.testInfo.getTimeoutTicks()).forEach(p_177365_ -> this.testInfo.setRunAtTickTime(p_177365_, p_177411_::run));
    }

    public GameTestSequence startSequence() {
        return this.testInfo.createSequence();
    }

    public BlockPos absolutePos(BlockPos p_177450_) {
        BlockPos blockpos = this.testInfo.getTestOrigin();
        BlockPos blockpos1 = blockpos.offset(p_177450_);
        return StructureTemplate.transform(blockpos1, Mirror.NONE, this.testInfo.getRotation(), blockpos);
    }

    public BlockPos relativePos(BlockPos p_177453_) {
        BlockPos blockpos = this.testInfo.getTestOrigin();
        Rotation rotation = this.testInfo.getRotation().getRotated(Rotation.CLOCKWISE_180);
        BlockPos blockpos1 = StructureTemplate.transform(p_177453_, Mirror.NONE, rotation, blockpos);
        return blockpos1.subtract(blockpos);
    }

    public AABB absoluteAABB(AABB p_369302_) {
        Vec3 vec3 = this.absoluteVec(p_369302_.getMinPosition());
        Vec3 vec31 = this.absoluteVec(p_369302_.getMaxPosition());
        return new AABB(vec3, vec31);
    }

    public AABB relativeAABB(AABB p_369720_) {
        Vec3 vec3 = this.relativeVec(p_369720_.getMinPosition());
        Vec3 vec31 = this.relativeVec(p_369720_.getMaxPosition());
        return new AABB(vec3, vec31);
    }

    public Vec3 absoluteVec(Vec3 p_177228_) {
        Vec3 vec3 = Vec3.atLowerCornerOf(this.testInfo.getTestOrigin());
        return StructureTemplate.transform(vec3.add(p_177228_), Mirror.NONE, this.testInfo.getRotation(), this.testInfo.getTestOrigin());
    }

    public Vec3 relativeVec(Vec3 p_251543_) {
        Vec3 vec3 = Vec3.atLowerCornerOf(this.testInfo.getTestOrigin());
        return StructureTemplate.transform(p_251543_.subtract(vec3), Mirror.NONE, this.testInfo.getRotation(), this.testInfo.getTestOrigin());
    }

    public Rotation getTestRotation() {
        return this.testInfo.getRotation();
    }

    public void assertTrue(boolean p_249380_, Component p_393681_) {
        if (!p_249380_) {
            throw this.assertionException(p_393681_);
        }
    }

    public <N> void assertValueEqual(N p_328559_, N p_332683_, Component p_397042_) {
        if (!p_328559_.equals(p_332683_)) {
            throw this.assertionException("test.error.value_not_equal", p_397042_, p_328559_, p_332683_);
        }
    }

    public void assertFalse(boolean p_277974_, Component p_392338_) {
        this.assertTrue(!p_277974_, p_392338_);
    }

    public long getTick() {
        return this.testInfo.getTick();
    }

    public AABB getBounds() {
        return this.testInfo.getStructureBounds();
    }

    private AABB getRelativeBounds() {
        AABB aabb = this.testInfo.getStructureBounds();
        Rotation rotation = this.testInfo.getRotation();
        switch (rotation) {
            case COUNTERCLOCKWISE_90:
            case CLOCKWISE_90:
                return new AABB(0.0, 0.0, 0.0, aabb.getZsize(), aabb.getYsize(), aabb.getXsize());
            default:
                return new AABB(0.0, 0.0, 0.0, aabb.getXsize(), aabb.getYsize(), aabb.getZsize());
        }
    }

    public void forEveryBlockInStructure(Consumer<BlockPos> p_177293_) {
        AABB aabb = this.getRelativeBounds().contract(1.0, 1.0, 1.0);
        BlockPos.MutableBlockPos.betweenClosedStream(aabb).forEach(p_177293_);
    }

    public void onEachTick(Runnable p_177424_) {
        LongStream.range(this.testInfo.getTick(), this.testInfo.getTimeoutTicks()).forEach(p_177283_ -> this.testInfo.setRunAtTickTime(p_177283_, p_177424_::run));
    }

    public void placeAt(Player p_261595_, ItemStack p_262007_, BlockPos p_261973_, Direction p_262008_) {
        BlockPos blockpos = this.absolutePos(p_261973_.relative(p_262008_));
        BlockHitResult blockhitresult = new BlockHitResult(Vec3.atCenterOf(blockpos), p_262008_, blockpos, false);
        UseOnContext useoncontext = new UseOnContext(p_261595_, InteractionHand.MAIN_HAND, blockhitresult);
        p_262007_.useOn(useoncontext);
    }

    public void setBiome(ResourceKey<Biome> p_312755_) {
        AABB aabb = this.getBounds();
        BlockPos blockpos = BlockPos.containing(aabb.minX, aabb.minY, aabb.minZ);
        BlockPos blockpos1 = BlockPos.containing(aabb.maxX, aabb.maxY, aabb.maxZ);
        Either<Integer, CommandSyntaxException> either = FillBiomeCommand.fill(
            this.getLevel(), blockpos, blockpos1, this.getLevel().registryAccess().lookupOrThrow(Registries.BIOME).getOrThrow(p_312755_)
        );
        if (either.right().isPresent()) {
            throw this.assertionException("test.error.set_biome");
        }
    }
}