/*******************************************************************************
 * 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
 *     Philip Langer - 
 *******************************************************************************/
package org.eclipse.emf.compare.ide.ui.tests.command;

import static com.google.common.base.Predicates.and;
import static com.google.common.collect.Iterables.filter;
import static com.google.common.collect.Iterables.size;
import static org.eclipse.emf.compare.utils.EMFComparePredicates.fromSide;
import static org.eclipse.emf.compare.utils.EMFComparePredicates.hasState;
import static org.eclipse.emf.compare.utils.EMFComparePredicates.ofKind;
import static org.junit.Assert.assertEquals;

import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;

import java.io.IOException;

import org.eclipse.emf.common.notify.Notifier;
import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.compare.Comparison;
import org.eclipse.emf.compare.Diff;
import org.eclipse.emf.compare.DifferenceKind;
import org.eclipse.emf.compare.DifferenceSource;
import org.eclipse.emf.compare.DifferenceState;
import org.eclipse.emf.compare.EMFCompare;
import org.eclipse.emf.compare.command.impl.MergeAllNonConflictingCommand;
import org.eclipse.emf.compare.domain.impl.EMFCompareEditingDomain;
import org.eclipse.emf.compare.ide.ui.internal.structuremergeviewer.actions.MergeNonConflictingRunnable;
import org.eclipse.emf.compare.ide.ui.tests.command.data.MergeAllCommandInputData;
import org.eclipse.emf.compare.internal.merge.MergeMode;
import org.eclipse.emf.compare.merge.IMerger;
import org.eclipse.emf.compare.scope.DefaultComparisonScope;
import org.eclipse.emf.compare.scope.IComparisonScope;
import org.eclipse.emf.ecore.change.util.ChangeRecorder;
import org.eclipse.emf.ecore.resource.Resource;
import org.junit.Before;
import org.junit.Test;

@SuppressWarnings({"restriction", "unchecked" })
public class MergeAllCommandTests {

	private Resource leftResource;

	private Resource rightResource;

	private Resource originResource;

	private IMerger.Registry mergerRegistry;

	@Before
	public void getInputData() throws IOException {
		final MergeAllCommandInputData input = new MergeAllCommandInputData();
		leftResource = input.getLeftScope();
		rightResource = input.getRightScope();
		originResource = input.getOriginScope();
		mergerRegistry = IMerger.RegistryImpl.createStandaloneInstance();
	}

