/*
 * Copyright (c) 2020, 2022, Oracle and/or its affiliates. All rights reserved.
 * 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.
 */

import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodHandles;
import java.lang.invoke.MethodType;
import java.nio.Buffer;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.CharBuffer;
import java.nio.DoubleBuffer;
import java.nio.FloatBuffer;
import java.nio.IntBuffer;
import java.nio.LongBuffer;
import java.nio.ReadOnlyBufferException;
import java.nio.ShortBuffer;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Random;

import org.testng.Assert;
import org.testng.annotations.DataProvider;
import org.testng.annotations.Test;


/*
 * @test
 * @bug 8219014 8245121
 * @summary Ensure that a bulk put of a buffer into another is correct.
 * @compile BulkPutBuffer.java
 * @run testng/othervm BulkPutBuffer
 */
public class BulkPutBuffer {
    static final long SEED = System.nanoTime();
    static final MyRandom RND = new MyRandom(SEED);

    static final int ITERATIONS = 100;
    static final int MAX_CAPACITY = 1024;

    static class MyRandom extends Random {
        MyRandom(long seed) {
            super(seed);
        }

        public byte nextByte() {
            return (byte)next(8);
        }

        public char nextChar() {
            return (char)next(16);
        }

        public short nextShort() {
            return (short)next(16);
        }
    }

    enum BufferKind {
        HEAP,
        HEAP_VIEW,
        DIRECT,
        STRING;
    }

    static final Map<Class<?>,TypeAttr> typeToAttr;

    static record TypeAttr(Class<?> type, int bytes, String name) {}

    static {
        typeToAttr = Map.of(
            byte.class, new TypeAttr(ByteBuffer.class, Byte.BYTES, "Byte"),
            char.class, new TypeAttr(CharBuffer.class, Character.BYTES, "Char"),
            short.class, new TypeAttr(ShortBuffer.class, Short.BYTES, "Short"),
            int.class, new TypeAttr(IntBuffer.class, Integer.BYTES, "Int"),
            float.class, new TypeAttr(FloatBuffer.class, Float.BYTES, "Float"),
            long.class, new TypeAttr(LongBuffer.class, Long.BYTES, "Long"),
            double.class, new TypeAttr(DoubleBuffer.class, Double.BYTES, "Double")
        );
    }

    static BufferKind[] getKinds(Class<?> elementType) {
        BufferKind[] kinds;
        if (elementType == byte.class)
            kinds = new BufferKind[] {
                BufferKind.DIRECT,
                BufferKind.HEAP
            };
        else if (elementType == char.class)
            kinds = BufferKind.values();
        else
            kinds = new BufferKind[] {
                BufferKind.DIRECT,
                BufferKind.HEAP,
                BufferKind.HEAP_VIEW
            };
        return kinds;
    }

    static ByteOrder[] getOrders(BufferKind kind, Class<?> elementType) {
        switch (kind) {
            case HEAP:
                return new ByteOrder[] { ByteOrder.nativeOrder() };
            default:
                if (elementType == byte.class)
                    return new ByteOrder[] { ByteOrder.nativeOrder() };
                else
                    return new ByteOrder[] { ByteOrder.BIG_ENDIAN,
                        ByteOrder.LITTLE_ENDIAN };
        }
    }

    public static class BufferProxy {
        final Class<?> elementType;
        final BufferKind kind;
        final ByteOrder order;

        // Buffer methods
        MethodHandle alloc;
        MethodHandle allocBB;
        MethodHandle allocDirect;
        MethodHandle asReadOnlyBuffer;
        MethodHandle asTypeBuffer;
        MethodHandle putAbs;
        MethodHandle getAbs;
        MethodHandle putBufAbs;
        MethodHandle putBufRel;
        MethodHandle equals;

        // MyRandom method
        MethodHandle nextType;

        BufferProxy(Class<?> elementType, BufferKind kind, ByteOrder order) {
            this.elementType = elementType;
            this.kind = kind;
            this.order = order;

            Class<?> bufferType = typeToAttr.get(elementType).type;

            var lookup = MethodHandles.lookup();
            try {
                String name = typeToAttr.get(elementType).name;

                alloc = lookup.findStatic(bufferType, "allocate",
                    MethodType.methodType(bufferType, int.class));
                allocBB = lookup.findStatic(ByteBuffer.class, "allocate",
                    MethodType.methodType(ByteBuffer.class, int.class));
                allocDirect = lookup.findStatic(ByteBuffer.class, "allocateDirect",
                    MethodType.methodType(ByteBuffer.class, int.class));

                asReadOnlyBuffer = lookup.findVirtual(bufferType,
                        "asReadOnlyBuffer", MethodType.methodType(bufferType));
                if (elementType != byte.class) {
                    asTypeBuffer = lookup.findVirtual(ByteBuffer.class,
                        "as" + name + "Buffer", MethodType.methodType(bufferType));
                }

                putAbs = lookup.findVirtual(bufferType, "put",
                    MethodType.methodType(bufferType, int.class, elementType));
                getAbs = lookup.findVirtual(bufferType, "get",
                    MethodType.methodType(elementType, int.class));

                putBufAbs = lookup.findVirtual(bufferType, "put",
                    MethodType.methodType(bufferType, int.class, bufferType,
                        int.class, int.class));
                putBufRel = lookup.findVirtual(bufferType, "put",
                    MethodType.methodType(bufferType, bufferType));

                equals = lookup.findVirtual(bufferType, "equals",
                    MethodType.methodType(boolean.class, Object.class));

                nextType = lookup.findVirtual(MyRandom.class,
                     "next" + name, MethodType.methodType(elementType));
            } catch (IllegalAccessException | NoSuchMethodException e) {
                throw new AssertionError(e);
            }
        }

