/*
 * ModeShape (http://www.modeshape.org)
 *
 * Licensed 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.modeshape.sequencer.ddl.node;

import static org.hamcrest.core.Is.is;
import static org.hamcrest.core.IsNull.nullValue;
import static org.hamcrest.core.IsSame.sameInstance;
import static org.junit.Assert.assertThat;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

/**
 * 
 */
public class AstNodeTest {

    private AstNode node;
    private AstNode parent;

    @Before
    public void beforeEach() {
        node = new AstNode("node1");
    }

    @After
    public void afterEach() {
        this.node = null;
        this.parent = null;
    }

    @Test
    public void shouldCreatePlanNodeWithNameAndNoParent() {
        String name = "something";
        node = new AstNode(name);
        assertThat(node.getName(), is(name));
        assertThat(node.getParent(), is(nullValue()));
    }

    @Test
    public void shouldCreatePlanNodeWithNameAndParent() {
        String name = "something";
        parent = new AstNode("parent");
        node = new AstNode(parent, name);
        assertThat(node.getName(), is(name));
        assertThat(node.getParent(), is(sameInstance(parent)));
        assertThat(parent.getFirstChild(), is(sameInstance(node)));
        assertThat(parent.getChildCount(), is(1));
    }

    @Test
    public void shouldGetFirstChildAndLastChildWithOneChild() {
        parent = new AstNode("parent");
        node = new AstNode(parent, "child");
        assertThat(parent.getFirstChild(), is(sameInstance(node)));
        assertThat(parent.getLastChild(), is(sameInstance(node)));
    }

    @Test
    public void shouldGetFirstChildAndLastChildWithTwoChildren() {
        parent = new AstNode("parent");
        AstNode child1 = new AstNode(parent, "childA");
        AstNode child2 = new AstNode(parent, "childB");
        assertThat(parent.getFirstChild(), is(sameInstance(child1)));
        assertThat(parent.getLastChild(), is(sameInstance(child2)));
    }

    @Test
    public void shouldGetFirstChildAndLastChildWithMoreThanTwoChildren() {
        parent = new AstNode("parent");
        AstNode child1 = new AstNode(parent, "childA");
        new AstNode(parent, "childB");
        AstNode child3 = new AstNode(parent, "childC");
        assertThat(parent.getFirstChild(), is(sameInstance(child1)));
        assertThat(parent.getLastChild(), is(sameInstance(child3)));
    }

    @Test
    public void shouldGetFirstChildAndLastChildWithNoChildren() {
        parent = new AstNode("parent");
        assertThat(parent.getFirstChild(), is(nullValue()));
        assertThat(parent.getLastChild(), is(nullValue()));
    }

    @Test
    public void shouldRemoveNodeFromExistingParentWhenSettingParentToNull() {
        parent = new AstNode("parent");
        node = new AstNode(parent, "child");
        assertThat(parent.getFirstChild(), is(sameInstance(node)));
        assertThat(parent.getChildCount(), is(1));
        node.setParent(null);
        assertThat(parent.getChildCount(), is(0));
        assertThat(node.getParent(), is(nullValue()));
    }

    @Test
    public void shouldInsertNewParentNodeInBetweenExistingParentAndChild() {
        parent = new AstNode("parent");
        AstNode child1 = new AstNode(parent, "childA");
        AstNode child2 = new AstNode(parent, "childB");
        AstNode child3 = new AstNode(parent, "childC");
        assertThat(parent.getFirstChild(), is(sameInstance(child1)));
        assertThat(parent.getChild(1), is(sameInstance(child2)));
        assertThat(parent.getLastChild(), is(sameInstance(child3)));
        assertThat(parent.getChildCount(), is(3));
        node = new AstNode("inserted");
        child2.insertAsParent(node);
        assertThat(parent.getChildCount(), is(3));
        assertThat(parent.getFirstChild(), is(sameInstance(child1)));
        assertThat(parent.getChild(1), is(sameInstance(node)));
        assertThat(parent.getLastChild(), is(sameInstance(child3)));
        assertThat(node.getParent(), is(sameInstance(parent)));
        assertThat(child2.getParent(), is(sameInstance(node)));
    }

    @Test
    public void shouldInsertNewParentNodeInAboveNodeWithoutParent() {
        AstNode child1 = new AstNode("childA");
        node = new AstNode("node");
        AstNode nodeChild = new AstNode(node, "child");
        // Perform the insertAsParent ...
        child1.insertAsParent(node);
        assertThat(node.getParent(), is(nullValue()));
        assertThat(node.getChildCount(), is(2));
        assertThat(node.getFirstChild(), is(sameInstance(nodeChild)));
        assertThat(node.getLastChild(), is(sameInstance(child1)));
        assertThat(child1.getParent(), is(sameInstance(node)));
    }

