package org.shedlang.compiler.util;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Comparator;
import java.util.List;
import java.util.function.BiFunction;
import java.util.function.Function;

public class Iterables {
    private Iterables() {
    }

    public interface OnElement<T, E extends Exception> {
        void accept(T value) throws E;
    }

    public interface Between<E extends Exception> {
        void call() throws E;
    }

    public static <T, U> List<U> filterToType(Iterable<T> iterable, Class<U> clazz) {
        var result = new ArrayList<U>();

        for (var element : iterable) {
            if (clazz.isInstance(element)) {
                result.add(clazz.cast(element));
            }
        }

        return result;
    }

    public static <T> T first(Iterable<T> iterable) {
        return iterable.iterator().next();
    }

    public static <T, R> R foldLeft(
        R initial,
        Iterable<T> iterable,
        BiFunction<R, T, R> combine
    ) {
        R result = initial;

        for (var element : iterable) {
            result = combine.apply(result, element);
        }

        return result;
    }

    public static <T, E extends Exception> void forEachInterspersed(
        Iterable<T> values,
        OnElement<T, E> onElement,
        Between<E> between
    ) throws E {
        var first = true;
        for (var value : values) {
            if (!first) {
                between.call();
            }
            onElement.accept(value);
            first = false;
        }
    }

    public static <T, K extends Comparable<? super K>> List<T> sortedBy(
        Collection<T> collection,
        Function<? super T, ? extends K> key
    ) {
        return collection.stream().sorted(Comparator.comparing(key)).toList();
    }
}