	@Test
	public void testMergeAllNonConflictingFromLeftToRightThreeWayWithoutConflicts() throws IOException {
		MergeMode mergeMode = MergeMode.LEFT_TO_RIGHT;
		boolean leftToRight = true;
		boolean isLeftEditable = true;
		boolean isRightEditable = true;

		IComparisonScope scope = new DefaultComparisonScope(leftResource, rightResource, originResource);
		Comparison comparison = EMFCompare.builder().build().compare(scope);

		EMFCompareEditingDomain editingDomain = (EMFCompareEditingDomain)EMFCompareEditingDomain.create(
				leftResource, rightResource, originResource);
		ChangeRecorder changeRecorder = editingDomain.getChangeRecorder();

		ImmutableSet.Builder<Notifier> notifiersBuilder = ImmutableSet.builder();
		ImmutableSet<Notifier> notifiers = notifiersBuilder.add(comparison).addAll(
				ImmutableList.of(leftResource, rightResource, originResource)).build();

		MergeNonConflictingRunnable runnable = new MergeNonConflictingRunnable(isLeftEditable,
				isRightEditable, mergeMode);

		MergeAllNonConflictingCommand command = new MergeAllNonConflictingCommand(changeRecorder, notifiers,
				comparison, leftToRight, mergerRegistry, runnable);

		EList<Diff> differencesBefore = comparison.getDifferences();
		// Test state of differences before command
		// 3 Left Delete differences
		Iterable<Diff> leftDelete = filter(differencesBefore, and(fromSide(DifferenceSource.LEFT),
				ofKind(DifferenceKind.DELETE), hasState(DifferenceState.UNRESOLVED)));
		assertEquals(3, size(leftDelete));
		// 3 Right Delete differences
		Iterable<Diff> rightDelete = filter(differencesBefore, and(fromSide(DifferenceSource.RIGHT),
				ofKind(DifferenceKind.DELETE), hasState(DifferenceState.UNRESOLVED)));
		assertEquals(3, size(rightDelete));
		// 3 Left Add differences
		Iterable<Diff> leftAdd = filter(differencesBefore, and(fromSide(DifferenceSource.LEFT),
				ofKind(DifferenceKind.ADD), hasState(DifferenceState.UNRESOLVED)));
		assertEquals(3, size(leftAdd));
		// 3 Right Add differences
		Iterable<Diff> rightAdd = filter(differencesBefore, and(fromSide(DifferenceSource.RIGHT),
				ofKind(DifferenceKind.ADD), hasState(DifferenceState.UNRESOLVED)));
		assertEquals(3, size(rightAdd));

		// Execute command
		command.execute();

		EList<Diff> differencesAfter = comparison.getDifferences();
		// Test state of differences before command
		// 3 Left Delete differences merged
		leftDelete = filter(differencesAfter, and(fromSide(DifferenceSource.LEFT),
				ofKind(DifferenceKind.DELETE), hasState(DifferenceState.MERGED)));
		assertEquals(3, size(leftDelete));
		// 0 Right Delete differences merged
		rightDelete = filter(differencesAfter, and(fromSide(DifferenceSource.RIGHT),
				ofKind(DifferenceKind.DELETE), hasState(DifferenceState.MERGED)));
		assertEquals(0, size(rightDelete));
		// 3 Left Add differences merged
		leftAdd = filter(differencesAfter, and(fromSide(DifferenceSource.LEFT), ofKind(DifferenceKind.ADD),
				hasState(DifferenceState.MERGED)));
		assertEquals(3, size(leftAdd));
		// 0 Right Add differences merged
		rightAdd = filter(differencesAfter, and(fromSide(DifferenceSource.RIGHT), ofKind(DifferenceKind.ADD),
				hasState(DifferenceState.MERGED)));
		assertEquals(0, size(rightAdd));

		command.dispose();
		editingDomain.dispose();
	}

	@Test
	public void testMergeAllNonConflictingFromRightToLeftThreeWayWithoutConflicts() throws IOException {
		MergeMode mergeMode = MergeMode.RIGHT_TO_LEFT;
		boolean leftToRight = false;
		boolean isLeftEditable = true;
		boolean isRightEditable = true;

		IComparisonScope scope = new DefaultComparisonScope(leftResource, rightResource, originResource);
		Comparison comparison = EMFCompare.builder().build().compare(scope);

		EMFCompareEditingDomain editingDomain = (EMFCompareEditingDomain)EMFCompareEditingDomain.create(
				leftResource, rightResource, originResource);
		ChangeRecorder changeRecorder = editingDomain.getChangeRecorder();

		ImmutableSet.Builder<Notifier> notifiersBuilder = ImmutableSet.builder();
		ImmutableSet<Notifier> notifiers = notifiersBuilder.add(comparison).addAll(
				ImmutableList.of(leftResource, rightResource, originResource)).build();

		MergeNonConflictingRunnable runnable = new MergeNonConflictingRunnable(isLeftEditable,
				isRightEditable, mergeMode);

		MergeAllNonConflictingCommand command = new MergeAllNonConflictingCommand(changeRecorder, notifiers,
				comparison, leftToRight, mergerRegistry, runnable);

		EList<Diff> differencesBefore = comparison.getDifferences();
		// Test state of differences before command
		// 3 Left Delete differences
		Iterable<Diff> leftDelete = filter(differencesBefore, and(fromSide(DifferenceSource.LEFT),
				ofKind(DifferenceKind.DELETE), hasState(DifferenceState.UNRESOLVED)));
		assertEquals(3, size(leftDelete));
		// 3 Right Delete differences
		Iterable<Diff> rightDelete = filter(differencesBefore, and(fromSide(DifferenceSource.RIGHT),
				ofKind(DifferenceKind.DELETE), hasState(DifferenceState.UNRESOLVED)));
		assertEquals(3, size(rightDelete));
		// 3 Left Add differences
		Iterable<Diff> leftAdd = filter(differencesBefore, and(fromSide(DifferenceSource.LEFT),
				ofKind(DifferenceKind.ADD), hasState(DifferenceState.UNRESOLVED)));
		assertEquals(3, size(leftAdd));
		// 3 Right Add differences
		Iterable<Diff> rightAdd = filter(differencesBefore, and(fromSide(DifferenceSource.RIGHT),
				ofKind(DifferenceKind.ADD), hasState(DifferenceState.UNRESOLVED)));
		assertEquals(3, size(rightAdd));

		// Execute command
		command.execute();

		EList<Diff> differencesAfter = comparison.getDifferences();
		// Test state of differences after command
		// 0 Left Delete differences merged
		leftDelete = filter(differencesAfter, and(fromSide(DifferenceSource.LEFT),
				ofKind(DifferenceKind.DELETE), hasState(DifferenceState.MERGED)));
		assertEquals(0, size(leftDelete));
		// 3 Right Delete differences merged
		rightDelete = filter(differencesAfter, and(fromSide(DifferenceSource.RIGHT),
				ofKind(DifferenceKind.DELETE), hasState(DifferenceState.MERGED)));
		assertEquals(3, size(rightDelete));
		// 0 Left Add differences merged
		leftAdd = filter(differencesAfter, and(fromSide(DifferenceSource.LEFT), ofKind(DifferenceKind.ADD),
				hasState(DifferenceState.MERGED)));
		assertEquals(0, size(leftAdd));
		// 3 Right Add differences merged
		rightAdd = filter(differencesAfter, and(fromSide(DifferenceSource.RIGHT), ofKind(DifferenceKind.ADD),
				hasState(DifferenceState.MERGED)));
		assertEquals(3, size(rightAdd));

		command.dispose();
		editingDomain.dispose();
	}

