// Generated by delombok at Sat Feb 25 17:58:34 UTC 2023
package io.cui.tools.string;

import static io.cui.tools.collect.CollectionLiterals.mutableList;
import static io.cui.tools.collect.MoreCollections.isEmpty;
import static io.cui.tools.string.MoreStrings.isBlank;
import static java.util.Objects.requireNonNull;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.stream.Collectors;
import io.cui.tools.logging.CuiLogger;
import lombok.NonNull;

/**
 * Inspired by Googles Joiner.
 * <p>
 * It uses internally the {@link String#join(CharSequence, Iterable)} implementation
 * of java and provides a guava like wrapper. It focuses on the simplified Joining
 * and omits the Map based variants.
 * </p>
 * <h2>Usage</h2>
 *
 * <pre>
 * assertEquals("key=value", Joiner.on('=').join("key", "value"));
 * assertEquals("key=no value", Joiner.on('=').useForNull("no value").join("key", null));
 * assertEquals("key", Joiner.on('=').skipNulls().join("key", null));
 * assertEquals("key", Joiner.on('=').skipEmptyStrings().join("key", ""));
 * assertEquals("key", Joiner.on('=').skipBlankStrings().join("key", " "));
 * </pre>
 *
 * <h2>Migrating from Guava</h2>
 * <p>
 * In order to migrate for most case you only need to replace the package name on the import.
 * </p>
 * <h2>Changes to Guavas-Joiner</h2>
 * <p>
 * In case of content to be joined containing {@code null}-values and not set to skip nulls,
 * {@link #skipNulls()} it does not throw an
 * {@link NullPointerException} but writes "null" for each {@code null} element. You can define a
 * different String by calling {@link #useForNull(String)}
 * </p>
 * <p>
 * In addition to {@link #skipEmptyStrings()} it provides a variant {@link #skipBlankStrings()}
 * </p>
 *
 * @author Oliver Wolff
 */
public final class Joiner {
    private static final CuiLogger log = new CuiLogger(Joiner.class);
    @NonNull
    private final JoinerConfig joinerConfig;

    /**
     * Returns a Joiner that uses the given fixed string as a separator. For example, {@code
     * Joiner.on("-").join("foo", "bar")} returns a String "foo-bar"
     *
     * @param separator the literal, nonempty string to recognize as a separator
     *
     * @return a {@link Joiner}, with default settings, that uses that separator
     */
    public static Joiner on(final String separator) {
        requireNonNull(separator);
        return new Joiner(JoinerConfig.builder().separator(separator).build());
    }

    /**
     * Returns a Joiner that uses the given fixed string as a separator. For example, {@code
     * Joiner.on('-').join("foo", "bar")} returns a String "foo-bar"
     *
     * @param separator the literal, nonempty string to recognize as a separator
     *
     * @return a {@link Joiner}, with default settings, that uses that separator
     */
    public static Joiner on(final char separator) {
        requireNonNull(separator);
        return on(String.valueOf(separator));
    }

    /**
     * @param nullText to be used as substitution for {@code null} elements
     * @return a joiner with the same behavior as this one, except automatically substituting {@code
     * nullText} for any provided null elements.
     */
    public Joiner useForNull(final String nullText) {
        return new Joiner(joinerConfig.copy().useForNull(nullText).build());
    }

    /**
     * @return a joiner with the same behavior as this one, except automatically skipping
     *         null-values
     */
    public Joiner skipNulls() {
        return new Joiner(joinerConfig.copy().skipNulls(true).build());
    }

    /**
     * @return a joiner with the same behavior as this one, except automatically skipping
     *         String-values that evaluate to an empty String
     */
    public Joiner skipEmptyStrings() {
        return new Joiner(joinerConfig.copy().skipEmpty(true).build());
    }

    /**
     * @return a joiner with the same behavior as this one, except automatically skipping
     *         String-values that evaluate to a blank String as defined within
     *         {@link MoreStrings#isBlank(CharSequence)}
     */
    public Joiner skipBlankStrings() {
        return new Joiner(joinerConfig.copy().skipBlank(true).build());
    }

    /**
     * @param parts to be joined
     *
     * @return a string containing the string representation of each of {@code parts}, using the
     *         previously configured separator between each.
     */
    public String join(Iterable<?> parts) {
        return doJoin(parts);
    }

    /**
     * @param parts to be joined
     *
     * @return a string containing the string representation of each of {@code parts}, using the
     *         previously configured separator between each.
     */
    public String join(Iterator<?> parts) {
        return doJoin(mutableList(parts));
    }

    /**
     * @param parts to be joined
     * @return a string containing the string representation of each of {@code parts}, using the
     *         previously configured separator between each.
     */
    public String join(Object... parts) {
        return doJoin(mutableList(parts));
    }

    private String doJoin(Iterable<?> parts) {
        log.trace("Joining elements with configuration {}", joinerConfig);
        if (isEmpty(parts)) {
            return "";
        }
        var builder = new ArrayList<CharSequence>();
        for (Object element : parts) {
            if (null == element) {
                if (!joinerConfig.isSkipNulls()) {
                    builder.add(joinerConfig.getUseForNull());
                }
            } else if (element instanceof CharSequence) {
                builder.add((CharSequence) element);
            } else {
                builder.add(MoreStrings.lenientToString(element));
            }
        }
        if (joinerConfig.isSkipEmpty()) {
            builder = builder.stream().filter(element -> !MoreStrings.isEmpty(element)).collect(Collectors.toCollection(ArrayList::new));
        }
        if (joinerConfig.isSkipBlank()) {
            builder = builder.stream().filter(element -> !isBlank(element)).collect(Collectors.toCollection(ArrayList::new));
        }
        return String.join(joinerConfig.getSeparator(), builder);
    }

    @java.lang.SuppressWarnings("all")
    @lombok.Generated
    Joiner(@NonNull final JoinerConfig joinerConfig) {
        if (joinerConfig == null) {
            throw new java.lang.NullPointerException("joinerConfig is marked non-null but is null");
        }
        this.joinerConfig = joinerConfig;
    }
}