package splititerator;

import java.util.List;
import java.util.Optional;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.Stream;

public class SplitIteratorFactoryImpl implements SplitIteratorFactory {

    private class SimpleSplitIterator<X> implements SplitIterator<X>{

        private List<X> datas;

        //Package-protected
        SimpleSplitIterator(Stream<X> source) {
            this.datas = source.collect(Collectors.toList());
        }

        protected List<X> getDatas(){
            return this.datas;
        }

        protected void setDatas(List<X> datas) {
            this.datas = datas;
        }

        @Override
        public Optional<X> next() {
            return Optional.ofNullable(this.datas.size() == 0 ? null : this.datas.remove(0));
        }

        @Override
        public SplitIterator<X> split() {
            throw new UnsupportedOperationException();
        }
    }

    private class SplitIteratorImpl<X> extends SimpleSplitIterator<X> {

        //Package-protected
        SplitIteratorImpl(Stream<X> source) {
            super(source);
        }

        @Override
        public SplitIterator<X> split() {
            List<X> splittedData = getDatas().subList(0, getDatas().size() / 2);
            setDatas(getDatas().subList(getDatas().size() / 2, getDatas().size()));
            return new SplitIteratorImpl<X>(splittedData.stream());
        }
    }

    @Override
    public SplitIterator<Integer> fromRange(int start, int stop) {
        return new SplitIteratorImpl<Integer>(IntStream.range(start, stop+1).mapToObj(i -> i));
    }

    @Override
    public SplitIterator<Integer> fromRangeNonSplit(int start, int stop) {
        return new SimpleSplitIterator<Integer>(IntStream.range(start, stop+1).mapToObj(i -> i));
    }

    @Override
    public <X> SplitIterator<X> fromList(List<X> list) {
        return new SplitIteratorImpl<>(list.stream());
    }

    @Override
    public <X> SplitIterator<X> fromListNonSplit(List<X> list) {
        return new SimpleSplitIterator<>(list.stream());
    }

    @Override
    public <X> SplitIterator<X> ignoreFirst(SplitIterator<X> source) {
        if(source instanceof SimpleSplitIterator) {
            SimpleSplitIterator<X> it = (SimpleSplitIterator<X>)source;
            Stream<X> newSource = it.getDatas().stream().skip(1);
            SimpleSplitIterator<X> res;
            if(source instanceof SplitIteratorImpl) {
                res = new SplitIteratorImpl<>(newSource);
            } else {
                res = new SimpleSplitIterator<>(newSource);
            }
            return res;
        }

        throw new UnsupportedOperationException();
    }

    @Override
    public <X, Y> SplitIterator<Y> map(SplitIterator<X> source, Function<X, Y> mapOp) {
        if(source instanceof SimpleSplitIterator) {
            SimpleSplitIterator<X> it = (SimpleSplitIterator<X>)source;
            Stream<Y> newSource = it.getDatas().stream().map(mapOp);
            SimpleSplitIterator<Y> res;
            if(source instanceof SplitIteratorImpl) {
                res = new SplitIteratorImpl<>(newSource);
            } else {
                res = new SimpleSplitIterator<>(newSource);
            }
            return res;
        }

        throw new UnsupportedOperationException();
    }

}