/*******************************************************************************
 * Copyright (c) 2015 Obeo.
 * 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:
 *     Obeo - initial API and implementation
 *******************************************************************************/
package org.eclipse.papyrus.compare.diagram.tests.groups;

import static com.google.common.collect.Iterables.filter;
import static com.google.common.collect.Iterables.size;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;

import com.google.common.base.Predicate;
import com.google.common.collect.Lists;
import com.google.common.eventbus.EventBus;

import java.io.IOException;
import java.util.Collection;
import java.util.regex.Pattern;

import org.eclipse.emf.common.notify.AdapterFactory;
import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.compare.Comparison;
import org.eclipse.emf.compare.Conflict;
import org.eclipse.emf.compare.Diff;
import org.eclipse.emf.compare.ReferenceChange;
import org.eclipse.emf.compare.diagram.ide.ui.internal.structuremergeviewer.filters.GMFRefinedElementsFilter;
import org.eclipse.emf.compare.diagram.internal.extensions.NodeChange;
import org.eclipse.emf.compare.diagram.internal.extensions.provider.spec.ExtensionsItemProviderAdapterFactorySpec;
import org.eclipse.emf.compare.diagram.internal.matchs.provider.spec.DiagramCompareItemProviderAdapterFactorySpec;
import org.eclipse.emf.compare.provider.spec.CompareItemProviderAdapterFactorySpec;
import org.eclipse.emf.compare.rcp.ui.internal.structuremergeviewer.filters.StructureMergeViewerFilter;
import org.eclipse.emf.compare.rcp.ui.internal.structuremergeviewer.groups.impl.ThreeWayComparisonGroupProvider;
import org.eclipse.emf.compare.rcp.ui.internal.structuremergeviewer.groups.provider.GroupItemProviderAdapter;
import org.eclipse.emf.compare.rcp.ui.internal.structuremergeviewer.groups.provider.TreeItemProviderAdapterFactorySpec;
import org.eclipse.emf.compare.tests.postprocess.data.TestPostProcessor;
import org.eclipse.emf.compare.uml2.internal.provider.custom.UMLCompareCustomItemProviderAdapterFactory;
import org.eclipse.emf.compare.uml2.internal.provider.decorator.UMLCompareItemProviderDecoratorAdapterFactory;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.provider.EcoreItemProviderAdapterFactory;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.edit.provider.AdapterFactoryItemDelegator;
import org.eclipse.emf.edit.provider.ComposedAdapterFactory;
import org.eclipse.emf.edit.provider.ReflectiveItemProviderAdapterFactory;
import org.eclipse.emf.edit.tree.TreeFactory;
import org.eclipse.emf.edit.tree.TreeNode;
import org.eclipse.gmf.runtime.notation.provider.NotationItemProviderAdapterFactory;
import org.eclipse.gmf.runtime.notation.util.NotationAdapterFactory;
import org.eclipse.papyrus.compare.diagram.internal.PapyrusDiagramPostProcessor;
import org.eclipse.papyrus.compare.diagram.tests.AbstractTest;
import org.eclipse.papyrus.compare.diagram.tests.DiagramInputData;
import org.eclipse.papyrus.compare.diagram.tests.groups.data.conflictsgroup.ConflictsGroupInputData;
import org.eclipse.uml2.uml.edit.providers.UMLItemProviderAdapterFactory;
import org.junit.BeforeClass;
import org.junit.Ignore;
import org.junit.Test;

@SuppressWarnings("restriction")
public class PapyrusConflictsGroupProviderTests extends AbstractTest {

	private ConflictsGroupInputData input = new ConflictsGroupInputData();

	private static AdapterFactoryItemDelegator itemDelegator;

