/*
 * Copyright 2021 The Netty Project
 *
 * The Netty Project licenses this file to you under the Apache License,
 * version 2.0 (the "License"); you may not use this file except in compliance
 * with the License. You may obtain a copy of the License at:
 *
 *   https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 * License for the specific language governing permissions and limitations
 * under the License.
 */
package io.netty.buffer.api.tests;

import io.netty.buffer.api.Buffer;
import io.netty.buffer.api.BufferAllocator;
import io.netty.buffer.api.BufferClosedException;
import io.netty.buffer.api.BufferReadOnlyException;
import io.netty.buffer.api.CompositeBuffer;
import io.netty.buffer.api.Send;
import io.netty.buffer.api.internal.ResourceSupport;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.MethodSource;

import static io.netty.buffer.api.internal.Statics.acquire;
import static io.netty.buffer.api.internal.Statics.isOwned;
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;

public class BufferCompositionTest extends BufferTestSupport {
    @Test
    public void compositeBuffersCannotHaveDuplicateComponents() {
        try (BufferAllocator allocator = BufferAllocator.onHeapUnpooled()) {
            Send<Buffer> a = allocator.allocate(4).send();
            var e = assertThrows(IllegalStateException.class, () -> CompositeBuffer.compose(allocator, a, a));
            assertThat(e).hasMessageContaining("already been received");

            Send<Buffer> b = allocator.allocate(4).send();
            try (CompositeBuffer composite = CompositeBuffer.compose(allocator, b)) {
                e = assertThrows(IllegalStateException.class, () -> composite.extendWith(b));
                assertThat(e).hasMessageContaining("already been received");
            }
        }
    }

    @Test
    public void compositeBufferFromSends() {
        try (BufferAllocator allocator = BufferAllocator.onHeapUnpooled();
             Buffer composite = CompositeBuffer.compose(allocator,
                     allocator.allocate(8).send(),
                     allocator.allocate(8).send(),
                     allocator.allocate(8).send())) {
            assertEquals(24, composite.capacity());
            assertTrue(isOwned((ResourceSupport<?, ?>) composite));
        }
    }

    @Test
    public void compositeBufferMustNotBeAllowedToContainThemselves() {
        try (BufferAllocator allocator = BufferAllocator.onHeapUnpooled()) {
            CompositeBuffer bufA = CompositeBuffer.compose(allocator, allocator.allocate(4).send());
            Send<Buffer> sendA = bufA.send();
            try {
                assertThrows(BufferClosedException.class, () -> bufA.extendWith(sendA));
            } finally {
                sendA.close();
            }

            CompositeBuffer bufB = CompositeBuffer.compose(allocator, allocator.allocate(4).send());
            Send<Buffer> sendB = bufB.send();
            try (CompositeBuffer compositeBuffer = CompositeBuffer.compose(allocator, sendB)) {
                assertThrows(IllegalStateException.class, () -> compositeBuffer.extendWith(sendB));
            } finally {
                sendB.close();
            }
        }
    }

    @ParameterizedTest
    @MethodSource("allocators")
    public void ensureWritableOnCompositeBuffersMustRespectExistingBigEndianByteOrder(Fixture fixture) {
        try (BufferAllocator allocator = fixture.createAllocator()) {
            Buffer composite;
            try (Buffer a = allocator.allocate(4)) {
                composite = CompositeBuffer.compose(allocator, a.send());
            }
            try (composite) {
                composite.writeInt(0x01020304);
                composite.ensureWritable(4);
                composite.writeInt(0x05060708);
                assertEquals(0x0102030405060708L, composite.readLong());
            }
        }
    }

    @Test
    public void extendOnNonCompositeBufferMustThrow() {
        try (BufferAllocator allocator = BufferAllocator.onHeapUnpooled();
             Buffer a = allocator.allocate(8);
             Buffer b = allocator.allocate(8)) {
            assertThrows(ClassCastException.class, () -> ((CompositeBuffer) a).extendWith(b.send()));
        }
    }