	@Test
	public void testAcceptAllNonConflictingChangesThreeWayWithoutConflicts() throws IOException {
		MergeMode mergeMode = MergeMode.ACCEPT;
		boolean leftToRight = false;
		boolean isLeftEditable = true;
		boolean isRightEditable = false;

		IComparisonScope scope = new DefaultComparisonScope(leftResource, rightResource, originResource);
		Comparison comparison = EMFCompare.builder().build().compare(scope);

		EMFCompareEditingDomain editingDomain = (EMFCompareEditingDomain)EMFCompareEditingDomain.create(
				leftResource, rightResource, originResource);
		ChangeRecorder changeRecorder = editingDomain.getChangeRecorder();

		ImmutableSet.Builder<Notifier> notifiersBuilder = ImmutableSet.builder();
		ImmutableSet<Notifier> notifiers = notifiersBuilder.add(comparison).addAll(
				ImmutableList.of(leftResource, rightResource, originResource)).build();

		MergeNonConflictingRunnable runnable = new MergeNonConflictingRunnable(isLeftEditable,
				isRightEditable, mergeMode);

		MergeAllNonConflictingCommand command = new MergeAllNonConflictingCommand(changeRecorder, notifiers,
				comparison, leftToRight, mergerRegistry, runnable);

		EList<Diff> differencesBefore = comparison.getDifferences();
		// Test state of differences before command
		// 3 Left Delete differences
		Iterable<Diff> leftDelete = filter(differencesBefore, and(fromSide(DifferenceSource.LEFT),
				ofKind(DifferenceKind.DELETE), hasState(DifferenceState.UNRESOLVED)));
		assertEquals(3, size(leftDelete));
		// 3 Right Delete differences
		Iterable<Diff> rightDelete = filter(differencesBefore, and(fromSide(DifferenceSource.RIGHT),
				ofKind(DifferenceKind.DELETE), hasState(DifferenceState.UNRESOLVED)));
		assertEquals(3, size(rightDelete));
		// 3 Left Add differences
		Iterable<Diff> leftAdd = filter(differencesBefore, and(fromSide(DifferenceSource.LEFT),
				ofKind(DifferenceKind.ADD), hasState(DifferenceState.UNRESOLVED)));
		assertEquals(3, size(leftAdd));
		// 3 Right Add differences
		Iterable<Diff> rightAdd = filter(differencesBefore, and(fromSide(DifferenceSource.RIGHT),
				ofKind(DifferenceKind.ADD), hasState(DifferenceState.UNRESOLVED)));
		assertEquals(3, size(rightAdd));

		// Execute command
		command.execute();

		EList<Diff> differencesAfter = comparison.getDifferences();
		// Test state of differences after command
		// 3 Left Delete differences merged
		leftDelete = filter(differencesAfter, and(fromSide(DifferenceSource.LEFT),
				ofKind(DifferenceKind.DELETE), hasState(DifferenceState.MERGED)));
		assertEquals(3, size(leftDelete));
		// 3 Right Delete differences merged
		rightDelete = filter(differencesAfter, and(fromSide(DifferenceSource.RIGHT),
				ofKind(DifferenceKind.DELETE), hasState(DifferenceState.MERGED)));
		assertEquals(3, size(rightDelete));
		// 3 Left Add differences merged
		leftAdd = filter(differencesAfter, and(fromSide(DifferenceSource.LEFT), ofKind(DifferenceKind.ADD),
				hasState(DifferenceState.MERGED)));
		assertEquals(3, size(leftAdd));
		// 3 Right Add differences merged
		rightAdd = filter(differencesAfter, and(fromSide(DifferenceSource.RIGHT), ofKind(DifferenceKind.ADD),
				hasState(DifferenceState.MERGED)));
		assertEquals(3, size(rightAdd));

		command.dispose();
		editingDomain.dispose();
	}

