/*

* Copyright (c) 2007 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description: 

*

*/

package com.nokia.sdt.emf.dm.tests;

import com.nokia.sdt.component.IComponent;

import com.nokia.sdt.component.property.IPropertyInformation;

import com.nokia.sdt.component.property.ISequencePropertySource;

import com.nokia.sdt.datamodel.IDesignerDataModel;

import com.nokia.sdt.datamodel.adapter.IComponentInstance;

import com.nokia.sdt.datamodel.adapter.IComponentInstancePropertyListener;

import com.nokia.sdt.datamodel.util.ModelUtils;

import com.nokia.sdt.emf.dm.IComponentManifest;

import com.nokia.sdt.symbian.dm.DesignerDataModel;

import com.nokia.sdt.testsupport.TestDataModelHelpers;

import com.nokia.cpp.internal.api.utils.core.Logging;

import org.eclipse.emf.common.command.Command;

import org.eclipse.emf.ecore.EObject;

import org.eclipse.ui.views.properties.IPropertySource;

import java.util.Collections;

import java.util.List;

import junit.framework.TestCase;

/**

 * Test reference property promotion 

 * 

 *

 */

public class ReferencePropertyPromotionTest extends TestCase {

	static final String MAIN_COMPONENT = "com.nokia.test.rptMainComponent";

	static final String SUB_COMPONENT = "com.nokia.test.rptSubComponent";

	static final String SUB_COMPONENT_CONFLICTS_1 = "com.nokia.test.rptSubComponentConflicts1";

	static final String SUB_COMPONENT_CONFLICTS_2 = "com.nokia.test.rptSubComponentConflicts2";

	static final String REFERENCE_PROPERTY = "reference";

	static final String REFERENCE2_PROPERTY = "reference2";

	DesignerDataModel model;

	EObject root;

	IComponentManifest manifest;

	protected void setUp() throws Exception {

		Logging.alwaysLogToConsole = true;

		TestDataModelHelpers.setupResourceFactory();

		TestDataModelHelpers.setupTestComponents();

		model = (DesignerDataModel) TestDataModelHelpers.createTemporaryModel();

		TestDataModelHelpers.initDefaultComponentSet(model);

		IComponent component = model.getComponentSet().lookupComponent(MAIN_COMPONENT);

		root = model.createNewComponentInstance(component);

		model.getDesignerData().getRootContainers().add(root);

		IPropertySource rootPs = ModelUtils.getPropertySource(root);

		rootPs.setPropertyValue("name", "root");

	}

	protected EObject addChild(EObject parent, String componentId, String name) {

		IComponent subComponent = model.getComponentSet().lookupComponent(componentId);

		EObject sub = model.createNewComponentInstance(subComponent);

		Command addCommand = model.createAddNewComponentInstanceCommand(parent, sub, IDesignerDataModel.AT_END);

		assertNotNull(addCommand.canExecute());

		addCommand.execute();

		IPropertySource ps = ModelUtils.getPropertySource(sub);

		ps.setPropertyValue("name", name);

		return sub;

	}

	protected EObject addChild(EObject parent, String name) {

		return addChild(parent, SUB_COMPONENT, name);

	}

	protected void setReference(EObject from, EObject to) {

		IPropertySource toPs = ModelUtils.getPropertySource(to);

		String name = toPs.getPropertyValue("name").toString();

		IPropertySource ps = ModelUtils.getPropertySource(from);

		ps.setPropertyValue(REFERENCE_PROPERTY, name);

	}

	/** No reference from root to sub. */

	public void testUnconnected() {

		EObject sub = addChild(root, "child");

		IPropertySource ps = ModelUtils.getPropertySource(root);

		assertNull(ps.getPropertyValue("intValue"));

		assertNull(ps.getPropertyValue("stringValue"));

		assertNull(ps.getPropertyValue("refValue"));

		assertNull(ps.getPropertyValue("locationValue"));

		assertNull(ps.getPropertyValue("arrayValue"));

		ps = ModelUtils.getPropertySource(sub);

		assertNotNull(ps.getPropertyValue("intValue"));

		assertNotNull(ps.getPropertyValue("stringValue"));

		assertNotNull(ps.getPropertyValue("refValue"));

		assertNotNull(ps.getPropertyValue("locationValue"));

		assertNotNull(ps.getPropertyValue("arrayValue"));

	}