    @Test
    public void shouldRemoveFromParentWhenThereIsAParent() {
        parent = new AstNode("parent");
        AstNode child1 = new AstNode(parent, "childA");
        AstNode child2 = new AstNode(parent, "childB");
        AstNode child3 = new AstNode(parent, "childC");
        AstNode grandChild21 = new AstNode(child2, "grandChild21");
        assertThat(parent.getFirstChild(), is(sameInstance(child1)));
        assertThat(parent.getChild(1), is(sameInstance(child2)));
        assertThat(parent.getLastChild(), is(sameInstance(child3)));
        assertThat(parent.getChildCount(), is(3));
        assertThat(child2.getFirstChild(), is(sameInstance(grandChild21)));
        // Perform the removeFromParent ...
        assertThat(child2.removeFromParent(), is(sameInstance(parent)));
        assertThat(parent.getFirstChild(), is(sameInstance(child1)));
        assertThat(parent.getLastChild(), is(sameInstance(child3)));
        assertThat(parent.getChildCount(), is(2));
        // There should still be the child in the removed node ...
        assertThat(child2.getFirstChild(), is(sameInstance(grandChild21)));
    }

    @Test
    public void shouldRemoveFromParentWhenThereIsNoParent() {
        node = new AstNode("node");
        AstNode child1 = new AstNode(node, "child");
        assertThat(node.getFirstChild(), is(sameInstance(child1)));
        assertThat(node.getChildCount(), is(1));
        // Perform the removeFromParent ...
        assertThat(node.removeFromParent(), is(nullValue()));
        assertThat(node.getFirstChild(), is(sameInstance(child1)));
        assertThat(node.getChildCount(), is(1));
    }

    @Test
    public void shouldReturnListOfChildren() {
        parent = new AstNode("parent");
        AstNode child1 = new AstNode(parent, "childA");
        AstNode child2 = new AstNode(parent, "childB");
        AstNode child3 = new AstNode(parent, "childC");
        List<AstNode> children = parent.getChildren();
        assertThat(children.get(0), is(sameInstance(child1)));
        assertThat(children.get(1), is(sameInstance(child2)));
        assertThat(children.get(2), is(sameInstance(child3)));
        assertThat(children.size(), is(3));
    }

    @Test( expected = UnsupportedOperationException.class )
    public void shouldReturnImmutableListOfChildren() {
        parent = new AstNode("parent");
        new AstNode(parent, "childA");
        new AstNode(parent, "childB");
        new AstNode(parent, "childC");
        parent.getChildren().clear();
    }

    @Test
    public void shouldReturnIteratorOfChildren() {
        parent = new AstNode("parent");
        AstNode child1 = new AstNode(parent, "childA");
        AstNode child2 = new AstNode(parent, "childB");
        AstNode child3 = new AstNode(parent, "childC");
        Iterator<AstNode> children = parent.iterator();
        assertThat(children.next(), is(sameInstance(child1)));
        assertThat(children.next(), is(sameInstance(child2)));
        assertThat(children.next(), is(sameInstance(child3)));
        assertThat(children.hasNext(), is(false));
    }

    @Test( expected = UnsupportedOperationException.class )
    public void shouldReturnImmutableIteratorOfChildren() {
        parent = new AstNode("parent");
        new AstNode(parent, "childA");
        new AstNode(parent, "childB");
        new AstNode(parent, "childC");
        Iterator<AstNode> iter = parent.iterator();
        iter.next();
        iter.remove();
    }

    @Test
    public void shouldRemoveAllChildrenOfParentWithNoChildrenByReturningEmptyList() {
        parent = new AstNode("parent");
        // Perform the remove, and verify the list has all the children ...
        List<AstNode> children = parent.removeAllChildren();
        assertThat(children.size(), is(0));
        assertThat(parent.getChildCount(), is(0));
        // Add a new child to the parent ...
        AstNode child1a = new AstNode(parent, "child1A");
        assertThat(parent.getFirstChild(), is(sameInstance(child1a)));
        // The returned copy should not be modified ...
        assertThat(children.size(), is(0));
    }

    @Test
    public void shouldRemoveAllChildrenAndReturnCopyOfListOfChildren() {
        parent = new AstNode("parent");
        AstNode child1 = new AstNode(parent, "childA");
        AstNode child2 = new AstNode(parent, "childB");
        AstNode child3 = new AstNode(parent, "childC");
        // Perform the remove, and verify the list has all the children ...
        List<AstNode> children = parent.removeAllChildren();
        assertThat(children.get(0), is(sameInstance(child1)));
        assertThat(children.get(1), is(sameInstance(child2)));
        assertThat(children.get(2), is(sameInstance(child3)));
        assertThat(children.size(), is(3));
        assertThat(parent.getChildCount(), is(0));
        // Add a new child to the parent ...
        AstNode child1a = new AstNode(parent, "child1A");
        assertThat(parent.getFirstChild(), is(sameInstance(child1a)));
        // The returned copy should not be modified ...
        assertThat(children.get(0), is(sameInstance(child1)));
        assertThat(children.get(1), is(sameInstance(child2)));
        assertThat(children.get(2), is(sameInstance(child3)));
        assertThat(children.size(), is(3));
    }