    @Test
    public void extendingNonOwnedCompositeBufferMustThrow() {
        try (BufferAllocator allocator = BufferAllocator.onHeapUnpooled();
             Buffer a = allocator.allocate(8);
             Buffer b = allocator.allocate(8);
             CompositeBuffer composed = CompositeBuffer.compose(allocator, a.send())) {
            try (Buffer ignore = acquire(composed)) {
                var exc = assertThrows(IllegalStateException.class, () -> composed.extendWith(b.send()));
                assertThat(exc).hasMessageContaining("owned");
            }
        }
    }

    @Test
    public void extendingCompositeBufferWithItselfMustThrow() {
        try (BufferAllocator allocator = BufferAllocator.onHeapUnpooled()) {
            CompositeBuffer composite;
            try (Buffer a = allocator.allocate(8)) {
                composite = CompositeBuffer.compose(allocator, a.send());
            }
            try (composite) {
                assertThrows(BufferClosedException.class, () -> composite.extendWith(composite.send()));
            }
        }
    }

    @Test
    public void extendingWithZeroCapacityBufferHasNoEffect() {
        try (BufferAllocator allocator = BufferAllocator.onHeapUnpooled();
             CompositeBuffer composite = CompositeBuffer.compose(allocator)) {
            composite.extendWith(CompositeBuffer.compose(allocator).send());
            assertThat(composite.capacity()).isZero();
            assertThat(composite.countComponents()).isZero();
        }
        try (BufferAllocator allocator = BufferAllocator.onHeapUnpooled()) {
            Buffer a = allocator.allocate(1);
            CompositeBuffer composite = CompositeBuffer.compose(allocator, a.send());
            assertTrue(isOwned(composite));
            assertThat(composite.capacity()).isOne();
            assertThat(composite.countComponents()).isOne();
            try (Buffer b = CompositeBuffer.compose(allocator)) {
                composite.extendWith(b.send());
            }
            assertTrue(isOwned(composite));
            assertThat(composite.capacity()).isOne();
            assertThat(composite.countComponents()).isOne();
        }
    }

    @Test
    public void extendingCompositeBufferWithNullMustThrow() {
        try (BufferAllocator allocator = BufferAllocator.onHeapUnpooled();
             CompositeBuffer composite = CompositeBuffer.compose(allocator)) {
            assertThrows(NullPointerException.class, () -> composite.extendWith(null));
        }
    }

    @Test
    public void extendingCompositeBufferMustIncreaseCapacityByGivenBuffer() {
        try (BufferAllocator allocator = BufferAllocator.onHeapUnpooled();
             CompositeBuffer composite = CompositeBuffer.compose(allocator)) {
            assertThat(composite.capacity()).isZero();
            try (Buffer buf = allocator.allocate(8)) {
                composite.extendWith(buf.send());
            }
            assertThat(composite.capacity()).isEqualTo(8);
            composite.writeLong(0x0102030405060708L);
            assertThat(composite.readLong()).isEqualTo(0x0102030405060708L);
        }
    }

    @Test
    public void emptyCompositeBufferMustAllowExtendingWithBuffer() {
        try (BufferAllocator allocator = BufferAllocator.onHeapUnpooled()) {
            try (CompositeBuffer composite = CompositeBuffer.compose(allocator)) {
                try (Buffer b = allocator.allocate(8)) {
                    composite.extendWith(b.send());
                    assertThat(composite.capacity()).isEqualTo(8);
                }
            }
        }
    }

    @Test
    public void emptyCompositeBufferMustAllowExtendingWithReadOnlyBuffer() {
        try (BufferAllocator allocator = BufferAllocator.onHeapUnpooled()) {
            try (CompositeBuffer composite = CompositeBuffer.compose(allocator)) {
                try (Buffer b = allocator.allocate(8).makeReadOnly()) {
                    composite.extendWith(b.send());
                    assertTrue(composite.readOnly());
                }
            }
        }
    }