	@Test
	public void testRejectAllNonConflictingChangesThreeWayWithoutConflicts() throws IOException {
		MergeMode mergeMode = MergeMode.REJECT;
		boolean leftToRight = false;
		boolean isLeftEditable = true;
		boolean isRightEditable = false;

		IComparisonScope scope = new DefaultComparisonScope(leftResource, rightResource, originResource);
		Comparison comparison = EMFCompare.builder().build().compare(scope);

		EMFCompareEditingDomain editingDomain = (EMFCompareEditingDomain)EMFCompareEditingDomain.create(
				leftResource, rightResource, originResource);
		ChangeRecorder changeRecorder = editingDomain.getChangeRecorder();

		ImmutableSet.Builder<Notifier> notifiersBuilder = ImmutableSet.builder();
		ImmutableSet<Notifier> notifiers = notifiersBuilder.add(comparison).addAll(
				ImmutableList.of(leftResource, rightResource, originResource)).build();

		MergeNonConflictingRunnable runnable = new MergeNonConflictingRunnable(isLeftEditable,
				isRightEditable, mergeMode);

		MergeAllNonConflictingCommand command = new MergeAllNonConflictingCommand(changeRecorder, notifiers,
				comparison, leftToRight, mergerRegistry, runnable);

		EList<Diff> differencesBefore = comparison.getDifferences();
		// Test state of differences before command
		// 3 Left Delete differences
		Iterable<Diff> leftDelete = filter(differencesBefore, and(fromSide(DifferenceSource.LEFT),
				ofKind(DifferenceKind.DELETE), hasState(DifferenceState.UNRESOLVED)));
		assertEquals(3, size(leftDelete));
		// 3 Right Delete differences
		Iterable<Diff> rightDelete = filter(differencesBefore, and(fromSide(DifferenceSource.RIGHT),
				ofKind(DifferenceKind.DELETE), hasState(DifferenceState.UNRESOLVED)));
		assertEquals(3, size(rightDelete));
		// 3 Left Add differences
		Iterable<Diff> leftAdd = filter(differencesBefore, and(fromSide(DifferenceSource.LEFT),
				ofKind(DifferenceKind.ADD), hasState(DifferenceState.UNRESOLVED)));
		assertEquals(3, size(leftAdd));
		// 3 Right Add differences
		Iterable<Diff> rightAdd = filter(differencesBefore, and(fromSide(DifferenceSource.RIGHT),
				ofKind(DifferenceKind.ADD), hasState(DifferenceState.UNRESOLVED)));
		assertEquals(3, size(rightAdd));

		// Execute command
		command.execute();

		EList<Diff> differencesAfter = comparison.getDifferences();
		// Test state of differences after command
		// 3 Left Delete differences merged
		leftDelete = filter(differencesAfter, and(fromSide(DifferenceSource.LEFT),
				ofKind(DifferenceKind.DELETE), hasState(DifferenceState.MERGED)));
		assertEquals(3, size(leftDelete));
		// 3 Right Delete differences merged
		rightDelete = filter(differencesAfter, and(fromSide(DifferenceSource.RIGHT),
				ofKind(DifferenceKind.DELETE), hasState(DifferenceState.MERGED)));
		assertEquals(3, size(rightDelete));
		// 3 Left Add differences merged
		leftAdd = filter(differencesAfter, and(fromSide(DifferenceSource.LEFT), ofKind(DifferenceKind.ADD),
				hasState(DifferenceState.MERGED)));
		assertEquals(3, size(leftAdd));
		// 3 Right Add differences merged
		rightAdd = filter(differencesAfter, and(fromSide(DifferenceSource.RIGHT), ofKind(DifferenceKind.ADD),
				hasState(DifferenceState.MERGED)));
		assertEquals(3, size(rightAdd));

		command.dispose();
		editingDomain.dispose();
	}

