/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF 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
 *
 *     http://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 org.apache.cassandra.utils.btree;

import static org.apache.cassandra.utils.btree.BTreeRemoval.remove;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;

import java.util.Comparator;
import java.util.Random;
import java.util.SortedSet;
import java.util.TreeSet;

import org.junit.Test;

import com.google.common.collect.Iterables;

public class BTreeRemovalTest
{
    static
    {
        System.setProperty("cassandra.btree.fanfactor", "8");
    }

    private static final Comparator<Integer> CMP = new Comparator<Integer>()
    {
        public int compare(Integer o1, Integer o2)
        {
            return Integer.compare(o1, o2);
        }
    };

    private static Object[] copy(final Object[] btree)
    {
        final Object[] result = new Object[btree.length];
        System.arraycopy(btree, 0, result, 0, btree.length);
        if (!BTree.isLeaf(btree))
        {
            for (int i = BTree.getChildStart(btree); i < BTree.getChildEnd(btree); ++i)
                result[i] = copy((Object[]) btree[i]);
            final int[] sizeMap = BTree.getSizeMap(btree);
            final int[] resultSizeMap = new int[sizeMap.length];
            System.arraycopy(sizeMap, 0, resultSizeMap, 0, sizeMap.length);
            result[result.length - 1] = resultSizeMap;
        }
        return result;
    }

    private static Object[] assertRemove(final Object[] btree, final int key)
    {
        final Object[] btreeBeforeRemoval = copy(btree);
        final Object[] result = remove(btree, CMP, key);
        assertBTree(btreeBeforeRemoval, btree);
        assertTrue(BTree.isWellFormed(result, CMP));
        assertEquals(BTree.size(btree) - 1, BTree.size(result));
        assertNull(BTree.find(result, CMP, key));

        for (Integer k : BTree.<Integer>iterable(btree))
            if (k != key)
                assertNotNull(BTree.find(result, CMP, k));

        return result;
    }

    private static void assertBTree(final Object[] expected, final Object[] result)
    {
        assertEquals(BTree.isEmpty(expected), BTree.isEmpty(result));
        assertEquals(BTree.isLeaf(expected), BTree.isLeaf(result));
        assertEquals(expected.length, result.length);
        if (BTree.isLeaf(expected))
        {
            assertArrayEquals(expected, result);
        }
        else
        {
            for (int i = 0; i < BTree.getBranchKeyEnd(expected); ++i)
                assertEquals(expected[i], result[i]);
            for (int i = BTree.getChildStart(expected); i < BTree.getChildEnd(expected); ++i)
                assertBTree((Object[]) expected[i], (Object[]) result[i]);
            assertArrayEquals(BTree.getSizeMap(expected), BTree.getSizeMap(result));
        }
    }

    private static Object[] generateLeaf(int from, int size)
    {
        final Object[] result = new Object[(size & 1) == 1 ? size : size + 1];
        for (int i = 0; i < size; ++i)
            result[i] = from + i;
        return result;
    }

    private static Object[] generateBranch(int[] keys, Object[][] children)
    {
        assert keys.length > 0;
        assert children.length > 1;
        assert children.length == keys.length + 1;
        final Object[] result = new Object[keys.length + children.length + 1];
        for (int i = 0; i < keys.length; ++i)
            result[i] = keys[i];
        for (int i = 0; i < children.length; ++i)
            result[keys.length + i] = children[i];
        final int[] sizeMap = new int[children.length];
        sizeMap[0] = BTree.size(children[0]);
        for (int i = 1; i < children.length; ++i)
            sizeMap[i] = sizeMap[i - 1] + BTree.size(children[i]) + 1;
        result[result.length - 1] = sizeMap;
        return result;
    }

    private static Object[] generateSampleTwoLevelsTree(final int[] leafSizes)
    {
        assert leafSizes.length > 1;
        final Object[][] leaves = new Object[leafSizes.length][];
        for (int i = 0; i < leaves.length; ++i)
            leaves[i] = generateLeaf(10 * i + 1, leafSizes[i]);
        final int[] keys = new int[leafSizes.length - 1];
        for (int i = 0; i < keys.length; ++i)
            keys[i] = 10 * (i + 1);
        final Object[] btree = generateBranch(keys, leaves);
        assertTrue(BTree.isWellFormed(btree, CMP));
        return btree;
    }

