/*

* Copyright (c) 2009 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.emf.dm.*;

import com.nokia.sdt.emf.dm.impl.PropertyContainerCopier;

import junit.framework.TestCase;

public class PropertyContainerCopierTest extends TestCase {

	IDesignerData root;

	IPropertyContainer nodeProperties;

	INode rootNode, child1, child2;

	static final String NAME1 = "child1";

	static final String NAME2 = "child2";

	protected void setUp() throws Exception {

		root = DmFactory.eINSTANCE.createIDesignerData();

		rootNode = DmFactory.eINSTANCE.createINode();

		root.getRootContainers().add(rootNode);

		nodeProperties = rootNode.getProperties();

		child1 = DmFactory.eINSTANCE.createINode();

		child1.getProperties().set("name", nodeProperties.createLiteral(NAME1));

		rootNode.getChildren().add(child1);

		child2 = DmFactory.eINSTANCE.createINode();

		rootNode.getChildren().add(child2);

		child2.getProperties().set("name", nodeProperties.createLiteral(NAME2));

	}

	String getKey(IPropertyContainer pc, String propertyID) {

		IPropertyValue pv = (IPropertyValue) pc.getProperties().get(propertyID);

		assertNotNull(pv);

		assertTrue(pv.hasStringValue());

		assertTrue(pv.getStringValue().isKey());

		return pv.getStringValue().getValue();

	}

	void checkString(IPropertyContainer pc, String propertyID, int type, String expected) {

		Object value = pc.get(propertyID);

		assertNotNull(value);

		assertTrue(value instanceof StringValue);

		StringValue sv = (StringValue) value;

		assertEquals(type, sv.getType());

		String text = pc.lookupString(sv);

		assertEquals(expected, text);

	}

	public void testUndo() {

		// simulate an undo scenario by initializing a compound

		// property, capturing undo state, changing the properties,

		// undoing, and checking the values

		IPropertyValue compoundPV = nodeProperties.createPropertyContainerForProperty("test");

		nodeProperties.getProperties().put("test", compoundPV);

		IPropertyContainer srcProperties = compoundPV.getCompoundValue();

		srcProperties.set("literal", srcProperties.createLiteral("literal1"));

		srcProperties.set("macro1", srcProperties.createMacro("macro1-value"));

		srcProperties.set("macro2", srcProperties.createMacro("macro2-value"));

		srcProperties.set("localized1", srcProperties.createLocalized("localized1-value"));

		srcProperties.set("localized2", srcProperties.createLocalized("localized2-value"));

		srcProperties.set("reference1", srcProperties.createReference(NAME1));

		srcProperties.set("reference2", srcProperties.createReference(NAME2));

		IPropertyValue nestedCompoundPV = srcProperties.createPropertyContainerForProperty("nested-compound1");

		srcProperties.getProperties().put("nested-compound1", nestedCompoundPV);

		IPropertyContainer nestedCompoundProperties = nestedCompoundPV.getCompoundValue();

		nestedCompoundProperties.set("nested-literal", nestedCompoundProperties.createLiteral("nested-literal1"));

		nestedCompoundProperties.set("nested-macro", nestedCompoundProperties.createMacro("nested-macro1"));

		nestedCompoundProperties.set("nested-localized", nestedCompoundProperties.createLocalized("nested-localized1"));

		IPropertyValue nestedCompound2PV = srcProperties.createPropertyContainerForProperty("nested-compound2");

		srcProperties.getProperties().put("nested-compound2", nestedCompound2PV);

		IPropertyContainer nestedCompound2Properties = nestedCompound2PV.getCompoundValue();

		nestedCompound2Properties.set("aaa", nestedCompoundProperties.createLiteral("xyz"));

		// record expected table keys, so we know new ones aren't assigned

		String topMacro1Key = getKey(srcProperties, "macro1");

		String topMacro2Key = getKey(srcProperties, "macro2");	

		String topLocalized1Key = getKey(srcProperties, "localized1");

		String topLocalized2Key = getKey(srcProperties, "localized2");

		String nestedMacroKey = getKey(nestedCompoundProperties, "nested-macro");

		String nestedLocalizedKey = getKey(nestedCompoundProperties, "nested-localized");

		PropertyContainerCopier copier = new PropertyContainerCopier(srcProperties);

		assertNotNull(copier.getCopy());

		// change values prior to undo

		srcProperties.set("newly-added", srcProperties.createLocalized("new localized"));

		srcProperties.set("literal", srcProperties.createLiteral("another literal"));

		srcProperties.set("macro1", srcProperties.createMacro("another macro"));

		srcProperties.reset("macro2");

		srcProperties.set("localized1", srcProperties.createLocalized("another localized"));

		srcProperties.reset("localized2");

		nestedCompoundProperties.set("nested-literal", nestedCompoundProperties.createLocalized("loc123"));

		nestedCompoundProperties.reset("nested-macro");

		nestedCompoundProperties.set("nested-localized", nestedCompoundProperties.createLiteral("literal123"));

		srcProperties.reset("nested-compound2");

		// remove child node 2. Upon undo the reference should not be restored

		rootNode.getChildren().remove(child2);

		assertNull(srcProperties.getProperties().get("reference2"));

		copier.undo(true, true);

		srcProperties = (IPropertyContainer) nodeProperties.get("test");

		assertNotNull(srcProperties);

		nestedCompoundProperties = (IPropertyContainer) srcProperties.get("nested-compound1");

		assertNotNull(nestedCompoundProperties);

		nestedCompound2Properties = (IPropertyContainer) srcProperties.get("nested-compound2");

		assertNotNull(nestedCompound2Properties);

		assertEquals(topMacro1Key, getKey(srcProperties, "macro1"));

		assertEquals(topMacro2Key, getKey(srcProperties, "macro2"));

		assertEquals(topLocalized1Key, getKey(srcProperties, "localized1"));

		assertEquals(topLocalized2Key, getKey(srcProperties, "localized2"));

		assertEquals(nestedMacroKey, getKey(nestedCompoundProperties, "nested-macro"));

		assertEquals(nestedLocalizedKey, getKey(nestedCompoundProperties, "nested-localized"));

		assertNull(srcProperties.getProperties().get("newly-added"));

		checkString(srcProperties, "literal", StringValue.LITERAL, "literal1");

		checkString(srcProperties, "macro1", StringValue.MACRO, "macro1-value");

		checkString(srcProperties, "macro2", StringValue.MACRO, "macro2-value");

		checkString(srcProperties, "localized1", StringValue.LOCALIZED, "localized1-value");

		checkString(srcProperties, "localized2", StringValue.LOCALIZED, "localized2-value");

		checkString(srcProperties, "reference1", StringValue.REFERENCE, NAME1);

		assertNull(srcProperties.getProperties().get("reference2"));

		checkString(nestedCompoundProperties, "nested-literal", StringValue.LITERAL, "nested-literal1");

		checkString(nestedCompoundProperties, "nested-macro", StringValue.MACRO, "nested-macro1");

		checkString(nestedCompoundProperties, "nested-localized", StringValue.LOCALIZED, "nested-localized1");

		checkString(nestedCompound2Properties, "aaa", StringValue.LITERAL, "xyz");

	}

}