	/** Adding a reference from root to sub. */

	public void testConnected() {

		EObject sub = addChild(root, "child");

		IPropertySource rootPs = ModelUtils.getPropertySource(root);

		rootPs.setPropertyValue(REFERENCE_PROPERTY, "child");

		IPropertySource ps = ModelUtils.getPropertySource(sub);

		assertNotNull(ps.getPropertyValue("intValue"));

		assertNotNull(ps.getPropertyValue("stringValue"));

		assertNotNull(ps.getPropertyValue("refValue"));

		assertNotNull(ps.getPropertyValue("locationValue"));

		assertNotNull(ps.getPropertyValue("arrayValue"));

		assertNotNull(rootPs.getPropertyValue("intValue"));

		assertNotNull(rootPs.getPropertyValue("stringValue"));

		assertNotNull(rootPs.getPropertyValue("refValue"));

		assertNotNull(rootPs.getPropertyValue("locationValue"));

		assertNotNull(rootPs.getPropertyValue("arrayValue"));

		assertEquals("child", rootPs.getPropertyValue(REFERENCE_PROPERTY));

	}

	/** Test that the values are properly promoted */

	public void testPromotingPropertyValues() {

		EObject sub = addChild(root, "child");

		IPropertySource rootPs = ModelUtils.getPropertySource(root);

		IPropertySource subPs = ModelUtils.getPropertySource(sub);

		assertFalse(rootPs.isPropertySet("intValue"));

		assertFalse(rootPs.isPropertySet("stringValue"));

		assertFalse(rootPs.isPropertySet("refValue"));

		assertFalse(rootPs.isPropertySet("locationValue"));

		assertFalse(rootPs.isPropertySet("arrayValue"));

		assertFalse(subPs.isPropertySet("intValue"));

		assertFalse(subPs.isPropertySet("stringValue"));

		assertFalse(subPs.isPropertySet("refValue"));

		assertFalse(subPs.isPropertySet("locationValue"));

		assertFalse(subPs.isPropertySet("arrayValue"));

		// verify info

		IPropertyInformation info = (IPropertyInformation) rootPs;

		assertEquals(root, info.getPropertyOwner("name"));

		assertEquals(root, info.getPropertyOwner(REFERENCE_PROPERTY));

		assertNull(info.getPropertyOwner("intValue"));

		assertNull(info.getPropertyOwner("stringValue"));

		info = (IPropertyInformation) subPs;

		assertEquals(sub, info.getPropertyOwner("name"));

		assertNull(info.getPropertyOwner(REFERENCE_PROPERTY));

		assertEquals(sub, info.getPropertyOwner("intValue"));

		assertEquals(sub, info.getPropertyOwner("stringValue"));

		subPs.setPropertyValue("intValue", 23);

		subPs.setPropertyValue("stringValue", "flargle");

		subPs.setPropertyValue("refValue", "child"); // self-ref... so what?

		IPropertySource compound = (IPropertySource) subPs.getPropertyValue("locationValue"); 

		compound.setPropertyValue("x", 1);

		compound.setPropertyValue("y", 2);

		ISequencePropertySource seq = (ISequencePropertySource) subPs.getPropertyValue("arrayValue");

		seq.addSimpleProperty(0, true);

		seq.addSimpleProperty(1, false);

		assertEquals("true", seq.get(0));

		assertEquals("false", seq.get(1));

		// ensure they're promoted

		rootPs.setPropertyValue(REFERENCE_PROPERTY, "child");

		assertEquals("child", rootPs.getPropertyValue(REFERENCE_PROPERTY));

		assertTrue(rootPs.isPropertySet("intValue"));

		assertTrue(rootPs.isPropertySet("stringValue"));

		assertTrue(rootPs.isPropertySet("refValue"));

		assertTrue(rootPs.isPropertySet("locationValue"));

		assertTrue(rootPs.isPropertySet("arrayValue"));

		assertTrue(subPs.isPropertySet("intValue"));

		assertTrue(subPs.isPropertySet("stringValue"));

		assertTrue(subPs.isPropertySet("refValue"));

		assertTrue(subPs.isPropertySet("locationValue"));

		assertTrue(subPs.isPropertySet("arrayValue"));

		// verify info

		info = (IPropertyInformation) rootPs;

		assertEquals(root, info.getPropertyOwner("name"));

		assertEquals(root, info.getPropertyOwner(REFERENCE_PROPERTY));

		assertEquals(sub, info.getPropertyOwner("intValue"));

		assertEquals(sub, info.getPropertyOwner("stringValue"));

		info = (IPropertyInformation) subPs;

		assertEquals(sub, info.getPropertyOwner("name"));

		assertNull(info.getPropertyOwner(REFERENCE_PROPERTY));

		assertEquals(sub, info.getPropertyOwner("intValue"));

		assertEquals(sub, info.getPropertyOwner("stringValue"));

		assertEquals(23, rootPs.getPropertyValue("intValue"));

		assertEquals("flargle", rootPs.getPropertyValue("stringValue"));

		assertEquals("child", rootPs.getPropertyValue("refValue"));

		IPropertySource rootCompound = (IPropertySource) rootPs.getPropertyValue("locationValue"); 

		assertEquals(1, rootCompound.getPropertyValue("x"));

		assertEquals(2, rootCompound.getPropertyValue("y"));

		ISequencePropertySource rootArray = (ISequencePropertySource) rootPs.getPropertyValue("arrayValue");

		assertEquals(2, rootArray.size());

		assertEquals("true", rootArray.get(0));

		assertEquals("false", rootArray.get(1));

	}