    private static Object[] generateSampleThreeLevelsTree(final int[] middleNodeSizes)
    {
        assert middleNodeSizes.length > 1;
        final Object[][] middleNodes = new Object[middleNodeSizes.length][];
        for (int i = 0; i < middleNodes.length; ++i)
        {
            final Object[][] leaves = new Object[middleNodeSizes[i]][];
            for (int j = 0; j < middleNodeSizes[i]; ++j)
                leaves[j] = generateLeaf(100 * i + 10 * j + 1, 4);
            final int[] keys = new int[middleNodeSizes[i] - 1];
            for (int j = 0; j < keys.length; ++j)
                keys[j] = 100 * i + 10 * (j + 1);
            middleNodes[i] = generateBranch(keys, leaves);
        }
        final int[] keys = new int[middleNodeSizes.length - 1];
        for (int i = 0; i < keys.length; ++i)
            keys[i] = 100 * (i + 1);
        final Object[] btree = generateBranch(keys, middleNodes);
        assertTrue(BTree.isWellFormed(btree, CMP));
        return btree;
    }

    @Test
    public void testRemoveFromEmpty()
    {
        assertBTree(BTree.empty(), remove(BTree.empty(), CMP, 1));
    }

    @Test
    public void testRemoveNonexistingElement()
    {
        final Object[] btree = new Object[] {1, 2, 3, 4, null};
        assertBTree(btree, remove(btree, CMP, 5));
    }

    @Test
    public void testRemoveLastElement()
    {
        final Object[] btree = new Object[] {1};
        assertBTree(BTree.empty(), remove(btree, CMP, 1));
    }

    @Test
    public void testRemoveFromRootWhichIsALeaf()
    {
        for (int size = 1; size < 9; ++size)
        {
            final Object[] btree = new Object[(size & 1) == 1 ? size : size + 1];
            for (int i = 0; i < size; ++i)
                btree[i] = i + 1;
            for (int i = 0; i < size; ++i)
            {
                final Object[] result = remove(btree, CMP, i + 1);
                assertTrue("size " + size, BTree.isWellFormed(result, CMP));
                for (int j = 0; j < i; ++j)
                    assertEquals("size " + size + "elem " + j, btree[j], result[j]);
                for (int j = i; j < size - 1; ++j)
                    assertEquals("size " + size + "elem " + j, btree[j + 1], result[j]);
                for (int j = size - 1; j < result.length; ++j)
                    assertNull("size " + size + "elem " + j, result[j]);
            }

            {
                final Object[] result = remove(btree, CMP, 0);
                assertTrue("size " + size, BTree.isWellFormed(result, CMP));
                assertBTree(btree, result);
            }

            {
                final Object[] result = remove(btree, CMP, size + 1);
                assertTrue("size " + size, BTree.isWellFormed(result, CMP));
                assertBTree(btree, result);
            }
        }
    }

    @Test
    public void testRemoveFromNonMinimalLeaf()
    {
        for (int size = 5; size < 9; ++size)
        {
            final Object[] btree = generateSampleTwoLevelsTree(new int[] {size, 4, 4, 4, 4});

            for (int i = 1; i < size + 1; ++i)
                assertRemove(btree, i);
        }
    }

    @Test
    public void testRemoveFromMinimalLeafRotateLeft()
    {
        final Object[] btree = generateSampleTwoLevelsTree(new int[] {4, 5, 5, 5, 5});

        for (int i = 11; i < 15; ++i)
            assertRemove(btree, i);
    }

    @Test
    public void testRemoveFromMinimalLeafRotateRight1()
    {
        final Object[] btree = generateSampleTwoLevelsTree(new int[] {4, 5, 5, 5, 5});

        for (int i = 1; i < 5; ++i)
            assertRemove(btree, i);
    }

    @Test
    public void testRemoveFromMinimalLeafRotateRight2()
    {
        final Object[] btree = generateSampleTwoLevelsTree(new int[] {4, 4, 5, 5, 5});

        for (int i = 11; i < 15; ++i)
            assertRemove(btree, i);
    }

    @Test
    public void testRemoveFromMinimalLeafMergeWithLeft1()
    {
        final Object[] btree = generateSampleTwoLevelsTree(new int[] {4, 4, 4, 4, 4});

        for (int i = 11; i < 15; ++i)
            assertRemove(btree, i);
    }