    @Test
    public void shouldReturnCorrectChildCount() {
        parent = new AstNode("parent");
        assertThat(parent.getChildCount(), is(0));
        for (int i = 0; i != 10; ++i) {
            new AstNode(parent, "child");
            assertThat(parent.getChildCount(), is(i + 1));
        }
    }

    @Test
    public void shouldAddChildrenAtEnd() {
        parent = new AstNode("parent");
        List<AstNode> children = new ArrayList<AstNode>();
        children.add(new AstNode(parent, "child"));
        children.add(new AstNode(parent, "child"));
        children.add(new AstNode(parent, "child"));
        parent.addChildren(children);
        int index = 0;
        for (AstNode child : children) {
            assertThat(parent.getChild(index++), is(sameInstance(child)));
        }
    }

    @Test
    public void shouldRemoveChild() {
        parent = new AstNode("parent");
        AstNode child1 = new AstNode(parent, "childA");
        AstNode child2 = new AstNode(parent, "childB");
        AstNode child3 = new AstNode(parent, "childC");
        assertThat(parent.getChild(0), is(sameInstance(child1)));
        assertThat(parent.getChild(1), is(sameInstance(child2)));
        assertThat(parent.getChild(2), is(sameInstance(child3)));
        // Perform the remove, and verify children have changed ...
        assertThat(parent.removeChild(child2), is(true));
        assertThat(parent.getChild(0), is(sameInstance(child1)));
        assertThat(parent.getChild(1), is(sameInstance(child3)));
    }

    @Test
    public void shouldNotRemoveChildIfNotReallyAChild() {
        node = new AstNode("node");
        parent = new AstNode("parent");
        AstNode child1 = new AstNode(parent, "childA");
        AstNode child2 = new AstNode(parent, "childB");
        AstNode child3 = new AstNode(parent, "childC");
        assertThat(parent.getChild(0), is(sameInstance(child1)));
        assertThat(parent.getChild(1), is(sameInstance(child2)));
        assertThat(parent.getChild(2), is(sameInstance(child3)));
        // Try to remove the non-child, and verify the children have no changed ...
        assertThat(parent.removeChild(node), is(false));
        assertThat(parent.getChild(0), is(sameInstance(child1)));
        assertThat(parent.getChild(1), is(sameInstance(child2)));
        assertThat(parent.getChild(2), is(sameInstance(child3)));
    }

    @Test
    public void shouldNotRemoveChildIfReferenceIsNull() {
        parent = new AstNode("parent");
        AstNode child1 = new AstNode(parent, "childA");
        AstNode child2 = new AstNode(parent, "childB");
        AstNode child3 = new AstNode(parent, "childC");
        assertThat(parent.getChild(0), is(sameInstance(child1)));
        assertThat(parent.getChild(1), is(sameInstance(child2)));
        assertThat(parent.getChild(2), is(sameInstance(child3)));
        // Try to remove the non-child, and verify the children have no changed ...
        assertThat(parent.removeChild(null), is(false));
        assertThat(parent.getChild(0), is(sameInstance(child1)));
        assertThat(parent.getChild(1), is(sameInstance(child2)));
        assertThat(parent.getChild(2), is(sameInstance(child3)));
    }

    @Test
    public void shouldExtractChildByRemovingIfChildHasNoChildren() {
        parent = new AstNode("parent");
        AstNode child1 = new AstNode(parent, "childA");
        AstNode child2 = new AstNode(parent, "childB");
        AstNode child3 = new AstNode(parent, "childC");
        assertThat(parent.getChild(0), is(sameInstance(child1)));
        assertThat(parent.getChild(1), is(sameInstance(child2)));
        assertThat(parent.getChild(2), is(sameInstance(child3)));
        // Perform the extraction ...
        parent.extractChild(child2);
        assertThat(parent.getChild(0), is(sameInstance(child1)));
        assertThat(parent.getChild(1), is(sameInstance(child3)));
        assertThat(parent.getChildCount(), is(2));
    }

