package codechicken.nei; import java.io.File; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.net.URL; import java.util.ArrayList; import java.util.Arrays; import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.UUID; import java.util.concurrent.ConcurrentHashMap; import java.util.function.Predicate; import java.util.regex.Pattern; import java.util.regex.PatternSyntaxException; import java.util.stream.Collectors; import java.util.stream.IntStream; import net.minecraft.item.ItemStack; import net.minecraft.nbt.NBTBase.NBTPrimitive; import net.minecraft.nbt.NBTTagCompound; import net.minecraft.util.StatCollector; import net.minecraftforge.oredict.OreDictionary; import org.apache.commons.io.IOUtils; import com.google.gson.JsonObject; import com.google.gson.JsonParser; import com.google.gson.JsonSyntaxException; import codechicken.nei.ItemList.AllMultiItemFilter; import codechicken.nei.ItemList.AnyMultiItemFilter; import codechicken.nei.ItemList.EverythingItemFilter; import codechicken.nei.ItemList.NegatedItemFilter; import codechicken.nei.ItemList.NothingItemFilter; import codechicken.nei.PresetsList.Preset; import codechicken.nei.PresetsList.PresetMode; import codechicken.nei.api.ItemFilter; import cpw.mods.fml.common.registry.GameData; public class CollapsibleItems { protected static interface ISearchParserProvider { public ItemFilter getFilter(String searchText); default Predicate getMatcher(String searchText) { if (searchText.length() >= 3 && searchText.startsWith("r/") && searchText.endsWith("/")) { try { Pattern pattern = Pattern.compile( searchText.substring(2, searchText.length() - 1), Pattern.MULTILINE | Pattern.CASE_INSENSITIVE | Pattern.UNICODE_CASE); return value -> pattern.matcher(value).find(); } catch (PatternSyntaxException ignored) {} } else if (!searchText.isEmpty()) { return value -> value.toLowerCase().contains(searchText); } return null; } } protected static class GroupTokenParser { protected final HashMap searchProviders = new HashMap<>(); public void addProvider(char prefix, ISearchParserProvider provider) { this.searchProviders.put(prefix, provider); } public ItemFilter getFilter(String filterText) { final String[] parts = filterText.toLowerCase().trim().split("\\|"); final List searchTokens = Arrays.stream(parts).map(s -> parseSearchText(s)) .filter(s -> s != null && !s.filters.isEmpty()).collect(Collectors.toCollection(ArrayList::new)); if (searchTokens.isEmpty()) { return new EverythingItemFilter(); } else if (searchTokens.size() == 1) { return searchTokens.get(0); } else { return new AnyMultiItemFilter(searchTokens); } } private AllMultiItemFilter parseSearchText(String filterText) { if (filterText.isEmpty()) { return null; } final String[] tokens = filterText.split("\\s+"); final AllMultiItemFilter searchTokens = new AllMultiItemFilter(); for (String token : tokens) { token = token.trim(); boolean ignore = token.startsWith("!"); if (ignore) { token = token.substring(1); } if (token.isEmpty()) { continue; } ISearchParserProvider provider = this.searchProviders.get(token.charAt(0)); if (provider != null) { token = token.substring(1); } else { provider = this.searchProviders.get('\0'); } ItemFilter filter = parseToken(ignore ? "!" + token : token, provider); if (filter != null) { searchTokens.filters.add(filter); } } return searchTokens; } private ItemFilter parseToken(String token, ISearchParserProvider provider) { final String[] parts = token.split(","); final AnyMultiItemFilter includeFilter = new AnyMultiItemFilter(); final AnyMultiItemFilter expludeFilter = new AnyMultiItemFilter(); final AllMultiItemFilter groupFilter = new AllMultiItemFilter(); for (String part : parts) { boolean ignore = part.startsWith("!"); if (ignore) { part = part.substring(1); } ItemFilter filter = provider.getFilter(part); if (filter == null) { continue; } if (ignore) { expludeFilter.filters.add(filter); } else { includeFilter.filters.add(filter); } } if (!includeFilter.filters.isEmpty()) { groupFilter.filters.add(includeFilter); } if (!expludeFilter.filters.isEmpty()) { groupFilter.filters.add(new NegatedItemFilter(expludeFilter)); } return groupFilter.filters.isEmpty() ? null : groupFilter; } } protected static class IdentifierFilter implements ISearchParserProvider { @Override public ItemFilter getFilter(String searchText) { if (Pattern.matches("^\\d+(-\\d+)*$", searchText)) { final Predicate filter = generateDamageFilter(searchText); return (stack) -> filter.test(stack.getItemDamage()); } Predicate matcher = getMatcher(searchText); if (matcher != null) { return stack -> matcher.test(getStringIdentifier(stack)); } return null; } protected String getStringIdentifier(ItemStack stack) { String name = GameData.getItemRegistry().getNameForObject(stack.getItem()); return name == null || name.isEmpty() ? "Unknown:Unknown" : name; } protected Predicate generateDamageFilter(String searchText) { String[] range = searchText.split("-"); if (range.length == 1) { final int damage = Integer.parseInt(range[0]); return (dmg) -> dmg == damage; } else { final int damageStart = Integer.parseInt(range[0]); final int damageEnd = Integer.parseInt(range[1]); return (dmg) -> dmg >= damageStart && dmg <= damageEnd; } } } protected static class OreDictionaryFilter implements ISearchParserProvider { @Override public ItemFilter getFilter(String searchText) { Predicate matcher = getMatcher(searchText); if (matcher != null) { return stack -> matches(stack, matcher); } return null; } protected boolean matches(ItemStack stack, Predicate matcher) { return IntStream.of(OreDictionary.getOreIDs(stack)) .anyMatch(id -> matcher.test(OreDictionary.getOreName(id))); } } protected static class GroupItem { public String guid; public ItemFilter filter; public boolean expanded = false; public String displayName = ""; public GroupItem() {} public void setFilter(String filter) { this.filter = CollapsibleItems.groupParser.getFilter(filter.trim()); this.guid = UUID.nameUUIDFromBytes(filter.getBytes()).toString(); } public void setFilter(ItemFilter filter, String guid) { this.filter = filter; this.guid = guid; } public boolean matches(ItemStack stack) { return this.filter.matches(stack); } } protected File statesFile; protected static final GroupTokenParser groupParser = new GroupTokenParser(); protected final List groups = new ArrayList<>(); protected final Map cache = new ConcurrentHashMap<>(); static { groupParser.addProvider('\0', new IdentifierFilter()); groupParser.addProvider('$', new OreDictionaryFilter()); } public void reload() { this.groups.clear(); this.cache.clear(); for (int i = PresetsList.presets.size() - 1; i >= 0; i--) { Preset preset = PresetsList.presets.get(i); if (preset.enabled && preset.mode == PresetMode.GROUP) { GroupItem group = new GroupItem(); group.setFilter(preset, UUID.nameUUIDFromBytes(preset.items.toString().getBytes()).toString()); group.displayName = preset.name; addGroup(group); } } if (NEIClientConfig.enableCollapsibleItems()) { loadCollapsibleItems(); } loadStates(); if (ItemList.loadFinished) { LayoutManager.markItemsDirty(); } } protected void loadCollapsibleItems() { File file = NEIClientConfig.collapsibleItemsFile; if (!file.exists()) { try (FileWriter writer = new FileWriter(file)) { NEIClientConfig.logger.info("Creating default collapsible items list {}", file); URL defaultCollapsibleItemsResource = ClientHandler.class .getResource("/assets/nei/cfg/collapsibleitems.cfg"); if (defaultCollapsibleItemsResource != null) { IOUtils.copy(defaultCollapsibleItemsResource.openStream(), writer); } } catch (IOException e) { NEIClientConfig.logger.error("Failed to save default collapsible items list to file {}", file, e); } } try (FileReader reader = new FileReader(file)) { NEIClientConfig.logger.info("Loading collapsible items from file {}", file); parseFile(IOUtils.readLines(reader)); } catch (IOException e) { NEIClientConfig.logger.error("Failed to load collapsible items from file {}", file, e); } } public void parseFile(List itemStrings) { final JsonParser parser = new JsonParser(); GroupItem group = new GroupItem(); for (String itemStr : itemStrings) { if (itemStr.startsWith("#") || itemStr.trim().isEmpty()) { continue; } try { if (itemStr.startsWith("; ")) { JsonObject settings = parser.parse(itemStr.substring(2)).getAsJsonObject(); if (settings.get("displayName") != null) { group.displayName = settings.get("displayName").getAsString(); } if (settings.get("unlocalizedName") != null) { String displayName = StatCollector .translateToLocal(settings.get("unlocalizedName").getAsString()); if (!displayName.equals(settings.get("unlocalizedName").getAsString())) { group.displayName = displayName; } } if (settings.get("expanded") != null) { group.expanded = settings.get("expanded").getAsBoolean(); } } else { group.setFilter(itemStr); } if (group != null && group.filter != null) { addGroup(group); group = new GroupItem(); } } catch (IllegalArgumentException | JsonSyntaxException | IllegalStateException e) { NEIClientConfig.logger.error("Failed to load collapsible items from json string:\n{}", itemStr); } } } protected void addGroup(GroupItem group) { if (group == null || group.filter == null || group.filter instanceof EverythingItemFilter || group.filter instanceof NothingItemFilter) return; this.groups.add(group); } public boolean isEmpty() { return this.groups.isEmpty(); } public ItemFilter getItemFilter() { AnyMultiItemFilter filter = new AnyMultiItemFilter(); for (GroupItem group : this.groups) { filter.filters.add(group.filter); } return filter; } public void updateCache(final List items) { this.cache.clear(); try { ItemList.forkJoinPool.submit(() -> items.parallelStream().forEach(stack -> { GroupItem group = this.groups.stream().filter(g -> g.matches(stack)).findFirst().orElse(null); if (group != null) { this.cache.put(stack, this.groups.indexOf(group)); } })).get(); } catch (Exception e) { NEIClientConfig.logger.error("Error create collapsible items groups", e); } } public int getGroupIndex(ItemStack stack) { if (stack == null) { return -1; } return this.cache.getOrDefault(stack, -1); } public String getDisplayName(int groupIndex) { if (groupIndex < this.groups.size()) { return this.groups.get(groupIndex).displayName; } return null; } public boolean isExpanded(int groupIndex) { if (groupIndex < this.groups.size()) { return this.groups.get(groupIndex).expanded; } return true; } public void setExpanded(int groupIndex, boolean expanded) { if (groupIndex < this.groups.size()) { this.groups.get(groupIndex).expanded = expanded; saveStates(); } } public void toggleGroups(Boolean expanded) { if (expanded == null) { expanded = !this.groups.stream().filter(g -> g.expanded).findAny().isPresent(); } for (GroupItem group : this.groups) { group.expanded = expanded; } saveStates(); } private void loadStates() { try { if (NEIClientConfig.world.nbt.hasKey("collapsibleitems")) { NBTTagCompound states = NEIClientConfig.world.nbt.getCompoundTag("collapsibleitems"); @SuppressWarnings("unchecked") final Map list = (Map) states.tagMap; final Map mapping = new HashMap<>(); for (GroupItem group : this.groups) { mapping.put(group.guid, group); } for (Map.Entry nbtEntry : list.entrySet()) { if (mapping.containsKey(nbtEntry.getKey())) { mapping.get(nbtEntry.getKey()).expanded = nbtEntry.getValue().func_150290_f() == 1; } } } } catch (Exception e) { NEIClientConfig.logger.error("Error loading collapsible items states", e); } } private void saveStates() { NBTTagCompound list = new NBTTagCompound(); for (GroupItem group : this.groups) { list.setBoolean(group.guid, group.expanded); } NEIClientConfig.world.nbt.setTag("collapsibleitems", list); } }