package net.minecraft.commands.arguments.selector.options;

import com.google.common.collect.Maps;
import com.mojang.brigadier.StringReader;
import com.mojang.brigadier.exceptions.CommandSyntaxException;
import com.mojang.brigadier.exceptions.DynamicCommandExceptionType;
import com.mojang.brigadier.exceptions.SimpleCommandExceptionType;
import com.mojang.brigadier.suggestion.SuggestionsBuilder;
import java.util.Arrays;
import java.util.Locale;
import java.util.Map;
import java.util.Objects;
import java.util.Optional;
import java.util.Map.Entry;
import java.util.function.Consumer;
import java.util.function.Predicate;
import net.minecraft.advancements.AdvancementHolder;
import net.minecraft.advancements.AdvancementProgress;
import net.minecraft.advancements.CriterionProgress;
import net.minecraft.advancements.critereon.MinMaxBounds;
import net.minecraft.advancements.critereon.WrappedMinMaxBounds;
import net.minecraft.commands.SharedSuggestionProvider;
import net.minecraft.commands.arguments.selector.EntitySelector;
import net.minecraft.commands.arguments.selector.EntitySelectorParser;
import net.minecraft.core.Holder;
import net.minecraft.core.HolderSet;
import net.minecraft.core.registries.BuiltInRegistries;
import net.minecraft.core.registries.Registries;
import net.minecraft.nbt.CompoundTag;
import net.minecraft.nbt.NbtUtils;
import net.minecraft.nbt.TagParser;
import net.minecraft.network.chat.Component;
import net.minecraft.resources.ResourceKey;
import net.minecraft.resources.ResourceLocation;
import net.minecraft.server.PlayerAdvancements;
import net.minecraft.server.ServerAdvancementManager;
import net.minecraft.server.level.ServerLevel;
import net.minecraft.server.level.ServerPlayer;
import net.minecraft.tags.TagKey;
import net.minecraft.util.Mth;
import net.minecraft.world.entity.Entity;
import net.minecraft.world.entity.EntityType;
import net.minecraft.world.item.ItemStack;
import net.minecraft.world.level.GameType;
import net.minecraft.world.level.storage.loot.LootContext;
import net.minecraft.world.level.storage.loot.LootParams;
import net.minecraft.world.level.storage.loot.parameters.LootContextParamSets;
import net.minecraft.world.level.storage.loot.parameters.LootContextParams;
import net.minecraft.world.level.storage.loot.predicates.LootItemCondition;
import net.minecraft.world.scores.Objective;
import net.minecraft.world.scores.ReadOnlyScoreInfo;
import net.minecraft.world.scores.Scoreboard;
import net.minecraft.world.scores.Team;

public class EntitySelectorOptions {
    private static final Map<String, EntitySelectorOptions.Option> OPTIONS = Maps.newHashMap();
    public static final DynamicCommandExceptionType ERROR_UNKNOWN_OPTION = new DynamicCommandExceptionType(
        p_308416_ -> Component.translatableEscape("argument.entity.options.unknown", p_308416_)
    );
    public static final DynamicCommandExceptionType ERROR_INAPPLICABLE_OPTION = new DynamicCommandExceptionType(
        p_308412_ -> Component.translatableEscape("argument.entity.options.inapplicable", p_308412_)
    );
    public static final SimpleCommandExceptionType ERROR_RANGE_NEGATIVE = new SimpleCommandExceptionType(Component.translatable("argument.entity.options.distance.negative"));
    public static final SimpleCommandExceptionType ERROR_LEVEL_NEGATIVE = new SimpleCommandExceptionType(Component.translatable("argument.entity.options.level.negative"));
    public static final SimpleCommandExceptionType ERROR_LIMIT_TOO_SMALL = new SimpleCommandExceptionType(Component.translatable("argument.entity.options.limit.toosmall"));
    public static final DynamicCommandExceptionType ERROR_SORT_UNKNOWN = new DynamicCommandExceptionType(
        p_308411_ -> Component.translatableEscape("argument.entity.options.sort.irreversible", p_308411_)
    );
    public static final DynamicCommandExceptionType ERROR_GAME_MODE_INVALID = new DynamicCommandExceptionType(
        p_308419_ -> Component.translatableEscape("argument.entity.options.mode.invalid", p_308419_)
    );
    public static final DynamicCommandExceptionType ERROR_ENTITY_TYPE_INVALID = new DynamicCommandExceptionType(
        p_308410_ -> Component.translatableEscape("argument.entity.options.type.invalid", p_308410_)
    );