	@Test
	public void testMergeAllNonConflictingChangesFromLeftToRightTwoWay() throws IOException {
		testMergeAllNonConflictingTwoWay(MergeMode.LEFT_TO_RIGHT);
	}

	@Test
	public void testMergeAllNonConflictingChangesFromRightToLeftTwoWay() throws IOException {
		testMergeAllNonConflictingTwoWay(MergeMode.RIGHT_TO_LEFT);
	}

	private void testMergeAllNonConflictingTwoWay(MergeMode mergeMode) {
		boolean isLeftEditable = true;
		boolean isRightEditable = true;

		IComparisonScope scope = new DefaultComparisonScope(leftResource, originResource, null);
		Comparison comparison = EMFCompare.builder().build().compare(scope);

		EMFCompareEditingDomain editingDomain = (EMFCompareEditingDomain)EMFCompareEditingDomain.create(
				leftResource, originResource, null);
		ChangeRecorder changeRecorder = editingDomain.getChangeRecorder();

		ImmutableSet.Builder<Notifier> notifiersBuilder = ImmutableSet.builder();
		ImmutableSet<Notifier> notifiers = notifiersBuilder.add(comparison).addAll(
				ImmutableList.of(leftResource, originResource)).build();

		MergeNonConflictingRunnable runnable = new MergeNonConflictingRunnable(isLeftEditable,
				isRightEditable, mergeMode);

		MergeAllNonConflictingCommand command = new MergeAllNonConflictingCommand(changeRecorder, notifiers,
				comparison, mergeMode.isLeftToRight(isLeftEditable, isRightEditable), mergerRegistry,
				runnable);

		EList<Diff> differencesBefore = comparison.getDifferences();
		// Test state of differences before command
		// 3 Left Delete differences
		Iterable<Diff> leftDelete = filter(differencesBefore, and(fromSide(DifferenceSource.LEFT),
				ofKind(DifferenceKind.DELETE), hasState(DifferenceState.UNRESOLVED)));
		assertEquals(3, size(leftDelete));
		// 3 Left Add differences
		Iterable<Diff> leftAdd = filter(differencesBefore, and(fromSide(DifferenceSource.LEFT),
				ofKind(DifferenceKind.ADD), hasState(DifferenceState.UNRESOLVED)));
		assertEquals(3, size(leftAdd));

		// Execute command
		command.execute();

		EList<Diff> differencesAfter = comparison.getDifferences();
		// Test state of differences after command
		// 3 Left Delete differences merged
		leftDelete = filter(differencesAfter, and(fromSide(DifferenceSource.LEFT),
				ofKind(DifferenceKind.DELETE), hasState(DifferenceState.MERGED)));
		assertEquals(3, size(leftDelete));
		// 3 Left Add differences merged
		leftAdd = filter(differencesAfter, and(fromSide(DifferenceSource.LEFT), ofKind(DifferenceKind.ADD),
				hasState(DifferenceState.MERGED)));
		assertEquals(3, size(leftAdd));

		command.dispose();
		editingDomain.dispose();
	}
}