    @Test
    public void testRemoveFromMinimalLeafMergeWithLeft2()
    {
        final Object[] btree = generateSampleTwoLevelsTree(new int[] {4, 4, 4, 4, 4});

        for (int i = 41; i < 45; ++i)
            assertRemove(btree, i);
    }

    @Test
    public void testRemoveFromMinimalLeafMergeWithRight()
    {
        final Object[] btree = generateSampleTwoLevelsTree(new int[] {4, 4, 4, 4, 4});

        for (int i = 1; i < 5; ++i)
            assertRemove(btree, i);
    }

    @Test
    public void testRemoveFromMinimalLeafWhenSingleKeyRootMergeWithLeft()
    {
        final Object[] btree = generateSampleTwoLevelsTree(new int[] {4, 4});

        for (int i = 1; i < 5; ++i)
            assertRemove(btree, i);
    }

    @Test
    public void testRemoveFromMinimalLeafWhenSingleKeyRootMergeWithRight()
    {
        final Object[] btree = generateSampleTwoLevelsTree(new int[] {4, 4});

        for (int i = 11; i < 15; ++i)
            assertRemove(btree, i);
    }

    @Test
    public void testRemoveFromMinimalLeafWithBranchLeftRotation()
    {
        final Object[] btree = generateSampleThreeLevelsTree(new int[] {6, 5, 5, 5, 5});
        for (int i = 101; i < 105; ++i)
            assertRemove(btree, i);
    }

    @Test
    public void testRemoveFromMinimalLeafWithBranchRightRotation1()
    {
        final Object[] btree = generateSampleThreeLevelsTree(new int[] {5, 6, 5, 5, 5});
        for (int i = 1; i < 5; ++i)
            assertRemove(btree, i);
    }

    @Test
    public void testRemoveFromMinimalLeafWithBranchRightRotation2()
    {
        final Object[] btree = generateSampleThreeLevelsTree(new int[] {5, 5, 6, 5, 5});
        for (int i = 101; i < 105; ++i)
            assertRemove(btree, i);
    }

    @Test
    public void testRemoveFromMinimalLeafWithBranchMergeWithLeft1()
    {
        final Object[] btree = generateSampleThreeLevelsTree(new int[] {5, 5, 5, 5, 5});
        for (int i = 101; i < 105; ++i)
            assertRemove(btree, i);
    }

    @Test
    public void testRemoveFromMinimalLeafWithBranchMergeWithLeft2()
    {
        final Object[] btree = generateSampleThreeLevelsTree(new int[] {5, 5, 5, 5, 5});
        for (int i = 401; i < 405; ++i)
            assertRemove(btree, i);
    }

    @Test
    public void testRemoveFromMinimalLeafWithBranchMergeWithRight()
    {
        final Object[] btree = generateSampleThreeLevelsTree(new int[] {5, 5, 5, 5, 5});
        for (int i = 1; i < 5; ++i)
            assertRemove(btree, i);
    }

    @Test
    public void testRemoveFromMiddleBranch()
    {
        final Object[] btree = generateSampleThreeLevelsTree(new int[] {5, 5, 5, 5, 5});
        for (int i = 10; i < 50; i += 10)
            assertRemove(btree, i);
    }

    @Test
    public void testRemoveFromRootBranch()
    {
        final Object[] btree = generateSampleThreeLevelsTree(new int[] {5, 5, 5, 5, 5});
        for (int i = 100; i < 500; i += 100)
            assertRemove(btree, i);
    }

    @Test
    public void randomizedTest()
    {
        Random rand = new Random(2);
        SortedSet<Integer> data = new TreeSet<>();
        for (int i = 0; i < 1000; ++i)
            data.add(rand.nextInt());
        Object[] btree = BTree.build(data, UpdateFunction.<Integer>noOp());

        assertTrue(BTree.isWellFormed(btree, CMP));
        assertTrue(Iterables.elementsEqual(data, BTree.iterable(btree)));
        while (btree != BTree.empty())
        {
            int idx = rand.nextInt(BTree.size(btree));
            Integer val = BTree.findByIndex(btree, idx);
            assertTrue(data.remove(val));
            btree = assertRemove(btree, val);
        }
    }
}