    @Test
    public void whenExtendingCompositeBufferWithWriteOffsetAtCapacityExtensionWriteOffsetCanBeNonZero() {
        try (BufferAllocator allocator = BufferAllocator.onHeapUnpooled()) {
            CompositeBuffer composite;
            try (Buffer a = allocator.allocate(8)) {
                composite = CompositeBuffer.compose(allocator, a.send());
            }
            try (composite) {
                composite.writeLong(0);
                try (Buffer b = allocator.allocate(8)) {
                    b.writeInt(1);
                    composite.extendWith(b.send());
                    assertThat(composite.capacity()).isEqualTo(16);
                    assertThat(composite.writerOffset()).isEqualTo(12);
                }
            }
        }
    }

    @Test
    public void whenExtendingCompositeBufferWithWriteOffsetLessThanCapacityExtensionWriteOffsetMustZero() {
        try (BufferAllocator allocator = BufferAllocator.onHeapUnpooled()) {
            CompositeBuffer composite;
            try (Buffer a = allocator.allocate(8)) {
                composite = CompositeBuffer.compose(allocator, a.send());
            }
            try (composite) {
                composite.writeInt(0);
                try (Buffer b = allocator.allocate(8)) {
                    b.writeInt(1);
                    var exc = assertThrows(IllegalArgumentException.class,
                            () -> composite.extendWith(b.send()));
                    assertThat(exc).hasMessageContaining("unwritten gap");
                }
                try (Buffer b = allocator.allocate(8)) {
                    b.setInt(0, 1);
                    composite.extendWith(b.send());
                    assertThat(composite.capacity()).isEqualTo(16);
                    assertThat(composite.writerOffset()).isEqualTo(4);
                }
            }
        }
    }

    @Test
    public void whenExtendingCompositeBufferWithReadOffsetAtCapacityExtensionReadOffsetCanBeNonZero() {
        try (BufferAllocator allocator = BufferAllocator.onHeapUnpooled()) {
            CompositeBuffer composite;
            try (Buffer a = allocator.allocate(8)) {
                composite = CompositeBuffer.compose(allocator, a.send());
            }
            try (composite) {
                composite.writeLong(0);
                composite.readLong();
                try (Buffer b = allocator.allocate(8)) {
                    b.writeInt(1);
                    b.readInt();
                    composite.extendWith(b.send());
                    assertThat(composite.capacity()).isEqualTo(16);
                    assertThat(composite.writerOffset()).isEqualTo(12);
                }
            }
        }
    }

    @Test
    public void whenExtendingCompositeBufferWithReadOffsetLessThanCapacityExtensionReadOffsetMustZero() {
        try (BufferAllocator allocator = BufferAllocator.onHeapUnpooled();
             CompositeBuffer composite = CompositeBuffer.compose(allocator, allocator.allocate(8).send())) {
            composite.writeLong(0);
            composite.readInt();

            Buffer b = allocator.allocate(8);
            b.writeInt(1);
            b.readInt();
            var exc = assertThrows(IllegalArgumentException.class,
                    () -> composite.extendWith(b.send()));
            assertThat(exc).hasMessageContaining("unread gap");
            assertThat(composite.capacity()).isEqualTo(8);
            assertThat(composite.writerOffset()).isEqualTo(8);
            assertThat(composite.readerOffset()).isEqualTo(4);

            composite.extendWith(allocator.allocate(8).writeInt(1).send());
            assertThat(composite.capacity()).isEqualTo(16);
            assertThat(composite.writerOffset()).isEqualTo(12);
            assertThat(composite.readerOffset()).isEqualTo(4);
        }
    }

