/*******************************************************************************
 * Copyright (c) 2013, 2016 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.emf.compare.merge;

import static org.eclipse.emf.compare.ConflictKind.REAL;
import static org.eclipse.emf.compare.DifferenceKind.DELETE;
import static org.eclipse.emf.compare.DifferenceKind.MOVE;
import static org.eclipse.emf.compare.DifferenceSource.LEFT;
import static org.eclipse.emf.compare.DifferenceSource.RIGHT;
import static org.eclipse.emf.compare.DifferenceState.DISCARDED;
import static org.eclipse.emf.compare.merge.IMergeCriterion.NONE;

import com.google.common.base.Predicate;
import com.google.common.base.Predicates;

import java.util.Iterator;
import java.util.List;
import java.util.Set;

import org.eclipse.emf.common.util.Monitor;
import org.eclipse.emf.compare.Conflict;
import org.eclipse.emf.compare.Diff;
import org.eclipse.emf.compare.DifferenceKind;
import org.eclipse.emf.compare.DifferenceSource;
import org.eclipse.emf.compare.ReferenceChange;
import org.eclipse.emf.compare.utils.IEqualityHelper;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.util.InternalEList;

/**
 * This specific implementation of {@link AbstractMerger} will be used to merge real conflicts.
 * 
 * @author <a href="mailto:axel.richard@obeo.fr">Axel Richard</a>
 * @since 3.1
 */
public class ConflictMerger extends AbstractMerger {

	/**
	 * {@inheritDoc}
	 * 
	 * @see org.eclipse.emf.compare.merge.IMerger#isMergerFor(org.eclipse.emf.compare.Diff)
	 */
	public boolean isMergerFor(Diff target) {
		final Conflict conflict = target.getConflict();
		return conflict != null && conflict.getKind() == REAL;
	}

	@Override
	public boolean apply(IMergeCriterion criterion) {
		return criterion == null || criterion == NONE;
	}

	/**
	 * {@inheritDoc}
	 * 
	 * @see org.eclipse.emf.compare.merge.IMerger#copyLeftToRight(org.eclipse.emf.compare.Diff,
	 *      org.eclipse.emf.common.util.Monitor)
	 */
	@Override
	public void copyLeftToRight(Diff target, Monitor monitor) {
		if (isInTerminalState(target)) {
			return;
		}

		if (target.getSource() == LEFT) {
			// Call the appropriate merger for each conflicted diff
			Conflict conflict = target.getConflict();
			Predicate<Diff> conflictVsMoveAndDelete = isConflictVsMoveAndDelete(target, MOVE, DELETE);
			for (Diff conflictedDiff : getDifferences(conflict)) {
				if (conflictedDiff.getSource() == RIGHT) {
					if (conflictVsMoveAndDelete.apply(conflictedDiff)) {
						conflictedDiff.setState(DISCARDED);
					} else {
						mergeConflictedDiff(conflictedDiff, true, monitor);
					}
				}
			}
		}

		// Call the appropriate merger for the current diff
		getMergerDelegate(target).copyLeftToRight(target, monitor);

	}

	/**
	 * {@inheritDoc}
	 * 
	 * @see org.eclipse.emf.compare.merge.IMerger#copyRightToLeft(org.eclipse.emf.compare.Diff,
	 *      org.eclipse.emf.common.util.Monitor)
	 */
	@Override
	public void copyRightToLeft(Diff target, Monitor monitor) {
		if (isInTerminalState(target)) {
			return;
		}

		if (target.getSource() == RIGHT) {
			// Call the appropriate merger for each conflicted diff
			Conflict conflict = target.getConflict();
			Predicate<Diff> conflictVsMoveAndDelete = isConflictVsMoveAndDelete(target, MOVE, DELETE);
			for (Diff conflictedDiff : getDifferences(conflict)) {
				if (conflictedDiff.getSource() == LEFT) {
					if (conflictVsMoveAndDelete.apply(conflictedDiff)) {
						conflictedDiff.setState(DISCARDED);
					} else {
						mergeConflictedDiff(conflictedDiff, false, monitor);
					}
				}
			}
		}

		// Call the appropriate merger for the current diff
		getMergerDelegate(target).copyRightToLeft(target, monitor);
	}

