package au.id.zancanaro;

import java.util.Iterator;
import java.util.function.Function;

public final class Iterators {
    public static <T> RangeIterator<T> rangeIterator(int countTo, Function<Integer,T> fn) {
        return new RangeIterator<T>(countTo, fn);
    }

    private static class RangeIterator<T> implements Iterator<T> {
        private final Function<Integer, T> action;
        private final int countTo;
        private int index = 0;

        public RangeIterator(int countTo, Function<Integer, T> action) {
            this.countTo = countTo;
            this.action = action;
        }

        @Override
        public boolean hasNext() {
            return index < countTo;
        }

        @Override
        public T next() {
            return action.apply(index++);
        }
    }

    public static <T> FlattenIterator<T> flatten(Iterator<Iterator<T>> iterators) {
        return new FlattenIterator<>(iterators);
    }
    public static class FlattenIterator<T> implements Iterator<T> {
        private Iterator<T> current;

        private Iterator<Iterator<T>> iterators;

        public FlattenIterator(Iterator<Iterator<T>> iterators) {
            this.current = Iterators.emptyIterator();
            this.iterators = iterators;
        }

        private Iterator<T> getCurrent() {
            while (!current.hasNext() && iterators.hasNext()) {
                current = iterators.next();
            }
            return current;
        }

        @Override
        public boolean hasNext() {
            return getCurrent().hasNext();
        }
        @Override
        public T next() {
            return getCurrent().next();
        }

    }

    public static <T> ConcatIterator<T> concat(Iterator<T> left, Iterator<T> right) {
        return new ConcatIterator<>(left, right);
    }
    public static class ConcatIterator<T> implements Iterator<T> {
        private final Iterator<T> left;

        private final Iterator<T> right;

        public ConcatIterator(Iterator<T> left, Iterator<T> right) {
            this.left = left;
            this.right = right;
        }

        @Override
        public boolean hasNext() {
            return left.hasNext() || right.hasNext();
        }
        @Override
        public T next() {
            if (left.hasNext()) {
                return left.next();
            } else {
                return right.next();
            }
        }

    }

    public static <T> EmptyIterator<T> emptyIterator() {
        return new EmptyIterator<>();
    }
    public static class EmptyIterator<T> implements Iterator<T> {

        @Override
        public boolean hasNext() {
            return false;
        }
        @Override
        public T next() {
            return null;
        }

    }

    public static <T,R> MappingIterator<T,R> mappingIterator(Function<T,R> f, Iterator<T> iterator) {
        return new MappingIterator<>(f, iterator);
    }
    private static class MappingIterator<T, R> implements Iterator<R> {
        private final Function<T, R> mapping;

        private final Iterator<T> iterator;

        public MappingIterator(Function<T, R> mapping, Iterator<T> iterator) {
            this.mapping = mapping;
            this.iterator = iterator;
        }

        @Override
        public boolean hasNext() {
            return iterator.hasNext();
        }
        @Override
        public R next() {
            return mapping.apply(iterator.next());
        }

    }
}