    @Test
    public void composingReadOnlyBuffersMustCreateReadOnlyCompositeBuffer() {
        try (BufferAllocator allocator = BufferAllocator.onHeapUnpooled();
             Buffer a = allocator.allocate(4).makeReadOnly();
             Buffer b = allocator.allocate(4).makeReadOnly();
             Buffer composite = CompositeBuffer.compose(allocator, a.send(), b.send())) {
            assertTrue(composite.readOnly());
            verifyWriteInaccessible(composite, BufferReadOnlyException.class);
        }
    }

    @Test
    public void composingReadOnlyAndWritableBuffersMustThrow() {
        try (BufferAllocator allocator = BufferAllocator.onHeapUnpooled()) {
            try (Buffer a = allocator.allocate(8).makeReadOnly();
                 Buffer b = allocator.allocate(8)) {
                assertThrows(IllegalArgumentException.class,
                             () -> CompositeBuffer.compose(allocator, a.send(), b.send()));
            }
            try (Buffer a = allocator.allocate(8).makeReadOnly();
                 Buffer b = allocator.allocate(8)) {
                assertThrows(IllegalArgumentException.class,
                             () -> CompositeBuffer.compose(allocator, b.send(), a.send()));
            }
            try (Buffer a = allocator.allocate(8).makeReadOnly();
                 Buffer b = allocator.allocate(8);
                 Buffer c = allocator.allocate(8).makeReadOnly()) {
                assertThrows(IllegalArgumentException.class,
                        () -> CompositeBuffer.compose(allocator, a.send(), b.send(), c.send()));
            }
            try (Buffer a = allocator.allocate(8).makeReadOnly();
                 Buffer b = allocator.allocate(8);
                 Buffer c = allocator.allocate(8)) {
                assertThrows(IllegalArgumentException.class,
                        () -> CompositeBuffer.compose(allocator, b.send(), a.send(), c.send()));
            }
        }
    }

    @Test
    public void compositeWritableBufferCannotBeExtendedWithReadOnlyBuffer() {
        try (BufferAllocator allocator = BufferAllocator.onHeapUnpooled()) {
            CompositeBuffer composite;
            try (Buffer a = allocator.allocate(8)) {
                composite = CompositeBuffer.compose(allocator, a.send());
            }
            try (composite; Buffer b = allocator.allocate(8).makeReadOnly()) {
                assertThrows(IllegalArgumentException.class, () -> composite.extendWith(b.send()));
            }
        }
    }

    @Test
    public void compositeReadOnlyBufferCannotBeExtendedWithWritableBuffer() {
        try (BufferAllocator allocator = BufferAllocator.onHeapUnpooled()) {
            CompositeBuffer composite;
            try (Buffer a = allocator.allocate(8).makeReadOnly()) {
                composite = CompositeBuffer.compose(allocator, a.send());
            }
            try (composite; Buffer b = allocator.allocate(8)) {
                assertThrows(IllegalArgumentException.class, () -> composite.extendWith(b.send()));
            }
        }
    }

    @Test
    public void splitComponentsFloorMustThrowOnOutOfBounds() {
        try (BufferAllocator allocator = BufferAllocator.onHeapUnpooled();
             CompositeBuffer composite = CompositeBuffer.compose(allocator,
                     allocator.allocate(8).send(),
                     allocator.allocate(8).send())) {
            assertThrows(IllegalArgumentException.class, () -> composite.splitComponentsFloor(-1));
            assertThrows(IllegalArgumentException.class, () -> composite.splitComponentsFloor(17));
            try (CompositeBuffer split = composite.splitComponentsFloor(16)) {
                assertThat(split.capacity()).isEqualTo(16);
                assertThat(composite.capacity()).isZero();
            }
        }
    }

