// 
// Decompiled by Procyon v0.6.0
// 

package com.hypixel.hytale.server.npc.asset.builder.util;

import java.util.HashSet;
import java.util.Set;
import java.util.function.Supplier;
import java.util.Collections;
import java.util.stream.Stream;
import java.util.function.Consumer;
import java.util.Objects;
import java.util.List;
import java.util.stream.Collector;
import java.util.stream.Collectors;
import java.util.function.Function;
import javax.annotation.Nullable;
import java.util.Collection;
import javax.annotation.Nonnull;
import java.util.regex.Pattern;

public class StringListHelpers
{
    @Nonnull
    private static Pattern listSplitter;
    @Nonnull
    private static Pattern listListSplitter;
    
    private StringListHelpers() {
    }
    
    @Nonnull
    public static String stringListToString(@Nullable final Collection<String> list) {
        if (list == null) {
            return "";
        }
        return list.stream().map((Function<? super String, ?>)String::trim).collect((Collector<? super Object, ?, String>)Collectors.joining(", "));
    }
    
    @Nonnull
    public static List<String> splitToStringList(final String string, @Nullable Function<String, String> mapper) {
        if (mapper == null) {
            mapper = Function.identity();
        }
        return StringListHelpers.listSplitter.splitAsStream(string).filter(s -> !s.isEmpty()).map((Function<? super String, ?>)mapper).collect((Collector<? super Object, ?, List<String>>)Collectors.toList());
    }
    
    public static void splitToStringList(final String string, @Nullable Function<String, String> mapper, @Nonnull final Collection<String> result) {
        if (mapper == null) {
            mapper = Function.identity();
        }
        final Stream<Object> map = StringListHelpers.listSplitter.splitAsStream(string).filter(s -> !s.isEmpty()).map((Function<? super String, ?>)mapper);
        Objects.requireNonNull(result);
        map.forEachOrdered(result::add);
    }
    
    @Nonnull
    public static String stringListListToString(@Nonnull final Collection<Collection<String>> list) {
        return list.stream().map((Function<? super Collection<String>, ?>)StringListHelpers::stringListToString).collect((Collector<? super Object, ?, String>)Collectors.joining("| "));
    }
    
    @Nonnull
    public static List<List<String>> splitToStringListList(@Nullable final String string, final Function<String, String> mapper) {
        if (string == null || string.isEmpty()) {
            return Collections.emptyList();
        }
        return StringListHelpers.listListSplitter.splitAsStream(string).filter(s -> !s.isEmpty()).map(s -> splitToStringList(s, mapper)).filter(l -> l != null && !l.isEmpty()).collect((Collector<? super Object, ?, List<List<String>>>)Collectors.toList());
    }
    
    public static void splitToStringListList(final String string, final Function<String, String> mapper, @Nonnull final Collection<Collection<String>> result, @Nonnull final Supplier<Collection<String>> supplier) {
        final Stream<Object> filter = StringListHelpers.listListSplitter.splitAsStream(string).filter(s -> !s.isEmpty()).map(s -> {
            final Collection<String> r = supplier.get();
            splitToStringList(s, mapper, r);
            return r;
        }).filter(l -> l != null && !l.isEmpty());
        Objects.requireNonNull(result);
        filter.forEachOrdered(result::add);
    }
    
    @Nonnull
    public static Set<String> stringListToStringSet(@Nonnull final List<String> list) {
        return new HashSet<String>(list);
    }
    
    @Nonnull
    public static Set<String> splitToStringSet(@Nullable final String input) {
        if (input == null || input.isEmpty()) {
            return Collections.emptySet();
        }
        final List<String> list = splitToStringList(input, null);
        return new HashSet<String>(list);
    }
    
    @Nonnull
    public static <T> Set<T> splitToStringSet(@Nullable final String input, final Function<String, T> transform) {
        if (input == null || input.isEmpty()) {
            return Collections.emptySet();
        }
        return splitToStringList(input, null).stream().map((Function<? super Object, ?>)transform).collect((Collector<? super Object, ?, Set<T>>)Collectors.toSet());
    }
    
    @Nonnull
    public static List<Set<String>> stringListListToStringSetList(@Nonnull final List<List<String>> group) {
        return group.stream().map((Function<? super Object, ?>)HashSet::new).collect((Collector<? super Object, ?, List<Set<String>>>)Collectors.toList());
    }
    
    static {
        StringListHelpers.listSplitter = Pattern.compile("[,; \t]");
        StringListHelpers.listListSplitter = Pattern.compile("\\|");
    }
}