    private static void register(String p_121454_, EntitySelectorOptions.Modifier p_121455_, Predicate<EntitySelectorParser> p_121456_, Component p_121457_) {
        OPTIONS.put(p_121454_, new EntitySelectorOptions.Option(p_121455_, p_121456_, p_121457_));
    }

    public static void bootStrap() {
        if (OPTIONS.isEmpty()) {
            register("name", p_368973_ -> {
                int i = p_368973_.getReader().getCursor();
                boolean flag = p_368973_.shouldInvertValue();
                String s = p_368973_.getReader().readString();
                if (p_368973_.hasNameNotEquals() && !flag) {
                    p_368973_.getReader().setCursor(i);
                    throw ERROR_INAPPLICABLE_OPTION.createWithContext(p_368973_.getReader(), "name");
                } else {
                    if (flag) {
                        p_368973_.setHasNameNotEquals(true);
                    } else {
                        p_368973_.setHasNameEquals(true);
                    }

                    p_368973_.addPredicate(p_175209_ -> p_175209_.getName().getString().equals(s) != flag);
                }
            }, p_121423_ -> !p_121423_.hasNameEquals(), Component.translatable("argument.entity.options.name.description"));
            register(
                "distance",
                p_121421_ -> {
                    int i = p_121421_.getReader().getCursor();
                    MinMaxBounds.Doubles minmaxbounds$doubles = MinMaxBounds.Doubles.fromReader(p_121421_.getReader());
                    if ((!minmaxbounds$doubles.min().isPresent() || !(minmaxbounds$doubles.min().get() < 0.0))
                        && (!minmaxbounds$doubles.max().isPresent() || !(minmaxbounds$doubles.max().get() < 0.0))) {
                        p_121421_.setDistance(minmaxbounds$doubles);
                        p_121421_.setWorldLimited();
                    } else {
                        p_121421_.getReader().setCursor(i);
                        throw ERROR_RANGE_NEGATIVE.createWithContext(p_121421_.getReader());
                    }
                },
                p_121419_ -> p_121419_.getDistance().isAny(),
                Component.translatable("argument.entity.options.distance.description")
            );
            register(
                "level",
                p_121417_ -> {
                    int i = p_121417_.getReader().getCursor();
                    MinMaxBounds.Ints minmaxbounds$ints = MinMaxBounds.Ints.fromReader(p_121417_.getReader());
                    if ((!minmaxbounds$ints.min().isPresent() || minmaxbounds$ints.min().get() >= 0)
                        && (!minmaxbounds$ints.max().isPresent() || minmaxbounds$ints.max().get() >= 0)) {
                        p_121417_.setLevel(minmaxbounds$ints);
                        p_121417_.setIncludesEntities(false);
                    } else {
                        p_121417_.getReader().setCursor(i);
                        throw ERROR_LEVEL_NEGATIVE.createWithContext(p_121417_.getReader());
                    }
                },
                p_121415_ -> p_121415_.getLevel().isAny(),
                Component.translatable("argument.entity.options.level.description")
            );
            register("x", p_121413_ -> {
                p_121413_.setWorldLimited();
                p_121413_.setX(p_121413_.getReader().readDouble());
            }, p_121411_ -> p_121411_.getX() == null, Component.translatable("argument.entity.options.x.description"));
            register("y", p_121409_ -> {
                p_121409_.setWorldLimited();
                p_121409_.setY(p_121409_.getReader().readDouble());
            }, p_121407_ -> p_121407_.getY() == null, Component.translatable("argument.entity.options.y.description"));
            register("z", p_121405_ -> {
                p_121405_.setWorldLimited();
                p_121405_.setZ(p_121405_.getReader().readDouble());
            }, p_121403_ -> p_121403_.getZ() == null, Component.translatable("argument.entity.options.z.description"));
            register("dx", p_121401_ -> {
                p_121401_.setWorldLimited();
                p_121401_.setDeltaX(p_121401_.getReader().readDouble());
            }, p_121399_ -> p_121399_.getDeltaX() == null, Component.translatable("argument.entity.options.dx.description"));
            register("dy", p_121397_ -> {
                p_121397_.setWorldLimited();
                p_121397_.setDeltaY(p_121397_.getReader().readDouble());
            }, p_121395_ -> p_121395_.getDeltaY() == null, Component.translatable("argument.entity.options.dy.description"));
            register("dz", p_121562_ -> {
                p_121562_.setWorldLimited();
                p_121562_.setDeltaZ(p_121562_.getReader().readDouble());
            }, p_121560_ -> p_121560_.getDeltaZ() == null, Component.translatable("argument.entity.options.dz.description"));
            register(
                "x_rotation",
                p_121558_ -> p_121558_.setRotX(WrappedMinMaxBounds.fromReader(p_121558_.getReader(), true, Mth::wrapDegrees)),
                p_121556_ -> p_121556_.getRotX() == WrappedMinMaxBounds.ANY,
                Component.translatable("argument.entity.options.x_rotation.description")
            );
            register(
                "y_rotation",
                p_121554_ -> p_121554_.setRotY(WrappedMinMaxBounds.fromReader(p_121554_.getReader(), true, Mth::wrapDegrees)),
                p_121552_ -> p_121552_.getRotY() == WrappedMinMaxBounds.ANY,
                Component.translatable("argument.entity.options.y_rotation.description")
            );
            register("limit", p_121550_ -> {
                int i = p_121550_.getReader().getCursor();
                int j = p_121550_.getReader().readInt();
                if (j < 1) {
                    p_121550_.getReader().setCursor(i);
                    throw ERROR_LIMIT_TOO_SMALL.createWithContext(p_121550_.getReader());
                } else {
                    p_121550_.setMaxResults(j);
                    p_121550_.setLimited(true);
                }
            }, p_121548_ -> !p_121548_.isCurrentEntity() && !p_121548_.isLimited(), Component.translatable("argument.entity.options.limit.description"));
            register(
                "sort",
                p_247983_ -> {
                    int i = p_247983_.getReader().getCursor();
                    String s = p_247983_.getReader().readUnquotedString();
                    p_247983_.setSuggestions(
                        (p_175153_, p_175154_) -> SharedSuggestionProvider.suggest(Arrays.asList("nearest", "furthest", "random", "arbitrary"), p_175153_)
                    );

                    p_247983_.setOrder(switch (s) {
                        case "nearest" -> EntitySelectorParser.ORDER_NEAREST;
                        case "furthest" -> EntitySelectorParser.ORDER_FURTHEST;
                        case "random" -> EntitySelectorParser.ORDER_RANDOM;
                        case "arbitrary" -> EntitySelector.ORDER_ARBITRARY;
                        default -> {
                            p_247983_.getReader().setCursor(i);
                            throw ERROR_SORT_UNKNOWN.createWithContext(p_247983_.getReader(), s);
                        }
                    });
                    p_247983_.setSorted(true);
                },
                p_121544_ -> !p_121544_.isCurrentEntity() && !p_121544_.isSorted(),
                Component.translatable("argument.entity.options.sort.description")
            );
            register("gamemode", p_121542_ -> {
                p_121542_.setSuggestions((p_175193_, p_175194_) -> {
                    String s1 = p_175193_.getRemaining().toLowerCase(Locale.ROOT);
                    boolean flag1 = !p_121542_.hasGamemodeNotEquals();
                    boolean flag2 = true;
                    if (!s1.isEmpty()) {
                        if (s1.charAt(0) == '!') {
                            flag1 = false;
                            s1 = s1.substring(1);
                        } else {
                            flag2 = false;
                        }
                    }

                    for (GameType gametype1 : GameType.values()) {
                        if (gametype1.getName().toLowerCase(Locale.ROOT).startsWith(s1)) {
                            if (flag2) {
                                p_175193_.suggest("!" + gametype1.getName());
                            }

                            if (flag1) {
                                p_175193_.suggest(gametype1.getName());
                            }
                        }
                    }

                    return p_175193_.buildFuture();
                });
                int i = p_121542_.getReader().getCursor();
                boolean flag = p_121542_.shouldInvertValue();
                if (p_121542_.hasGamemodeNotEquals() && !flag) {
                    p_121542_.getReader().setCursor(i);
                    throw ERROR_INAPPLICABLE_OPTION.createWithContext(p_121542_.getReader(), "gamemode");
                } else {
                    String s = p_121542_.getReader().readUnquotedString();
                    GameType gametype = GameType.byName(s, null);
                    if (gametype == null) {
                        p_121542_.getReader().setCursor(i);
                        throw ERROR_GAME_MODE_INVALID.createWithContext(p_121542_.getReader(), s);
                    } else {
                        p_121542_.setIncludesEntities(false);
                        p_121542_.addPredicate(p_175190_ -> {
                            if (p_175190_ instanceof ServerPlayer serverplayer) {
                                GameType gametype1 = serverplayer.gameMode();
                                return gametype1 == gametype ^ flag;
                            } else {
                                return false;
                            }
                        });
                        if (flag) {
                            p_121542_.setHasGamemodeNotEquals(true);
                        } else {
                            p_121542_.setHasGamemodeEquals(true);
                        }
                    }
                }
            }, p_121540_ -> !p_121540_.hasGamemodeEquals(), Component.translatable("argument.entity.options.gamemode.description"));
            register("team", p_121538_ -> {
                boolean flag = p_121538_.shouldInvertValue();
                String s = p_121538_.getReader().readUnquotedString();
                p_121538_.addPredicate(p_389651_ -> {
                    Team team = p_389651_.getTeam();
                    String s1 = team == null ? "" : team.getName();
                    return s1.equals(s) != flag;
                });
                if (flag) {
                    p_121538_.setHasTeamNotEquals(true);
                } else {
                    p_121538_.setHasTeamEquals(true);
                }
            }, p_121536_ -> !p_121536_.hasTeamEquals(), Component.translatable("argument.entity.options.team.description"));
            register(
                "type",
                p_121534_ -> {
                    p_121534_.setSuggestions(
                        (p_358070_, p_358071_) -> {
                            SharedSuggestionProvider.suggestResource(BuiltInRegistries.ENTITY_TYPE.keySet(), p_358070_, String.valueOf('!'));
                            SharedSuggestionProvider.suggestResource(
                                BuiltInRegistries.ENTITY_TYPE.getTags().map(p_358072_ -> p_358072_.key().location()), p_358070_, "!#"
                            );
                            if (!p_121534_.isTypeLimitedInversely()) {
                                SharedSuggestionProvider.suggestResource(BuiltInRegistries.ENTITY_TYPE.keySet(), p_358070_);
                                SharedSuggestionProvider.suggestResource(
                                    BuiltInRegistries.ENTITY_TYPE.getTags().map(p_358068_ -> p_358068_.key().location()), p_358070_, String.valueOf('#')
                                );
                            }

                            return p_358070_.buildFuture();
                        }
                    );
                    int i = p_121534_.getReader().getCursor();
                    boolean flag = p_121534_.shouldInvertValue();
                    if (p_121534_.isTypeLimitedInversely() && !flag) {
                        p_121534_.getReader().setCursor(i);
                        throw ERROR_INAPPLICABLE_OPTION.createWithContext(p_121534_.getReader(), "type");
                    } else {
                        if (flag) {
                            p_121534_.setTypeLimitedInversely();
                        }

                        if (p_121534_.isTag()) {
                            TagKey<EntityType<?>> tagkey = TagKey.create(Registries.ENTITY_TYPE, ResourceLocation.read(p_121534_.getReader()));
                            p_121534_.addPredicate(p_205691_ -> p_205691_.getType().is(tagkey) != flag);
                        } else {
                            ResourceLocation resourcelocation = ResourceLocation.read(p_121534_.getReader());
                            EntityType<?> entitytype = BuiltInRegistries.ENTITY_TYPE.getOptional(resourcelocation).orElseThrow(() -> {
                                p_121534_.getReader().setCursor(i);
                                return ERROR_ENTITY_TYPE_INVALID.createWithContext(p_121534_.getReader(), resourcelocation.toString());
                            });
                            if (Objects.equals(EntityType.PLAYER, entitytype) && !flag) {
                                p_121534_.setIncludesEntities(false);
                            }

                            p_121534_.addPredicate(p_175151_ -> Objects.equals(entitytype, p_175151_.getType()) != flag);
                            if (!flag) {
                                p_121534_.limitToType(entitytype);
                            }
                        }
                    }
                },
                p_121532_ -> !p_121532_.isTypeLimited(),
                Component.translatable("argument.entity.options.type.description")
            );
            register("tag", p_121530_ -> {
                boolean flag = p_121530_.shouldInvertValue();
                String s = p_121530_.getReader().readUnquotedString();
                p_121530_.addPredicate(p_175166_ -> "".equals(s) ? p_175166_.getTags().isEmpty() != flag : p_175166_.getTags().contains(s) != flag);
            }, p_121528_ -> true, Component.translatable("argument.entity.options.tag.description"));
            register("nbt", p_389652_ -> {
                boolean flag = p_389652_.shouldInvertValue();
                CompoundTag compoundtag = TagParser.parseCompoundAsArgument(p_389652_.getReader());
                p_389652_.addPredicate(p_175176_ -> {
                    CompoundTag compoundtag1 = p_175176_.saveWithoutId(new CompoundTag());
                    if (p_175176_ instanceof ServerPlayer serverplayer) {
                        ItemStack itemstack = serverplayer.getInventory().getSelectedItem();
                        if (!itemstack.isEmpty()) {
                            compoundtag1.put("SelectedItem", itemstack.save(serverplayer.registryAccess()));
                        }
                    }

                    return NbtUtils.compareNbt(compoundtag, compoundtag1, true) != flag;
                });
            }, p_121524_ -> true, Component.translatable("argument.entity.options.nbt.description"));
            register("scores", p_121522_ -> {
                StringReader stringreader = p_121522_.getReader();
                Map<String, MinMaxBounds.Ints> map = Maps.newHashMap();
                stringreader.expect('{');
                stringreader.skipWhitespace();

                while (stringreader.canRead() && stringreader.peek() != '}') {
                    stringreader.skipWhitespace();
                    String s = stringreader.readUnquotedString();
                    stringreader.skipWhitespace();
                    stringreader.expect('=');
                    stringreader.skipWhitespace();
                    MinMaxBounds.Ints minmaxbounds$ints = MinMaxBounds.Ints.fromReader(stringreader);
                    map.put(s, minmaxbounds$ints);
                    stringreader.skipWhitespace();
                    if (stringreader.canRead() && stringreader.peek() == ',') {
                        stringreader.skip();
                    }
                }

                stringreader.expect('}');
                if (!map.isEmpty()) {
                    p_121522_.addPredicate(p_308418_ -> {
                        Scoreboard scoreboard = p_308418_.getServer().getScoreboard();

                        for (Entry<String, MinMaxBounds.Ints> entry : map.entrySet()) {
                            Objective objective = scoreboard.getObjective(entry.getKey());
                            if (objective == null) {
                                return false;
                            }

                            ReadOnlyScoreInfo readonlyscoreinfo = scoreboard.getPlayerScoreInfo(p_308418_, objective);
                            if (readonlyscoreinfo == null) {
                                return false;
                            }

                            if (!entry.getValue().matches(readonlyscoreinfo.value())) {
                                return false;
                            }
                        }

                        return true;
                    });
                }

                p_121522_.setHasScores(true);
            }, p_121518_ -> !p_121518_.hasScores(), Component.translatable("argument.entity.options.scores.description"));
            register("advancements", p_121514_ -> {
                StringReader stringreader = p_121514_.getReader();
                Map<ResourceLocation, Predicate<AdvancementProgress>> map = Maps.newHashMap();
                stringreader.expect('{');
                stringreader.skipWhitespace();

                while (stringreader.canRead() && stringreader.peek() != '}') {
                    stringreader.skipWhitespace();
                    ResourceLocation resourcelocation = ResourceLocation.read(stringreader);
                    stringreader.skipWhitespace();
                    stringreader.expect('=');
                    stringreader.skipWhitespace();
                    if (stringreader.canRead() && stringreader.peek() == '{') {
                        Map<String, Predicate<CriterionProgress>> map1 = Maps.newHashMap();
                        stringreader.skipWhitespace();
                        stringreader.expect('{');
                        stringreader.skipWhitespace();

                        while (stringreader.canRead() && stringreader.peek() != '}') {
                            stringreader.skipWhitespace();
                            String s = stringreader.readUnquotedString();
                            stringreader.skipWhitespace();
                            stringreader.expect('=');
                            stringreader.skipWhitespace();
                            boolean flag1 = stringreader.readBoolean();
                            map1.put(s, p_175186_ -> p_175186_.isDone() == flag1);
                            stringreader.skipWhitespace();
                            if (stringreader.canRead() && stringreader.peek() == ',') {
                                stringreader.skip();
                            }
                        }

                        stringreader.skipWhitespace();
                        stringreader.expect('}');
                        stringreader.skipWhitespace();
                        map.put(resourcelocation, p_175169_ -> {
                            for (Entry<String, Predicate<CriterionProgress>> entry : map1.entrySet()) {
                                CriterionProgress criterionprogress = p_175169_.getCriterion(entry.getKey());
                                if (criterionprogress == null || !entry.getValue().test(criterionprogress)) {
                                    return false;
                                }
                            }

                            return true;
                        });
                    } else {
                        boolean flag = stringreader.readBoolean();
                        map.put(resourcelocation, p_175183_ -> p_175183_.isDone() == flag);
                    }

                    stringreader.skipWhitespace();
                    if (stringreader.canRead() && stringreader.peek() == ',') {
                        stringreader.skip();
                    }
                }

                stringreader.expect('}');
                if (!map.isEmpty()) {
                    p_121514_.addPredicate(p_358074_ -> {
                        if (!(p_358074_ instanceof ServerPlayer serverplayer)) {
                            return false;
                        } else {
                            PlayerAdvancements $$4 = serverplayer.getAdvancements();
                            ServerAdvancementManager $$5x = serverplayer.getServer().getAdvancements();

                            for (Entry<ResourceLocation, Predicate<AdvancementProgress>> entry : map.entrySet()) {
                                AdvancementHolder advancementholder = $$5x.get(entry.getKey());
                                if (advancementholder == null || !entry.getValue().test($$4.getOrStartProgress(advancementholder))) {
                                    return false;
                                }
                            }

                            return true;
                        }
                    });
                    p_121514_.setIncludesEntities(false);
                }

                p_121514_.setHasAdvancements(true);
            }, p_121506_ -> !p_121506_.hasAdvancements(), Component.translatable("argument.entity.options.advancements.description"));
            register(
                "predicate",
                p_325634_ -> {
                    boolean flag = p_325634_.shouldInvertValue();
                    ResourceKey<LootItemCondition> resourcekey = ResourceKey.create(Registries.PREDICATE, ResourceLocation.read(p_325634_.getReader()));
                    p_325634_.addPredicate(
                        p_358077_ -> {
                            if (!(p_358077_.level() instanceof ServerLevel)) {
                                return false;
                            } else {
                                ServerLevel serverlevel = (ServerLevel)p_358077_.level();
                                Optional<LootItemCondition> optional = serverlevel.getServer()
                                    .reloadableRegistries()
                                    .lookup()
                                    .get(resourcekey)
                                    .map(Holder::value);
                                if (optional.isEmpty()) {
                                    return false;
                                } else {
                                    LootParams lootparams = new LootParams.Builder(serverlevel)
                                        .withParameter(LootContextParams.THIS_ENTITY, p_358077_)
                                        .withParameter(LootContextParams.ORIGIN, p_358077_.position())
                                        .create(LootContextParamSets.SELECTOR);
                                    LootContext lootcontext = new LootContext.Builder(lootparams).create(Optional.empty());
                                    lootcontext.pushVisitedElement(LootContext.createVisitedEntry(optional.get()));
                                    return flag ^ optional.get().test(lootcontext);
                                }
                            }
                        }
                    );
                },
                p_121435_ -> true,
                Component.translatable("argument.entity.options.predicate.description")
            );
        }
    }

