/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

package jdk.internal.net.http.hpack;

import java.nio.ByteBuffer;

import java.util.*;

import java.util.function.Consumer;

import java.util.function.Function;

import java.util.function.Supplier;

import static java.nio.ByteBuffer.allocate;

public final class BuffersTestingKit {

    /**

     * Relocates a {@code [position, limit)} region of the given buffer to

     * corresponding region in a new buffer starting with provided {@code

     * newPosition}.

     *

     * <p> Might be useful to make sure ByteBuffer's users do not rely on any

     * absolute positions, but solely on what's reported by position(), limit().

     *

     * <p> The contents between the given buffer and the returned one are not

     * shared.

     */

    public static ByteBuffer relocate(ByteBuffer buffer, int newPosition,

                                      int newCapacity) {

        int oldPosition = buffer.position();

        int oldLimit = buffer.limit();

        if (newPosition + oldLimit - oldPosition > newCapacity) {

            throw new IllegalArgumentException();

        }

        ByteBuffer result;

        if (buffer.isDirect()) {

            result = ByteBuffer.allocateDirect(newCapacity);

        } else {

            result = allocate(newCapacity);

        }

        result.position(newPosition);

        result.put(buffer).limit(result.position()).position(newPosition);

        buffer.position(oldPosition);

        if (buffer.isReadOnly()) {

            return result.asReadOnlyBuffer();

        }

        return result;

    }

    public static Iterable<? extends ByteBuffer> relocateBuffers(

            Iterable<? extends ByteBuffer> source) {

        return () ->

                new Iterator<ByteBuffer>() {

                    private final Iterator<? extends ByteBuffer> it = source.iterator();

                    @Override

                    public boolean hasNext() {

                        return it.hasNext();

                    }

                    @Override

                    public ByteBuffer next() {

                        ByteBuffer buf = it.next();

                        int remaining = buf.remaining();

                        int newCapacity = remaining + random.nextInt(17);

                        int newPosition = random.nextInt(newCapacity - remaining + 1);

                        return relocate(buf, newPosition, newCapacity);

                    }

                };

    }

    // TODO: not always of size 0 (it's fine for buffer to report !b.hasRemaining())

    public static Iterable<? extends ByteBuffer> injectEmptyBuffers(

            Iterable<? extends ByteBuffer> source) {

        return injectEmptyBuffers(source, () -> allocate(0));

    }

    public static Iterable<? extends ByteBuffer> injectEmptyBuffers(

            Iterable<? extends ByteBuffer> source,

            Supplier<? extends ByteBuffer> emptyBufferFactory) {

        return () ->

                new Iterator<ByteBuffer>() {

                    private final Iterator<? extends ByteBuffer> it = source.iterator();

                    private ByteBuffer next = calculateNext();

                    private ByteBuffer calculateNext() {

                        if (random.nextBoolean()) {

                            return emptyBufferFactory.get();

                        } else if (it.hasNext()) {

                            return it.next();

                        } else {

                            return null;

                        }

                    }

                    @Override

                    public boolean hasNext() {

                        return next != null;

                    }

                    @Override

                    public ByteBuffer next() {

                        if (!hasNext()) {

                            throw new NoSuchElementException();

                        }

                        ByteBuffer next = this.next;

                        this.next = calculateNext();

                        return next;

                    }

                };

    }

    public static ByteBuffer concat(Iterable<? extends ByteBuffer> split) {

        return concat(split, ByteBuffer::allocate);

    }

    public static ByteBuffer concat(Iterable<? extends ByteBuffer> split,

                                    Function<? super Integer, ? extends ByteBuffer> concatBufferFactory) {

        int size = 0;

        for (ByteBuffer bb : split) {

            size += bb.remaining();

        }

        ByteBuffer result = concatBufferFactory.apply(size);

        for (ByteBuffer bb : split) {

            result.put(bb);

        }

        result.flip();

        return result;

    }

    public static void forEachSplit(ByteBuffer bb,

                                    Consumer<? super Iterable<? extends ByteBuffer>> action) {

        forEachSplit(bb.remaining(),

                (lengths) -> {

                    int end = bb.position();

                    List<ByteBuffer> buffers = new LinkedList<>();

                    for (int len : lengths) {

                        ByteBuffer d = bb.duplicate();

                        d.position(end);

                        d.limit(end + len);

                        end += len;

                        buffers.add(d);

                    }

                    action.accept(buffers);

                });

    }

    private static void forEachSplit(int n, Consumer<? super Iterable<? extends Integer>> action) {

        forEachSplit(n, new Stack<>(), action);

    }

    private static void forEachSplit(int n, Stack<Integer> path,

                                     Consumer<? super Iterable<? extends Integer>> action) {

        if (n == 0) {

            action.accept(path);

        } else {

            for (int i = 1; i <= n; i++) {

                path.push(i);

                forEachSplit(n - i, path, action);

                path.pop();

            }

        }

    }

    private static final Random random = new Random();

    private BuffersTestingKit() {

        throw new InternalError();

    }

//    public static void main(String[] args) {

//

//        List<ByteBuffer> buffers = Arrays.asList(

//                (ByteBuffer) allocate(3).position(1).limit(2),

//                allocate(0),

//                allocate(7));

//

//        Iterable<? extends ByteBuffer> buf = relocateBuffers(injectEmptyBuffers(buffers));

//        List<ByteBuffer> result = new ArrayList<>();

//        buf.forEach(result::add);

//        System.out.println(result);

//    }

}