        Buffer create(int capacity) throws Throwable {

            Class<?> bufferType = typeToAttr.get(elementType).type;

            try {
                if (bufferType == ByteBuffer.class ||
                    kind == BufferKind.DIRECT || kind == BufferKind.HEAP_VIEW) {
                    int len = capacity*typeToAttr.get(elementType).bytes;
                    ByteBuffer bb = (ByteBuffer)allocBB.invoke(len);
                    byte[] bytes = new byte[len];
                    RND.nextBytes(bytes);
                    bb.put(0, bytes);
                    if (bufferType == ByteBuffer.class) {
                        return (Buffer)bb;
                    } else {
                        bb.order(order);
                        return (Buffer)asTypeBuffer.invoke(bb);
                    }
                } else if (bufferType == CharBuffer.class &&
                    kind == BufferKind.STRING) {
                    char[] array = new char[capacity];
                    for (int i = 0; i < capacity; i++) {
                        array[i] = RND.nextChar();
                    }
                    return CharBuffer.wrap(new String(array));
                } else {
                    Buffer buf = (Buffer)alloc.invoke(capacity);
                    for (int i = 0; i < capacity; i++) {
                        putAbs.invoke(buf, i, nextType.invoke(RND));
                    }
                    return buf;
                }
            } catch (Exception e) {
                throw new AssertionError(e);
            }
        }

        void copy(Buffer src, int srcOff, Buffer dst, int dstOff, int length)
            throws Throwable {
            try {
                for (int i = 0; i < length; i++) {
                    putAbs.invoke(dst, dstOff + i, getAbs.invoke(src, srcOff + i));
                }
            } catch (ReadOnlyBufferException ro) {
                throw ro;
            } catch (Exception e) {
                throw new AssertionError(e);
            }
        }

        Buffer asReadOnlyBuffer(Buffer buf) throws Throwable {
            try {
                return (Buffer)asReadOnlyBuffer.invoke(buf);
            } catch (Exception e) {
                throw new AssertionError(e);
            }
        }

        void put(Buffer src, int srcOff, Buffer dst, int dstOff, int length)
            throws Throwable {
            try {
                putBufAbs.invoke(dst, dstOff, src, srcOff, length);
            } catch (ReadOnlyBufferException ro) {
                throw ro;
            } catch (Exception e) {
                throw new AssertionError(e);
            }
        }

        void put(Buffer src, Buffer dst) throws Throwable {
            try {
                putBufRel.invoke(dst, src);
            } catch (ReadOnlyBufferException ro) {
                throw ro;
            } catch (Exception e) {
                throw new AssertionError(e);
            }
        }

        boolean equals(Buffer src, Buffer dst) throws Throwable {
            try {
                return Boolean.class.cast(equals.invoke(dst, src));
            } catch (Exception e) {
                throw new AssertionError(e);
            }
        }
    }

    static List<BufferProxy> getProxies(Class<?> type) {
        List proxies = new ArrayList();
        for (BufferKind kind : getKinds(type)) {
            for (ByteOrder order : getOrders(kind, type)) {
                proxies.add(new BufferProxy(type, kind, order));
            }
        }
        return proxies;
    }

    @DataProvider
    static Object[][] proxies() {
        ArrayList<Object[]> args = new ArrayList<>();
        for (Class<?> type : typeToAttr.keySet()) {
            List<BufferProxy> proxies = getProxies(type);
            for (BufferProxy proxy : proxies) {
                args.add(new Object[] {proxy});
            }
        }
        return args.toArray(Object[][]::new);
    }

    @DataProvider
    static Object[][] proxyPairs() {
        List<Object[]> args = new ArrayList<>();
        for (Class<?> type : typeToAttr.keySet()) {
            List<BufferProxy> proxies = getProxies(type);
            for (BufferProxy proxy1 : proxies) {
                for (BufferProxy proxy2 : proxies) {
                    args.add(new Object[] {proxy1, proxy2});
                }
            }
        }
        return args.toArray(Object[][]::new);
    }

    private static void expectThrows(Class<?> exClass, Assert.ThrowingRunnable r) {
        try {
            r.run();
        } catch(Throwable e) {
            if (e.getClass() != exClass && e.getCause().getClass() != exClass) {
                throw new RuntimeException("Expected " + exClass +
                "; got " + e.getCause().getClass(), e);
            }
        }
    }