	@Override
	public Set<Diff> getDirectMergeDependencies(Diff diff, boolean rightToLeft) {
		Set<Diff> result = super.getDirectMergeDependencies(diff, rightToLeft);
		if (AbstractMerger.isAccepting(diff, rightToLeft)) {
			Conflict conflict = diff.getConflict();
			DifferenceSource source = diff.getSource();
			Predicate<Diff> conflictVsMoveAndDelete = isConflictVsMoveAndDelete(diff, DELETE, MOVE);
			// Add each conflicting diff from the other side
			for (Diff conflictingDiff : getDifferences(conflict)) {
				if (conflictingDiff.getSource() != source && conflictingDiff.getKind() != MOVE
						&& !conflictVsMoveAndDelete.apply(conflictingDiff)) {
					result.add(conflictingDiff);
				}
			}
		}
		return result;
	}

	@Override
	public Set<Diff> getDirectResultingMerges(Diff diff, boolean rightToLeft) {
		Set<Diff> result = super.getDirectResultingMerges(diff, rightToLeft);

		if (AbstractMerger.isAccepting(diff, rightToLeft)) {
			Conflict conflict = diff.getConflict();
			DifferenceSource source = diff.getSource();
			Predicate<Diff> conflictVsMoveAndDelete = isConflictVsMoveAndDelete(diff, DELETE, MOVE);
			for (Diff conflictingDiff : getDifferences(conflict)) {
				if (conflictingDiff.getSource() != source && (conflictingDiff.getKind() != MOVE
						|| conflictVsMoveAndDelete.apply(conflictingDiff))) {
					result.add(conflictingDiff);
				}
			}
		}
		return result;
	}

	/**
	 * Returns the unresolving basic list for the {@link Conflict#getDifferences() conflict's differences}.
	 * 
	 * @param conflict
	 *            the conflict.
	 * @return the unresolving basic list for the conflict's differences.
	 */
	private List<Diff> getDifferences(Conflict conflict) {
		return ((InternalEList<Diff>)conflict.getDifferences()).basicList();
	}

	/**
	 * A predicate to test if the given diff and the predicate's diff are diffs on the same object with one
	 * move and one delete. The move diff must be the one selected by the user for merging.
	 * 
	 * @param diff
	 *            the given diff.
	 * @param diffKind
	 *            the kind of the given diff.
	 * @param otherDiffKind
	 *            the kind of the predicate's diff.
	 * @return A predicate to test if the given diff and the predicate's diff are diffs on the same object
	 *         with one move and one delete.
	 */
	private Predicate<Diff> isConflictVsMoveAndDelete(final Diff diff, DifferenceKind diffKind,
			final DifferenceKind otherDiffKind) {
		if (diff.getKind() == diffKind && diff instanceof ReferenceChange) {
			return new Predicate<Diff>() {
				private EObject targetValue;

				private IEqualityHelper equalityHelper;

				public boolean apply(Diff input) {
					if (input.getKind() == otherDiffKind && input instanceof ReferenceChange) {
						if (equalityHelper == null) {
							equalityHelper = diff.getMatch().getComparison().getEqualityHelper();
							targetValue = ((ReferenceChange)diff).getValue();
						}
						return equalityHelper.matchingValues(targetValue,
								((ReferenceChange)input).getValue());
					} else {
						return false;
					}
				}
			};
		} else {
			return Predicates.alwaysFalse();
		}
	}

	/**
	 * Manages the merge of the given conflicted diff.
	 * 
	 * @param conflictedDiff
	 *            The given diff.
	 * @param leftToRight
	 *            The way of merge.
	 * @param monitor
	 *            Monitor.
	 */
	private void mergeConflictedDiff(Diff conflictedDiff, boolean leftToRight, Monitor monitor) {
		if (conflictedDiff.getKind() != MOVE) {
			DelegatingMerger delegate = getMergerDelegate(conflictedDiff);
			if (leftToRight) {
				delegate.copyLeftToRight(conflictedDiff, monitor);
			} else {
				delegate.copyRightToLeft(conflictedDiff, monitor);
			}
		} else {
			conflictedDiff.setState(DISCARDED);
		}
	}

	@Override
	protected DelegatingMerger getMergerDelegate(Diff diff) {
		IMergeCriterion criterion = (IMergeCriterion)getMergeOptions()
				.get(IMergeCriterion.OPTION_MERGE_CRITERION);
		Iterator<IMerger> it = ((Registry2)getRegistry()).getMergersByRankDescending(diff, criterion);
		IMerger merger = this;
		while (it.hasNext() && merger == this) {
			merger = it.next();
		}
		if (merger == null) {
			throw new IllegalStateException("No merger found for diff " + diff.getClass().getSimpleName()); //$NON-NLS-1$
		}
		return new DelegatingMerger(merger, criterion);
	}
}