	@BeforeClass
	public static void beforeClass() {
		final Collection<AdapterFactory> factories = Lists.newArrayList();
		factories.add(new CompareItemProviderAdapterFactorySpec());
		factories.add(new TreeItemProviderAdapterFactorySpec(new StructureMergeViewerFilter(new EventBus())));
		factories.add(new EcoreItemProviderAdapterFactory());
		factories.add(new ReflectiveItemProviderAdapterFactory());
		factories.add(new UMLCompareCustomItemProviderAdapterFactory());
		factories.add(new UMLItemProviderAdapterFactory());
		factories.add(new UMLCompareItemProviderDecoratorAdapterFactory());
		factories.add(new NotationAdapterFactory());
		factories.add(new ExtensionsItemProviderAdapterFactorySpec());
		factories.add(new DiagramCompareItemProviderAdapterFactorySpec());
		factories.add(new NotationItemProviderAdapterFactory());
		final AdapterFactory composedAdapterFactory = new ComposedAdapterFactory(factories);
		itemDelegator = new AdapterFactoryItemDelegator(composedAdapterFactory);
	}

	/**
	 * The comparison produces several conflicts. One of this conflict concerns the diagram. It involves 4
	 * differences: 2 ReferenceChanges and 2 NodeChanges. The NodeChanges are part of the conflict because
	 * they refine the ReferenceChanges. When the "Diagram refined elements " filer is enabled, the conflict
	 * group must show both NodeChanges. When the "Diagram refined elements " filer is disabled, the conflict
	 * group must show both ReferenceChanges.
	 * 
	 * @throws IOException
	 */
	@Test
	@Ignore("This should be tested manually during validation of releases. The set-up doesn't allow this test to behave like a real running eclipse with papyrus installed.")
	public void testBug478539() throws IOException {

		final Resource left = input.getBug478539Left();
		final Resource right = input.getBug478539Right();
		final Resource origin = input.getBug478539Origin();

		Comparison comparison = buildComparison(left, right, origin);

		EList<Conflict> conflicts = comparison.getConflicts();
		assertEquals(2, conflicts.size());

		Conflict conflict = conflicts.get(0);
		EList<Diff> conflictedDiffs = conflict.getDifferences();
		assertEquals(4, conflictedDiffs.size());
		assertEquals(2, size(filter(conflictedDiffs, NodeChange.class)));
		assertEquals(2, size(filter(conflictedDiffs, ReferenceChange.class)));

		TreeNode groupTreeNode = TreeFactory.eINSTANCE.createTreeNode();
		groupTreeNode.setData(comparison);
		groupTreeNode.eAdapters().add(new ThreeWayComparisonGroupProvider());

		Predicate<? super EObject> diagramFilterEnabled = new GMFRefinedElementsFilter()
				.getPredicateWhenSelected();
		Predicate<? super EObject> diagramFilterDisabled = new GMFRefinedElementsFilter()
				.getPredicateWhenUnselected();

		Collection<?> children = itemDelegator.getChildren(groupTreeNode);
		assertEquals(3, children.size());

		GroupItemProviderAdapter conflictGroup = (GroupItemProviderAdapter)children.iterator().next();
		Collection<?> conflictGroupChildren = itemDelegator.getChildren(conflictGroup);
		assertEquals(2, conflictGroupChildren.size());

		TreeNode firstConflict = (TreeNode)conflictGroupChildren.iterator().next();
		assertEquals("> Conflict [4 out of 4 differences unresolved]", itemDelegator.getText(firstConflict));
		EList<TreeNode> firstConflictChildren = firstConflict.getChildren();
		// the first conflict contains 2 children: a ReferenceChange and a
		// NodeChange.
		assertEquals(2, firstConflictChildren.size());

		// the NodeChange on Class1
		TreeNode shapeClass1 = firstConflictChildren.get(0);
		assertEquals("Shape <Class> Class1 [children delete]", itemDelegator.getText(shapeClass1));
		// visible when filter is enabled because this is a diagram diff
		assertFalse(diagramFilterEnabled.apply(shapeClass1));
		assertTrue(diagramFilterDisabled.apply(shapeClass1));
		EList<TreeNode> shapeClass1Children = shapeClass1.getChildren();
		assertEquals(3, shapeClass1Children.size());

		// the children of NodeChange on Class1
		// first child : the ReferenceChange on Class1
		TreeNode bcClass1 = shapeClass1Children.get(0);
		assertEquals("BasicCompartment <Class> Class1 [children delete]", itemDelegator.getText(bcClass1));
		// visible when filter is disabled because this is refined by a diagram
		// diff
		assertTrue(diagramFilterEnabled.apply(bcClass1));
		assertFalse(diagramFilterDisabled.apply(bcClass1));
		EList<TreeNode> bcClass1Children = bcClass1.getChildren();
		assertEquals(2, bcClass1Children.size());

		// second child : the ReferenceChange on Property att1
		TreeNode shapeAtt1 = shapeClass1Children.get(1);
		assertEquals("Shape <Property> att1 : Class2 [children add]", itemDelegator.getText(shapeAtt1));
		// visible when filter is disabled because this is refined by a diagram
		// diff
		assertTrue(diagramFilterEnabled.apply(shapeAtt1));
		assertFalse(diagramFilterDisabled.apply(shapeAtt1));
		EList<TreeNode> shapeAtt1Children = shapeAtt1.getChildren();
		assertEquals(0, shapeAtt1Children.size());

		// third child : the NodeChange on Property att1
		shapeAtt1 = shapeClass1Children.get(2);
		assertEquals("Shape <Property> att1 : Class2 [children add]", itemDelegator.getText(shapeAtt1));
		// visible when filter is enabled because this is a diagram diff
		assertFalse(diagramFilterEnabled.apply(shapeAtt1));
		assertTrue(diagramFilterDisabled.apply(shapeAtt1));
		shapeAtt1Children = shapeAtt1.getChildren();
		assertEquals(0, shapeAtt1Children.size());

		// the ReferenceChange on Class1
		TreeNode basicCompartmentClass1 = firstConflictChildren.get(1);
		assertEquals("BasicCompartment <Class> Class1 [children delete]",
				itemDelegator.getText(basicCompartmentClass1));
		// visible when filter is disabled because this is refined by a diagram
		// diff
		assertTrue(diagramFilterEnabled.apply(basicCompartmentClass1));
		assertFalse(diagramFilterDisabled.apply(basicCompartmentClass1));
		EList<TreeNode> basicCompartmentClass1Children = basicCompartmentClass1.getChildren();
		assertEquals(2, basicCompartmentClass1Children.size());

		// the children of ReferenceChange on Class1
		// first child : the ReferenceChange on Property att1
		shapeAtt1 = basicCompartmentClass1Children.get(0);
		assertEquals("Shape <Property> att1 : Class2 [children add]", itemDelegator.getText(shapeAtt1));
		// visible when filter is disabled because this is refined by a diagram
		// diff
		assertTrue(diagramFilterEnabled.apply(shapeAtt1));
		assertFalse(diagramFilterDisabled.apply(shapeAtt1));
		shapeAtt1Children = shapeAtt1.getChildren();
		assertEquals(0, shapeAtt1Children.size());

		// second child : the NodeChange on Property att1
		shapeAtt1 = basicCompartmentClass1Children.get(1);
		assertEquals("Shape <Property> att1 : Class2 [children add]", itemDelegator.getText(shapeAtt1));
		// visible when filter is enabled because this is a diagram diff
		assertFalse(diagramFilterEnabled.apply(shapeAtt1));
		assertTrue(diagramFilterDisabled.apply(shapeAtt1));
		shapeAtt1Children = shapeAtt1.getChildren();
		assertEquals(0, shapeAtt1Children.size());
	}

	@Override
	protected DiagramInputData getInput() {
		return input;
	}

	@Override
	public void registerPostProcessors() {
		super.registerPostProcessors();
		getPostProcessorRegistry().put(PapyrusDiagramPostProcessor.class.getName(),
				new TestPostProcessor.TestPostProcessorDescriptor(
						Pattern.compile("http://www.eclipse.org/gmf/runtime/\\d.\\d.\\d/notation"), null,
						new PapyrusDiagramPostProcessor(), 35));
	}
}