    @Test
    public void shouldExtractChildByReplacingWithFirstGrandchild() {
        parent = new AstNode("parent");
        AstNode child1 = new AstNode(parent, "childA");
        AstNode child2 = new AstNode(parent, "childB");
        AstNode child3 = new AstNode(parent, "childC");
        AstNode grandChild1 = new AstNode(child2, "grandchildA");
        AstNode grandChild2 = new AstNode(child2, "grandchildB");
        assertThat(parent.getChild(0), is(sameInstance(child1)));
        assertThat(parent.getChild(1), is(sameInstance(child2)));
        assertThat(parent.getChild(2), is(sameInstance(child3)));
        // Perform the extraction ...
        parent.extractChild(child2);
        assertThat(parent.getChild(0), is(sameInstance(child1)));
        assertThat(parent.getChild(1), is(sameInstance(grandChild1)));
        assertThat(parent.getChild(2), is(sameInstance(child3)));
        assertThat(parent.getChildCount(), is(3));
        // The old child should still contain just the remaining child(ren) ...
        assertThat(child2.getFirstChild(), is(sameInstance(grandChild2)));
        assertThat(child2.getParent(), is(nullValue()));
    }

    @Test
    public void shouldReplaceChild() {
        AstNode parentOfReplacement = new AstNode("parentOfReplacement");
        AstNode replacement = new AstNode(parentOfReplacement, "replacement");
        parent = new AstNode("parent");
        AstNode child1 = new AstNode(parent, "childA");
        AstNode child2 = new AstNode(parent, "childB");
        AstNode child3 = new AstNode(parent, "childC");
        assertThat(parent.getChild(0), is(sameInstance(child1)));
        assertThat(parent.getChild(1), is(sameInstance(child2)));
        assertThat(parent.getChild(2), is(sameInstance(child3)));
        // Perform the replacement ...
        assertThat(parent.replaceChild(child2, replacement), is(true));
        assertThat(parent.getChild(0), is(sameInstance(child1)));
        assertThat(parent.getChild(1), is(sameInstance(replacement)));
        assertThat(parent.getChild(2), is(sameInstance(child3)));
        assertThat(replacement.getParent(), is(sameInstance(parent)));
        assertThat(child1.getParent(), is(sameInstance(parent)));
        assertThat(child2.getParent(), is(nullValue()));
        assertThat(child3.getParent(), is(sameInstance(parent)));
        // The replacement should no longer be a child of its former parent ...
        assertThat(parentOfReplacement.getChildCount(), is(0));
    }

    @Test
    public void shouldReplaceChildWithAnotherChildToSwapPositions() {
        parent = new AstNode("parent");
        AstNode child1 = new AstNode(parent, "childA");
        AstNode child2 = new AstNode(parent, "childB");
        AstNode child3 = new AstNode(parent, "childC");
        assertThat(parent.getChild(0), is(sameInstance(child1)));
        assertThat(parent.getChild(1), is(sameInstance(child2)));
        assertThat(parent.getChild(2), is(sameInstance(child3)));
        // Perform the replacement ...
        assertThat(parent.replaceChild(child2, child3), is(true));
        assertThat(parent.getChild(0), is(sameInstance(child1)));
        assertThat(parent.getChild(1), is(sameInstance(child3)));
        assertThat(parent.getChild(2), is(sameInstance(child2)));
        assertThat(child1.getParent(), is(sameInstance(parent)));
        assertThat(child2.getParent(), is(sameInstance(parent)));
        assertThat(child3.getParent(), is(sameInstance(parent)));
    }

    @Test
    public void shouldNotReplaceChildIfChildNodeIsNotReallyAChild() {
        AstNode nonChild = new AstNode("nonChild");
        AstNode replacement = new AstNode("replacement");
        parent = new AstNode("parent");
        AstNode child1 = new AstNode(parent, "childA");
        AstNode child2 = new AstNode(parent, "childB");
        AstNode child3 = new AstNode(parent, "childC");
        assertThat(parent.getChild(0), is(sameInstance(child1)));
        assertThat(parent.getChild(1), is(sameInstance(child2)));
        assertThat(parent.getChild(2), is(sameInstance(child3)));
        assertThat(parent.replaceChild(nonChild, replacement), is(false));
    }

    @Test
    public void shouldReturnPath() {
        AstNode root = new AstNode("root");
        AstNode node1 = new AstNode(root, "node1");
        AstNode node2 = new AstNode(node1, "node2");
        AstNode node3 = new AstNode(node2, "node3");
        AstNode node4 = new AstNode(node3, "node4");
        AstNode node5 = new AstNode(node4, "node5");
        node4.setProperty("prop1", "value1");
        assertThat(root.getAbsolutePath(), is("/root"));
        assertThat(node1.getAbsolutePath(), is("/root/node1"));
        assertThat(node2.getAbsolutePath(), is("/root/node1/node2"));
        assertThat(node3.getAbsolutePath(), is("/root/node1/node2/node3"));
        assertThat(node4.getAbsolutePath(), is("/root/node1/node2/node3/node4"));
        assertThat(node5.getAbsolutePath(), is("/root/node1/node2/node3/node4/node5"));
    }

}