    @Test
    public void splitComponentsCeilMustThrowOnOutOfBounds() {
        try (BufferAllocator allocator = BufferAllocator.onHeapUnpooled();
             CompositeBuffer composite = CompositeBuffer.compose(allocator,
                     allocator.allocate(8).send(),
                     allocator.allocate(8).send())) {
            assertThrows(IllegalArgumentException.class, () -> composite.splitComponentsCeil(-1));
            assertThrows(IllegalArgumentException.class, () -> composite.splitComponentsCeil(17));
            try (CompositeBuffer split = composite.splitComponentsCeil(16)) {
                assertThat(split.capacity()).isEqualTo(16);
                assertThat(composite.capacity()).isZero();
            }
        }
    }

    @Test
    public void splitComponentsFloorMustGiveEmptyBufferForOffsetInFirstComponent() {
        try (BufferAllocator allocator = BufferAllocator.onHeapUnpooled();
             CompositeBuffer composite = CompositeBuffer.compose(allocator,
                     allocator.allocate(8).send(),
                     allocator.allocate(8).send())) {
            try (CompositeBuffer split = composite.splitComponentsFloor(4)) {
                assertTrue(isOwned(split));
                assertTrue(split.isAccessible());
                assertThat(split.capacity()).isZero();

                assertTrue(isOwned(composite));
                assertTrue(composite.isAccessible());
                assertThat(composite.capacity()).isEqualTo(16);
            }
        }
    }

    @Test
    public void splitComponentsFloorMustGiveEmptyBufferForOffsetLastByteInFirstComponent() {
        try (BufferAllocator allocator = BufferAllocator.onHeapUnpooled();
             CompositeBuffer composite = CompositeBuffer.compose(allocator,
                     allocator.allocate(8).send(),
                     allocator.allocate(8).send())) {
            try (CompositeBuffer split = composite.splitComponentsFloor(7)) {
                assertTrue(isOwned(split));
                assertTrue(split.isAccessible());
                assertThat(split.capacity()).isZero();

                assertTrue(isOwned(composite));
                assertTrue(composite.isAccessible());
                assertThat(composite.capacity()).isEqualTo(16);
            }
        }
    }

    @Test
    public void splitComponentsFloorMustGiveBufferWithFirstComponentForOffsetInSecondComponent() {
        try (BufferAllocator allocator = BufferAllocator.onHeapUnpooled();
             CompositeBuffer composite = CompositeBuffer.compose(allocator,
                     allocator.allocate(8).send(),
                     allocator.allocate(8).send())) {
            try (CompositeBuffer split = composite.splitComponentsFloor(12)) {
                assertTrue(isOwned(split));
                assertTrue(split.isAccessible());
                assertThat(split.capacity()).isEqualTo(8);

                assertTrue(isOwned(composite));
                assertTrue(composite.isAccessible());
                assertThat(composite.capacity()).isEqualTo(8);
            }
        }
    }

    @Test
    public void splitComponentsFloorMustGiveBufferWithFirstComponentForOffsetOnFirstByteInSecondComponent() {
        try (BufferAllocator allocator = BufferAllocator.onHeapUnpooled();
             CompositeBuffer composite = CompositeBuffer.compose(allocator,
                     allocator.allocate(8).send(),
                     allocator.allocate(8).send())) {
            try (CompositeBuffer split = composite.splitComponentsFloor(8)) {
                assertTrue(isOwned(split));
                assertTrue(split.isAccessible());
                assertThat(split.capacity()).isEqualTo(8);

                assertTrue(isOwned(composite));
                assertTrue(composite.isAccessible());
                assertThat(composite.capacity()).isEqualTo(8);
            }
        }
    }

    @Test
    public void splitComponentsCeilMustGiveBufferWithFirstComponentForOffsetInFirstComponent() {
        try (BufferAllocator allocator = BufferAllocator.onHeapUnpooled();
             CompositeBuffer composite = CompositeBuffer.compose(allocator,
                     allocator.allocate(8).send(),
                     allocator.allocate(8).send())) {
            try (CompositeBuffer split = composite.splitComponentsCeil(4)) {
                assertTrue(isOwned(split));
                assertTrue(split.isAccessible());
                assertThat(split.capacity()).isEqualTo(8);

                assertTrue(isOwned(composite));
                assertTrue(composite.isAccessible());
                assertThat(composite.capacity()).isEqualTo(8);
            }
        }
    }