	/** Test that properties from the reference do not alias properties of the instance */

	public void testAliasedPropertyValues() {

		EObject sub = addChild(root, "child");

		IPropertySource rootPs = ModelUtils.getPropertySource(root);

		IPropertySource subPs = ModelUtils.getPropertySource(sub);

		assertEquals("root", rootPs.getPropertyValue("name"));

		rootPs.setPropertyValue(REFERENCE_PROPERTY, "child");

		assertEquals("root", rootPs.getPropertyValue("name"));

		rootPs.setPropertyValue("name", "rootie");

		assertEquals("rootie", rootPs.getPropertyValue("name"));

		assertEquals("child", subPs.getPropertyValue("name"));

	}

	/** Test that we track promoted values properly */

	public void testChangingPromotingPropertyValues() {

		EObject sub = addChild(root, "child");

		IPropertySource rootPs = ModelUtils.getPropertySource(root);

		IPropertySource subPs = ModelUtils.getPropertySource(sub);

		subPs.setPropertyValue("intValue", 23);

		// ensure they're promoted

		rootPs.setPropertyValue(REFERENCE_PROPERTY, "child");

		assertTrue(rootPs.isPropertySet("intValue"));

		assertEquals(23, rootPs.getPropertyValue("intValue"));

		////

		subPs.setPropertyValue("stringValue", "flargle");

		assertEquals("flargle", rootPs.getPropertyValue("stringValue"));

		///

		rootPs.resetPropertyValue(REFERENCE_PROPERTY);

		assertFalse(rootPs.isPropertySet("intValue"));

		assertFalse(rootPs.isPropertySet("stringValue"));

		///

		rootPs.setPropertyValue(REFERENCE_PROPERTY, "child");

		assertEquals("flargle", rootPs.getPropertyValue("stringValue"));

		assertEquals(23, rootPs.getPropertyValue("intValue"));

	}

	/** Test that a change to the referenced instance (but not its name) is detected */

	public void testChangingReferencedInstance() {

		EObject sub = addChild(root, "child");

		IPropertySource rootPs = ModelUtils.getPropertySource(root);

		IPropertySource subPs = ModelUtils.getPropertySource(sub);

		rootPs.setPropertyValue(REFERENCE_PROPERTY, "child");

		subPs.setPropertyValue("intValue", 23);

		subPs.setPropertyValue("stringValue", "flargle");

		IPropertySource compound = (IPropertySource) subPs.getPropertyValue("locationValue"); 

		compound.setPropertyValue("x", 1);

		compound.setPropertyValue("y", 2);

		// sanity

		assertTrue(rootPs.isPropertySet("intValue"));

		assertEquals(23, rootPs.getPropertyValue("intValue"));

		IPropertySource rootCompound = (IPropertySource) rootPs.getPropertyValue("locationValue"); 

		assertEquals(1, rootCompound.getPropertyValue("x"));

		assertEquals(2, rootCompound.getPropertyValue("y"));

		////

		// replace the child

		List objectsToRemove = Collections.singletonList(sub);

		Command command = model.createRemoveComponentInstancesCommand(objectsToRemove);

		assertTrue(command.canExecute());

		command.execute();

		assertFalse(rootPs.isPropertySet("reference"));

		sub = addChild(root, "child");

		subPs = ModelUtils.getPropertySource(sub);

		// sanity

		assertFalse(subPs.isPropertySet("intValue"));

		assertFalse(subPs.isPropertySet("stringValue"));

		assertFalse(subPs.isPropertySet("refValue"));

		assertFalse(subPs.isPropertySet("locationValue"));

		assertFalse(subPs.isPropertySet("arrayValue"));

		// check root again

		assertFalse(rootPs.isPropertySet("intValue"));

		assertFalse(rootPs.isPropertySet("stringValue"));

		assertFalse(rootPs.isPropertySet("refValue"));

		assertFalse(rootPs.isPropertySet("locationValue"));

		assertFalse(rootPs.isPropertySet("arrayValue"));

	}

