/*******************************************************************************
 * Copyright (c) 2007, 2010 Association for Decentralized Information Management
 * in Industry THTH ry.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     VTT Technical Research Centre of Finland - initial API and implementation
 *******************************************************************************/
package org.simantics.scenegraph.tests;

import static junit.framework.Assert.assertSame;

import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.Semaphore;
import java.util.concurrent.atomic.AtomicBoolean;

import org.junit.Test;
import org.simantics.scenegraph.INode;
import org.simantics.scenegraph.ParentNode;
import org.simantics.scenegraph.g2d.G2DParentNode;
import org.simantics.scenegraph.g2d.G2DSceneGraph;
import org.simantics.scenegraph.g2d.nodes.DataNode;
import org.simantics.scenegraph.g2d.nodes.NavigationNode;
import org.simantics.scenegraph.utils.NodeUtil;


/**
 * @author Tuukka Lehtonen
 */
public class LookupServiceTests {

    AtomicBoolean           endTest;
    CyclicBarrier           startBarrier;
    Semaphore               ended;

    G2DSceneGraph           root              = new G2DSceneGraph();
    List<INode>             nodes             = new ArrayList<INode>();
    List<String>            nodeIds           = new ArrayList<String>();
    List<String>            mappedIds         = new ArrayList<String>();

    List<Throwable>         errors            = new ArrayList<Throwable>();


    <T extends INode> T addAndMapNode(ParentNode<?> parent, String id, Class<T> clazz) {
        T node = parent.addNode(id, clazz);
        nodes.add( node );
        nodeIds.add( id );
        NodeUtil.map(node, id);
        return node;
    }

    <T extends INode> T addNode(ParentNode<?> parent, String id, Class<T> clazz) {
        T node = parent.addNode(id, clazz);
        nodes.add( node );
        nodeIds.add( id );
        return node;
    }

    <T extends INode> T addNode(ParentNode<?> parent, Class<T> clazz) {
        return addNode(parent, UUID.randomUUID().toString(), clazz);
    }

    @Test
    public void testLookup() throws Exception {
        NavigationNode nav = addAndMapNode(root, "navigation", NavigationNode.class);
        DataNode data = addAndMapNode(root, "data", DataNode.class);
        G2DParentNode elements = addAndMapNode(nav, "elements", G2DParentNode.class);
        @SuppressWarnings("unused")
        G2DParentNode ghosts = addAndMapNode(nav, "ghosts", G2DParentNode.class);

        // Basic checks
        assertSame(nav, root.lookupNode("navigation"));
        assertSame(data, root.lookupNode("data"));
        assertSame(nav, NodeUtil.lookup(nav, "navigation"));
        assertSame(data, NodeUtil.lookup(data, "data"));

        String id1 = UUID.randomUUID().toString();
        String id2 = UUID.randomUUID().toString();
        String id3_1 = UUID.randomUUID().toString();
        String id3_2 = UUID.randomUUID().toString();
        String id4 = UUID.randomUUID().toString();
        G2DParentNode e1 = addAndMapNode(elements, id1, G2DParentNode.class);
        G2DParentNode e2 = addAndMapNode(elements, id2, G2DParentNode.class);
        G2DParentNode e3 = addNode(elements, G2DParentNode.class);
        G2DParentNode e3_1 = addAndMapNode(e3, id3_1, G2DParentNode.class);
        G2DParentNode e3_2 = addAndMapNode(e3, id3_2, G2DParentNode.class);
        G2DParentNode e4 = addAndMapNode(elements, id4, G2DParentNode.class);

        assertSame(e1, NodeUtil.lookup(e1, id1));
        assertSame(e2, NodeUtil.lookup(e2, id2));
        assertSame(e3_1, NodeUtil.lookup(e3_1, id3_1));
        assertSame(e3_2, NodeUtil.lookup(e3_2, id3_2));
        assertSame(e4, NodeUtil.lookup(e4, id4));
    }

}