    @Test
    public void splitComponentsCeilMustGiveBufferWithFirstComponentFofOffsetOnLastByteInFirstComponent() {
        try (BufferAllocator allocator = BufferAllocator.onHeapUnpooled();
             CompositeBuffer composite = CompositeBuffer.compose(allocator,
                     allocator.allocate(8).send(),
                     allocator.allocate(8).send())) {
            try (CompositeBuffer split = composite.splitComponentsCeil(7)) {
                assertTrue(isOwned(split));
                assertTrue(split.isAccessible());
                assertThat(split.capacity()).isEqualTo(8);

                assertTrue(isOwned(composite));
                assertTrue(composite.isAccessible());
                assertThat(composite.capacity()).isEqualTo(8);
            }
        }
    }

    @Test
    public void splitComponentsCeilMustGiveBufferWithFirstAndSecondComponentForfOffsetInSecondComponent() {
        try (BufferAllocator allocator = BufferAllocator.onHeapUnpooled();
             CompositeBuffer composite = CompositeBuffer.compose(allocator,
                     allocator.allocate(8).send(),
                     allocator.allocate(8).send())) {
            try (CompositeBuffer split = composite.splitComponentsCeil(12)) {
                assertTrue(isOwned(split));
                assertTrue(split.isAccessible());
                assertThat(split.capacity()).isEqualTo(16);

                assertTrue(isOwned(composite));
                assertTrue(composite.isAccessible());
                assertThat(composite.capacity()).isEqualTo(0);
            }
        }

        try (BufferAllocator allocator = BufferAllocator.onHeapUnpooled();
             CompositeBuffer composite = CompositeBuffer.compose(allocator,
                     allocator.allocate(8).send(),
                     allocator.allocate(8).send(),
                     allocator.allocate(8).send())) {
            try (CompositeBuffer split = composite.splitComponentsCeil(12)) {
                assertTrue(isOwned(split));
                assertTrue(split.isAccessible());
                assertThat(split.capacity()).isEqualTo(16);

                assertTrue(isOwned(composite));
                assertTrue(composite.isAccessible());
                assertThat(composite.capacity()).isEqualTo(8);
            }
        }
    }

    @Test
    public void splitComponentsCeilMustGiveBufferWithFirstComponentForfOffsetOnFirstByteInSecondComponent() {
        try (BufferAllocator allocator = BufferAllocator.onHeapUnpooled();
             CompositeBuffer composite = CompositeBuffer.compose(allocator,
                     allocator.allocate(8).send(),
                     allocator.allocate(8).send())) {
            try (CompositeBuffer split = composite.splitComponentsCeil(7)) {
                assertTrue(isOwned(split));
                assertTrue(split.isAccessible());
                assertThat(split.capacity()).isEqualTo(8);

                assertTrue(isOwned(composite));
                assertTrue(composite.isAccessible());
                assertThat(composite.capacity()).isEqualTo(8);
            }
        }
    }

    @Test
    public void splitComponentsCeilMustGiveEmptyBufferForOffsetOnFirstByteInFirstComponent() {
        try (BufferAllocator allocator = BufferAllocator.onHeapUnpooled();
             CompositeBuffer composite = CompositeBuffer.compose(allocator,
                     allocator.allocate(8).send(),
                     allocator.allocate(8).send())) {
            try (CompositeBuffer split = composite.splitComponentsCeil(0)) {
                assertTrue(isOwned(split));
                assertTrue(split.isAccessible());
                assertThat(split.capacity()).isZero();

                assertTrue(isOwned(composite));
                assertTrue(composite.isAccessible());
                assertThat(composite.capacity()).isEqualTo(16);
            }
        }
    }
}