	/** Test that properties are not promoted multiple times  */

	public void testConflictingPropertyPromotion1() {

		// this one aliases 'another'

		EObject sub = addChild(root, SUB_COMPONENT_CONFLICTS_1, "child");

		IPropertySource rootPs = ModelUtils.getPropertySource(root);

		IPropertySource subPs = ModelUtils.getPropertySource(sub);

		rootPs.setPropertyValue("another", "string");

		subPs.setPropertyValue("another", 42);

		rootPs.setPropertyValue(REFERENCE_PROPERTY, "child");

		assertEquals("string", rootPs.getPropertyValue("another"));

		assertEquals(42, subPs.getPropertyValue("another"));

		rootPs.setPropertyValue(REFERENCE_PROPERTY, null);

		assertEquals("string", rootPs.getPropertyValue("another"));

	}

	/** Test that properties are not promoted multiple times  */

	public void testConflictingPropertyPromotion2() {

		// this one aliases 'another'

		EObject sub1 = addChild(root, SUB_COMPONENT_CONFLICTS_2, "child1");

		EObject sub2 = addChild(root, SUB_COMPONENT_CONFLICTS_2, "child2");

		IPropertySource rootPs = ModelUtils.getPropertySource(root);

		IPropertySource sub1Ps = ModelUtils.getPropertySource(sub1);

		IPropertySource sub2Ps = ModelUtils.getPropertySource(sub2);

		sub1Ps.setPropertyValue("intValue", 4);

		sub2Ps.setPropertyValue("intValue", 5);

		rootPs.setPropertyValue(REFERENCE_PROPERTY, "child1");

		rootPs.setPropertyValue(REFERENCE2_PROPERTY, "child2");

		// we can't be sure what order they're added

		int val = (Integer) rootPs.getPropertyValue("intValue");

		assertTrue(val == 4 || val == 5);

		boolean got4 = (val == 4);

		rootPs.setPropertyValue(got4 ? REFERENCE_PROPERTY : REFERENCE2_PROPERTY, null);

		assertEquals(got4 ? 5 : 4, rootPs.getPropertyValue("intValue"));

		rootPs.setPropertyValue(got4 ? REFERENCE2_PROPERTY : REFERENCE_PROPERTY, null);

		assertNull(rootPs.getPropertyValue("intValue"));

	}

	/** Test that we handle when a reference property's name changes */

	public void testRenamedReferences() {

		EObject sub = addChild(root, "child");

		IPropertySource rootPs = ModelUtils.getPropertySource(root);

		IPropertySource subPs = ModelUtils.getPropertySource(sub);

		rootPs.setPropertyValue(REFERENCE_PROPERTY, "child");

		subPs.setPropertyValue("intValue", 23);

		assertEquals(23, rootPs.getPropertyValue("intValue"));

		subPs.setPropertyValue("name", "foo");

		subPs.setPropertyValue("intValue", 42);

		assertEquals(42, rootPs.getPropertyValue("intValue"));

	}

	/** test that promoted references inside compound properties works */

