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 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.InteractionResult.TryEmptyHandInteraction;
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;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;

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

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

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

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

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

	public GameTestAssertPosException assertionException(BlockPos pos, String messageKey, Object... args) {
		return this.assertionException(pos, Component.translatableEscape(messageKey, args));
	}

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

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

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

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

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

	public ItemEntity spawnItem(Item item, Vec3 pos) {
		ServerLevel serverLevel = this.getLevel();
		Vec3 vec3 = this.absoluteVec(pos);
		ItemEntity itemEntity = new ItemEntity(serverLevel, vec3.x, vec3.y, vec3.z, new ItemStack(item, 1));
		itemEntity.setDeltaMovement(0.0, 0.0, 0.0);
		serverLevel.addFreshEntity(itemEntity);
		return itemEntity;
	}

	public ItemEntity spawnItem(Item item, float x, float y, float z) {
		return this.spawnItem(item, new Vec3(x, y, z));
	}

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

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

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

			Vec3 vec3 = this.absoluteVec(pos);
			entity.snapTo(vec3.x, vec3.y, vec3.z, entity.getYRot(), entity.getXRot());
			serverLevel.addFreshEntity(entity);
			return entity;
		}
	}

	public void hurt(Entity entity, DamageSource damageSource, float amount) {
		entity.hurtServer(this.getLevel(), damageSource, amount);
	}

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

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

	public <E extends Entity> E findClosestEntity(EntityType<E> type, int x, int y, int z, double radius) {
		List<E> list = this.findEntities(type, x, y, z, radius);
		if (list.isEmpty()) {
			throw this.assertionException("test.error.expected_entity_around", type.getDescription(), x, y, z);
		} else if (list.size() > 1) {
			throw this.assertionException("test.error.too_many_entities", type.toShortString(), x, y, z, list.size());
		} else {
			Vec3 vec3 = this.absoluteVec(new Vec3(x, y, z));
			list.sort((entity, entity2) -> {
				double d = entity.position().distanceTo(vec3);
				double e = entity2.position().distanceTo(vec3);
				return Double.compare(d, e);
			});
			return (E)list.get(0);
		}
	}

	public <E extends Entity> List<E> findEntities(EntityType<E> type, int x, int y, int z, double radius) {
		return this.findEntities(type, Vec3.atBottomCenterOf(new BlockPos(x, y, z)), radius);
	}

	public <E extends Entity> List<E> findEntities(EntityType<E> type, Vec3 pos, double radius) {
		ServerLevel serverLevel = this.getLevel();
		Vec3 vec3 = this.absoluteVec(pos);
		AABB aABB = this.testInfo.getStructureBounds();
		AABB aABB2 = new AABB(vec3.add(-radius, -radius, -radius), vec3.add(radius, radius, radius));
		return serverLevel.getEntities(type, aABB, entity -> entity.getBoundingBox().intersects(aABB2) && entity.isAlive());
	}

	public <E extends Entity> E spawn(EntityType<E> type, int x, int y, int z) {
		return this.spawn(type, new BlockPos(x, y, z));
	}

	public <E extends Entity> E spawn(EntityType<E> type, float x, float y, float z) {
		return this.spawn(type, new Vec3(x, y, z));
	}

	public <E extends Mob> E spawnWithNoFreeWill(EntityType<E> type, BlockPos pos) {
		E mob = (E)this.spawn(type, pos);
		mob.removeFreeWill();
		return mob;
	}

	public <E extends Mob> E spawnWithNoFreeWill(EntityType<E> type, int x, int y, int z) {
		return this.spawnWithNoFreeWill(type, new BlockPos(x, y, z));
	}

	public <E extends Mob> E spawnWithNoFreeWill(EntityType<E> type, Vec3 pos) {
		E mob = (E)this.spawn(type, pos);
		mob.removeFreeWill();
		return mob;
	}

	public <E extends Mob> E spawnWithNoFreeWill(EntityType<E> type, float x, float y, float z) {
		return this.spawnWithNoFreeWill(type, new Vec3(x, y, z));
	}

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

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

	public void pressButton(int x, int y, int z) {
		this.pressButton(new BlockPos(x, y, z));
	}

	public void pressButton(BlockPos pos) {
		this.assertBlockTag(BlockTags.BUTTONS, pos);
		BlockPos blockPos = this.absolutePos(pos);
		BlockState blockState = this.getLevel().getBlockState(blockPos);
		ButtonBlock buttonBlock = (ButtonBlock)blockState.getBlock();
		buttonBlock.press(blockState, this.getLevel(), blockPos, null);
	}

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

	public void useBlock(BlockPos pos, Player player) {
		BlockPos blockPos = this.absolutePos(pos);
		this.useBlock(pos, player, new BlockHitResult(Vec3.atCenterOf(blockPos), Direction.NORTH, blockPos, true));
	}

	public void useBlock(BlockPos pos, Player player, BlockHitResult result) {
		BlockPos blockPos = this.absolutePos(pos);
		BlockState blockState = this.getLevel().getBlockState(blockPos);
		InteractionHand interactionHand = InteractionHand.MAIN_HAND;
		InteractionResult interactionResult = blockState.useItemOn(player.getItemInHand(interactionHand), this.getLevel(), player, interactionHand, result);
		if (!interactionResult.consumesAction()) {
			if (!(interactionResult instanceof TryEmptyHandInteraction) || !blockState.useWithoutItem(this.getLevel(), player, result).consumesAction()) {
				UseOnContext useOnContext = new UseOnContext(player, interactionHand, result);
				player.getItemInHand(interactionHand).useOn(useOnContext);
			}
		}
	}

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

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

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

			@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 x, int y, int z) {
		this.pullLever(new BlockPos(x, y, z));
	}

	public void pullLever(BlockPos pos) {
		this.assertBlockPresent(Blocks.LEVER, pos);
		BlockPos blockPos = this.absolutePos(pos);
		BlockState blockState = this.getLevel().getBlockState(blockPos);
		LeverBlock leverBlock = (LeverBlock)blockState.getBlock();
		leverBlock.pull(blockState, this.getLevel(), blockPos, null);
	}

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

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

	public void setBlock(int x, int y, int z, Block block) {
		this.setBlock(new BlockPos(x, y, z), block);
	}

	public void setBlock(int x, int y, int z, BlockState state) {
		this.setBlock(new BlockPos(x, y, z), state);
	}

	public void setBlock(BlockPos pos, Block block) {
		this.setBlock(pos, block.defaultBlockState());
	}

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

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

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

	public void assertBlockPresent(Block block, int x, int y, int z) {
		this.assertBlockPresent(block, new BlockPos(x, y, z));
	}

	public void assertBlockPresent(Block block, BlockPos pos) {
		BlockState blockState = this.getBlockState(pos);
		this.assertBlock(pos, block2 -> blockState.is(block), block2 -> Component.translatable("test.error.expected_block", block.getName(), block2.getName()));
	}

	public void assertBlockNotPresent(Block block, int x, int y, int z) {
		this.assertBlockNotPresent(block, new BlockPos(x, y, z));
	}

	public void assertBlockNotPresent(Block block, BlockPos pos) {
		this.assertBlock(pos, block2 -> !this.getBlockState(pos).is(block), block2 -> Component.translatable("test.error.unexpected_block", block.getName()));
	}

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

	public void succeedWhenBlockPresent(Block block, int x, int y, int z) {
		this.succeedWhenBlockPresent(block, new BlockPos(x, y, z));
	}

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

	public void assertBlock(BlockPos pos, Predicate<Block> predicate, Function<Block, Component> message) {
		this.assertBlockState(pos, blockState -> predicate.test(blockState.getBlock()), blockState -> (Component)message.apply(blockState.getBlock()));
	}

	public <T extends Comparable<T>> void assertBlockProperty(BlockPos pos, Property<T> property, T value) {
		BlockState blockState = this.getBlockState(pos);
		boolean bl = blockState.hasProperty(property);
		if (!bl) {
			throw this.assertionException(pos, "test.error.block_property_missing", property.getName(), value);
		} else if (!blockState.<T>getValue(property).equals(value)) {
			throw this.assertionException(pos, "test.error.block_property_mismatch", property.getName(), value, blockState.getValue(property));
		}
	}

	public <T extends Comparable<T>> void assertBlockProperty(BlockPos pos, Property<T> property, Predicate<T> predicate, Component message) {
		this.assertBlockState(pos, blockState -> {
			if (!blockState.hasProperty(property)) {
				return false;
			} else {
				T comparable = blockState.getValue(property);
				return predicate.test(comparable);
			}
		}, blockState -> message);
	}

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

	public void assertBlockState(BlockPos pos, Predicate<BlockState> predicate, Function<BlockState, Component> message) {
		BlockState blockState = this.getBlockState(pos);
		if (!predicate.test(blockState)) {
			throw this.assertionException(pos, (Component)message.apply(blockState));
		}
	}

	public <T extends BlockEntity> void assertBlockEntityData(BlockPos pos, Class<T> blockEntityClass, Predicate<T> predicate, Supplier<Component> message) {
		T blockEntity = this.getBlockEntity(pos, blockEntityClass);
		if (!predicate.test(blockEntity)) {
			throw this.assertionException(pos, (Component)message.get());
		}
	}

	public void assertRedstoneSignal(BlockPos pos, Direction direction, IntPredicate signalStrengthPredicate, Supplier<Component> message) {
		BlockPos blockPos = this.absolutePos(pos);
		ServerLevel serverLevel = this.getLevel();
		BlockState blockState = serverLevel.getBlockState(blockPos);
		int i = blockState.getSignal(serverLevel, blockPos, direction);
		if (!signalStrengthPredicate.test(i)) {
			throw this.assertionException(pos, (Component)message.get());
		}
	}

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

	public void assertEntityPresent(EntityType<?> type, int x, int y, int z) {
		this.assertEntityPresent(type, new BlockPos(x, y, z));
	}

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

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

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

	public void assertEntitiesPresent(EntityType<?> entityType, BlockPos pos, int count, double radius) {
		BlockPos blockPos = this.absolutePos(pos);
		List<? extends Entity> list = this.getEntities((EntityType<? extends Entity>)entityType, pos, radius);
		if (list.size() != count) {
			throw this.assertionException(pos, "test.error.expected_entity_count", count, entityType.getDescription(), list.size());
		}
	}

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

	public <T extends Entity> List<T> getEntities(EntityType<T> entityType, BlockPos pos, double radius) {
		BlockPos blockPos = this.absolutePos(pos);
		return this.getLevel().getEntities(entityType, new AABB(blockPos).inflate(radius), Entity::isAlive);
	}

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

	public void assertEntityInstancePresent(Entity entity, int x, int y, int z) {
		this.assertEntityInstancePresent(entity, new BlockPos(x, y, z));
	}

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

	public void assertItemEntityCountIs(Item item, BlockPos pos, double expansionAmount, int count) {
		BlockPos blockPos = this.absolutePos(pos);
		List<ItemEntity> list = this.getLevel().getEntities(EntityType.ITEM, new AABB(blockPos).inflate(expansionAmount), Entity::isAlive);
		int i = 0;

		for (ItemEntity itemEntity : list) {
			ItemStack itemStack = itemEntity.getItem();
			if (itemStack.is(item)) {
				i += itemStack.getCount();
			}
		}

		if (i != count) {
			throw this.assertionException(pos, "test.error.expected_items_count", count, item.getName(), i);
		}
	}

	public void assertItemEntityPresent(Item item, BlockPos pos, double expansionAmount) {
		BlockPos blockPos = this.absolutePos(pos);

		for (Entity entity : this.getLevel().getEntities(EntityType.ITEM, new AABB(blockPos).inflate(expansionAmount), Entity::isAlive)) {
			ItemEntity itemEntity = (ItemEntity)entity;
			if (itemEntity.getItem().getItem().equals(item)) {
				return;
			}
		}

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

	public void assertItemEntityNotPresent(Item item, BlockPos pos, double radius) {
		BlockPos blockPos = this.absolutePos(pos);

		for (Entity entity : this.getLevel().getEntities(EntityType.ITEM, new AABB(blockPos).inflate(radius), Entity::isAlive)) {
			ItemEntity itemEntity = (ItemEntity)entity;
			if (itemEntity.getItem().getItem().equals(item)) {
				throw this.assertionException(pos, "test.error.unexpected_item", item.getName());
			}
		}
	}

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

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

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

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

	public void assertEntityNotPresent(EntityType<?> type, int x, int y, int z) {
		this.assertEntityNotPresent(type, new BlockPos(x, y, z));
	}

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

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

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

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

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

	public <E extends Entity, T> void assertEntityData(BlockPos pos, EntityType<E> type, Function<? super E, T> entityDataGetter, @Nullable T testEntityData) {
		BlockPos blockPos = this.absolutePos(pos);
		List<E> list = this.getLevel().getEntities(type, new AABB(blockPos), Entity::isAlive);
		if (list.isEmpty()) {
			throw this.assertionException(pos, "test.error.expected_entity", type.getDescription());
		} else {
			for (E entity : list) {
				T object = (T)entityDataGetter.apply(entity);
				if (!Objects.equals(object, testEntityData)) {
					throw this.assertionException(pos, "test.error.expected_entity_data", testEntityData, object);
				}
			}
		}
	}

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

			throw this.assertionException(pos, "test.error.expected_entity_holding", item.getName());
		}
	}

	public <E extends Entity & InventoryCarrier> void assertEntityInventoryContains(BlockPos pos, EntityType<E> entityType, Item item) {
		BlockPos blockPos = this.absolutePos(pos);
		List<E> list = this.getLevel().getEntities(entityType, new AABB(blockPos), object -> ((Entity)object).isAlive());
		if (list.isEmpty()) {
			throw this.assertionException(pos, "test.error.expected_entity", entityType.getDescription());
		} else {
			for (E entity : list) {
				if (entity.getInventory().hasAnyMatching(itemStack -> itemStack.is(item))) {
					return;
				}
			}

			throw this.assertionException(pos, "test.error.expected_entity_having", item.getName());
		}
	}

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

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

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

	public void assertSameBlockStates(BoundingBox boundingBox, BlockPos pos) {
		BlockPos.betweenClosedStream(boundingBox).forEach(blockPos2 -> {
			BlockPos blockPos3 = pos.offset(blockPos2.getX() - boundingBox.minX(), blockPos2.getY() - boundingBox.minY(), blockPos2.getZ() - boundingBox.minZ());
			this.assertSameBlockState(blockPos2, blockPos3);
		});
	}

	public void assertSameBlockState(BlockPos testPos, BlockPos comparisonPos) {
		BlockState blockState = this.getBlockState(testPos);
		BlockState blockState2 = this.getBlockState(comparisonPos);
		if (blockState != blockState2) {
			throw this.assertionException(testPos, "test.error.state_not_equal", blockState2, blockState);
		}
	}

	public void assertAtTickTimeContainerContains(long tickTime, BlockPos pos, Item item) {
		this.runAtTickTime(tickTime, () -> this.assertContainerContainsSingle(pos, item));
	}

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

	public <E extends Entity, T> void succeedWhenEntityData(BlockPos pos, EntityType<E> type, Function<E, T> entityDataGetter, T testEntityData) {
		this.succeedWhen(() -> this.assertEntityData(pos, type, entityDataGetter, testEntityData));
	}

	public void assertEntityPosition(Entity entity, AABB boundingBox, Component message) {
		if (!boundingBox.contains(this.relativeVec(entity.position()))) {
			throw this.assertionException(message);
		}
	}

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

	public <E extends Entity, T> void assertEntityProperty(E entity, Function<E, T> valueGetter, T expectedValue, Component message) {
		T object = (T)valueGetter.apply(entity);
		if (!object.equals(expectedValue)) {
			throw this.assertionException(entity.blockPosition(), "test.error.entity_property_details", entity.getName(), message, object, expectedValue);
		}
	}

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

	public void succeedWhenEntityPresent(EntityType<?> type, int x, int y, int z) {
		this.succeedWhenEntityPresent(type, new BlockPos(x, y, z));
	}

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

	public void succeedWhenEntityNotPresent(EntityType<?> type, int x, int y, int z) {
		this.succeedWhenEntityNotPresent(type, new BlockPos(x, y, z));
	}

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

	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 criterion) {
		this.ensureSingleFinalCheck();
		this.testInfo.createSequence().thenWaitUntil(0L, criterion).thenSucceed();
	}

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

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

	public void runAtTickTime(long tickTime, Runnable task) {
		this.testInfo.setRunAtTickTime(tickTime, task);
	}

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

	public void randomTick(BlockPos pos) {
		BlockPos blockPos = this.absolutePos(pos);
		ServerLevel serverLevel = this.getLevel();
		serverLevel.getBlockState(blockPos).randomTick(serverLevel, blockPos, serverLevel.random);
	}

	public void tickBlock(BlockPos pos) {
		BlockPos blockPos = this.absolutePos(pos);
		ServerLevel serverLevel = this.getLevel();
		serverLevel.getBlockState(blockPos).tick(serverLevel, blockPos, serverLevel.random);
	}

	public void tickPrecipitation(BlockPos pos) {
		BlockPos blockPos = this.absolutePos(pos);
		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 m = (int)Math.floor(aABB.minZ); m < j; m++) {
				this.tickPrecipitation(new BlockPos(l, k, m));
			}
		}
	}

	public int getHeight(Heightmap.Types heightmapType, int x, int z) {
		BlockPos blockPos = this.absolutePos(new BlockPos(x, 0, z));
		return this.relativePos(this.getLevel().getHeightmapPos(heightmapType, blockPos)).getY();
	}

	public void fail(Component message, BlockPos pos) {
		throw this.assertionException(pos, message);
	}

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

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

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

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

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

	public BlockPos absolutePos(BlockPos pos) {
		BlockPos blockPos = this.testInfo.getTestOrigin();
		BlockPos blockPos2 = blockPos.offset(pos);
		return StructureTemplate.transform(blockPos2, Mirror.NONE, this.testInfo.getRotation(), blockPos);
	}

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

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

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

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

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

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

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

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

	public void assertFalse(boolean condition, Component message) {
		this.assertTrue(!condition, message);
	}

	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> consumer) {
		AABB aABB = this.getRelativeBounds().contract(1.0, 1.0, 1.0);
		BlockPos.MutableBlockPos.betweenClosedStream(aABB).forEach(consumer);
	}

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

	public void placeAt(Player player, ItemStack stack, BlockPos pos, Direction direction) {
		BlockPos blockPos = this.absolutePos(pos.relative(direction));
		BlockHitResult blockHitResult = new BlockHitResult(Vec3.atCenterOf(blockPos), direction, blockPos, false);
		UseOnContext useOnContext = new UseOnContext(player, InteractionHand.MAIN_HAND, blockHitResult);
		stack.useOn(useOnContext);
	}

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