    public static EntitySelectorOptions.Modifier get(EntitySelectorParser p_121448_, String p_121449_, int p_121450_) throws CommandSyntaxException {
        EntitySelectorOptions.Option entityselectoroptions$option = OPTIONS.get(p_121449_);
        if (entityselectoroptions$option != null) {
            if (entityselectoroptions$option.canUse.test(p_121448_)) {
                return entityselectoroptions$option.modifier;
            } else {
                throw ERROR_INAPPLICABLE_OPTION.createWithContext(p_121448_.getReader(), p_121449_);
            }
        } else {
            p_121448_.getReader().setCursor(p_121450_);
            throw ERROR_UNKNOWN_OPTION.createWithContext(p_121448_.getReader(), p_121449_);
        }
    }

    public static void suggestNames(EntitySelectorParser p_121441_, SuggestionsBuilder p_121442_) {
        String s = p_121442_.getRemaining().toLowerCase(Locale.ROOT);

        for (Entry<String, EntitySelectorOptions.Option> entry : OPTIONS.entrySet()) {
            if (entry.getValue().canUse.test(p_121441_) && entry.getKey().toLowerCase(Locale.ROOT).startsWith(s)) {
                p_121442_.suggest(entry.getKey() + "=", entry.getValue().description);
            }
        }
    }

    public interface Modifier {
        void handle(EntitySelectorParser p_121564_) throws CommandSyntaxException;
    }

    record Option(EntitySelectorOptions.Modifier modifier, Predicate<EntitySelectorParser> canUse, Component description) {
    }
}