	public void testPromotionInCompoundProperty() {

		EObject sub = addChild(root, "child");

		IPropertySource rootPs = ModelUtils.getPropertySource(root);

		IPropertySource subPs = ModelUtils.getPropertySource(sub);

		IPropertySource rootCompound = (IPropertySource) rootPs.getPropertyValue("refCompound");

		rootCompound.setPropertyValue(REFERENCE_PROPERTY, "child");

		subPs.setPropertyValue("intValue", 23);

		// ensure not promoted to root

		assertNull(rootPs.getPropertyValue("intValue"));

		assertEquals(23, rootCompound.getPropertyValue("intValue"));

		assertEquals("child", rootCompound.getPropertyValue(REFERENCE_PROPERTY));

		subPs.setPropertyValue("intValue", 23);

		assertEquals(23, rootCompound.getPropertyValue("intValue"));

	}

	/** Test sanity if reference is broken */

	public void testBadReference() {

		EObject sub = addChild(root, "child");

		IPropertySource rootPs = ModelUtils.getPropertySource(root);

		IPropertySource subPs = ModelUtils.getPropertySource(sub);

		rootPs.setPropertyValue(REFERENCE_PROPERTY, "foo");

		subPs.setPropertyValue("intValue", 23);

		assertNull(rootPs.getPropertyValue("intValue"));

	}

	/** Test sanity for recursive reference */

	public void testRecursiveReference() {

		IPropertySource rootPs = ModelUtils.getPropertySource(root);

		rootPs.setPropertyValue(REFERENCE_PROPERTY, "root");

		rootPs.setPropertyValue("another", "string");

		assertEquals("string", rootPs.getPropertyValue("another"));

	}

	class PropertyChangeListener implements IComponentInstancePropertyListener {

		public EObject firedInstance;

		public String firedProperty;

		public void propertyChanged(EObject componentInstance,

				Object propertyId) {

			firedInstance = componentInstance;

			firedProperty = propertyId.toString();

		}

		public void reset() {

			firedInstance = null;

			firedProperty = null;

		}

	}

	/** Test that property listeners get fired on both the referenced instance

	 * and the referencing instance */

	public void testPropertyChangeListeners() {

		EObject sub = addChild(root, "child");

		IPropertySource rootPs = ModelUtils.getPropertySource(root);

		IPropertySource subPs = ModelUtils.getPropertySource(sub);

		IComponentInstance rootInstance = ModelUtils.getComponentInstance(root);

		PropertyChangeListener rootListener = new PropertyChangeListener();

		rootInstance.addPropertyListener(rootListener);

		IComponentInstance subInstance = ModelUtils.getComponentInstance(sub);

		PropertyChangeListener subListener = new PropertyChangeListener();

		subInstance.addPropertyListener(subListener);

		// wire them up

		rootPs.setPropertyValue(REFERENCE_PROPERTY, "child");

		// sanity for listeners

		assertEquals(root, rootListener.firedInstance);

		assertEquals(REFERENCE_PROPERTY, rootListener.firedProperty);

		assertNull(subListener.firedInstance);

		assertNull(subListener.firedProperty);

		rootListener.reset();

		// set on the root, and sub should know

		rootPs.setPropertyValue("intValue", 23);

		assertEquals(root, rootListener.firedInstance);

		assertEquals(sub, subListener.firedInstance);

		assertEquals("intValue", rootListener.firedProperty);

		assertEquals("intValue", subListener.firedProperty);

		rootListener.reset();

		subListener.reset();

		// set on sub, and root should know

		subPs.setPropertyValue("intValue", 23);

		assertEquals(root, rootListener.firedInstance);

		assertEquals(sub, subListener.firedInstance);

		assertEquals("intValue", rootListener.firedProperty);

		assertEquals("intValue", subListener.firedProperty);

		// remove reference and make sure notifications stop

		rootPs.setPropertyValue(REFERENCE_PROPERTY, null);

		rootListener.reset();

		subListener.reset();

		subPs.setPropertyValue("intValue", 0);

		assertNull(rootListener.firedInstance);

		assertNull(rootListener.firedProperty);

		assertEquals(sub, subListener.firedInstance);

		assertEquals("intValue", subListener.firedProperty);

		// add again

		rootPs.setPropertyValue(REFERENCE_PROPERTY, "child");

		rootListener.reset();

		subListener.reset();

		// now delete the referent, which implicitly resets the reference

		List objectsToRemove = Collections.singletonList(sub);

		Command command = model.createRemoveComponentInstancesCommand(objectsToRemove);

		assertTrue(command.canExecute());

		command.execute();