    @Test(dataProvider = "proxies")
    public static void testExceptions(BufferProxy bp) throws Throwable {
        int cap = 27;
        Buffer buf = bp.create(cap);

        expectThrows(IndexOutOfBoundsException.class,
            () -> bp.put(buf, -1, buf, 0, 1));
        expectThrows(IndexOutOfBoundsException.class,
            () -> bp.put(buf, 0, buf, -1, 1));
        expectThrows(IndexOutOfBoundsException.class,
            () -> bp.put(buf, 1, buf, 0, cap));
        expectThrows(IndexOutOfBoundsException.class,
            () -> bp.put(buf, 0, buf, 1, cap));
        expectThrows(IndexOutOfBoundsException.class,
            () -> bp.put(buf, 0, buf, 0, cap + 1));
        expectThrows(IndexOutOfBoundsException.class,
            () -> bp.put(buf, 0, buf, 0, Integer.MAX_VALUE));

        Buffer rob = buf.isReadOnly() ? buf : bp.asReadOnlyBuffer(buf);
        expectThrows(ReadOnlyBufferException.class,
            () -> bp.put(buf, 0, rob, 0, cap));
    }

    @Test(dataProvider = "proxies")
    public static void testSelf(BufferProxy bp) throws Throwable {
        for (int i = 0; i < ITERATIONS; i++) {
            int cap = RND.nextInt(MAX_CAPACITY);
            Buffer buf = bp.create(cap);

            int lowerOffset = RND.nextInt(1 + cap/10);
            int lowerLength = RND.nextInt(1 + cap/2);
            if (lowerLength < 2)
                continue;
            Buffer lower = buf.slice(lowerOffset, lowerLength);

            Buffer lowerCopy = bp.create(lowerLength);
            if (lowerCopy.isReadOnly()) {
                Assert.expectThrows(ReadOnlyBufferException.class,
                    () -> bp.copy(lower, 0, lowerCopy, 0, lowerLength));
                break;
            }
            bp.copy(lower, 0, lowerCopy, 0, lowerLength);

            int middleOffset = RND.nextInt(1 + cap/2);
            Buffer middle = buf.slice(middleOffset, lowerLength);
            Buffer middleCopy = bp.create(lowerLength);
            bp.copy(middle, 0, middleCopy, 0, lowerLength);

            bp.put(lower, middle);
            middle.flip();

            Assert.assertTrue(bp.equals(lowerCopy, middle),
                String.format("%d %s %d %d %d %d%n", SEED,
                    buf.getClass().getName(), cap,
                    lowerOffset, lowerLength, middleOffset));

            bp.copy(lowerCopy, 0, buf, lowerOffset, lowerLength);
            bp.copy(middleCopy, 0, buf, middleOffset, lowerLength);

            bp.put(buf, lowerOffset, buf, middleOffset, lowerLength);

            Assert.assertTrue(bp.equals(lowerCopy, middle),
                String.format("%d %s %d %d %d %d%n", SEED,
                    buf.getClass().getName(), cap,
                    lowerOffset, lowerLength, middleOffset));
        }
    }

    @Test(dataProvider = "proxyPairs")
    public static void testPairs(BufferProxy bp, BufferProxy sbp) throws Throwable {
        for (int i = 0; i < ITERATIONS; i++) {
            int cap = Math.max(4, RND.nextInt(MAX_CAPACITY));
            int cap2 = cap/2;
            Buffer buf = bp.create(cap);

            int pos = RND.nextInt(Math.max(1, cap2));
            buf.position(pos);
            buf.mark();
            int lim = pos + Math.max(1, cap - pos);
            buf.limit(lim);

            int scap = Math.max(buf.remaining(), RND.nextInt(1024));
            Buffer src = sbp.create(scap);

            int diff = scap - buf.remaining();
            int spos = diff > 0 ? RND.nextInt(diff) : 0;
            src.position(spos);
            src.mark();
            int slim = spos + buf.remaining();
            src.limit(slim);

            if (buf.isReadOnly()) {
                Assert.expectThrows(ReadOnlyBufferException.class,
                    () -> bp.put(src, buf));
                break;
            }

            Buffer backup = bp.create(slim - spos);
            bp.copy(buf, pos, backup, 0, backup.capacity());
            bp.put(src, buf);

            buf.reset();
            src.reset();

            Assert.assertTrue(bp.equals(src, buf),
                String.format("%d %s %d %d %d %s %d %d %d%n", SEED,
                    buf.getClass().getName(), cap, pos, lim,
                    src.getClass().getName(), scap, spos, slim));

            src.clear();
            buf.clear();
            bp.copy(backup, 0, buf, pos, backup.capacity());
            bp.put(src, spos, buf, pos, backup.capacity());
            src.position(spos);
            src.limit(slim);
            buf.position(pos);
            buf.limit(lim);

            Assert.assertTrue(bp.equals(src, buf),
                String.format("%d %s %d %d %d %s %d %d %d%n", SEED,
                    buf.getClass().getName(), cap, pos, lim,
                    src.getClass().getName(), scap, spos, slim));
        }
    }
}