/*
 * Copyright (c) 2013, 2018 CEA and others.
 * 
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v2.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v20.html
 *
 * Contributors:
 *   Christian W. Damus (CEA) - initial API and implementation
 *   Kenn Hussey - 535301
 *
 */
package org.eclipse.uml2.uml.bug.tests;

import java.net.URL;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import junit.framework.Test;
import junit.framework.TestCase;
import junit.framework.TestSuite;

import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.EClassifier;
import org.eclipse.emf.ecore.EPackage;
import org.eclipse.emf.ecore.EReference;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.ecore.resource.ResourceSet;
import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl;
import org.eclipse.emf.ecore.util.EcoreUtil;
import org.eclipse.emf.ecore.xmi.impl.EMOFExtendedMetaData;
import org.eclipse.uml2.common.util.UML2Util;
import org.eclipse.uml2.uml.Package;
import org.eclipse.uml2.uml.Property;
import org.eclipse.uml2.uml.Type;
import org.eclipse.uml2.uml.UMLPackage;
import org.eclipse.uml2.uml.tests.util.StandaloneSupport;
import org.eclipse.uml2.uml.util.UMLUtil;

/**
 * Tests the support for UML-to-Ecore and Ecore-to-UML transformation of
 * non-navigable association ends for OCL support.
 * 
 * @see https://bugs.eclipse.org/bugs/show_bug.cgi?id=420338
 */
public class Bug420338Test
		extends TestCase {

	private ResourceSet rset;

	private Package fixture;

	private EPackage eFixture;

	public Bug420338Test() {
		super();
	}

	public Bug420338Test(String name) {
		super(name);
	}

	public static Test suite() {
		return new TestSuite(Bug420338Test.class, "Bug 420338 tests"); //$NON-NLS-1$
	}

	public void testExplicitRoleName_nonNavigable() {
		convertToEcore();

		EReference b = getEReference(getEClass("A"), "b");
		assertOppositeRoleName(b, "theA");

		convertToUML();

		Property b_ = getClass("A").getOwnedAttribute("b", null);
		assertOppositeRoleName(b_, "theA");
	}

	public void testImplicitRoleName_nonNavigable() {
		convertToEcore();

		EReference n = getEReference(getEClass("M"), "n");
		assertNoOppositeRoleName(n);

		convertToUML();

		Property n_ = getClass("M").getOwnedAttribute("n", null);
		assertNoOppositeRoleName(n_);
	}

	public void testExplicitRoleName_navigable() {
		convertToEcore();

		EReference t = getEReference(getEClass("S"), "t");
		assertNoOppositeRoleName(t);

		convertToUML();

		Property t_ = getClass("S").getOwnedAttribute("t", null);
		assertOppositeRoleName(t_, "s");
	}

	public void testImplicitRoleName_noAssociation() {
		convertToEcore();

		EReference y = getEReference(getEClass("X"), "y");
		assertNoOppositeRoleName(y);

		convertToUML();

		Property y_ = getClass("X").getOwnedAttribute("y", null);
		assertNoOppositeRoleName(y_);
	}

	//
	// Test framework
	//

	@Override
	protected void setUp()
			throws Exception {

		rset = new ResourceSetImpl();
		if (StandaloneSupport.isStandalone()) {
			StandaloneSupport.init(rset);
		}

		fixture = getTestModel();
	}

	@Override
	protected void tearDown()
			throws Exception {

		fixture = null;
		eFixture = null;

		// clean up the CacheAdapter as well as we can
		for (Resource next : rset.getResources()) {
			next.unload();
			next.eAdapters().clear();
		}

		rset.getResources().clear();
		rset.eAdapters().clear();
	}

	Package getTestModel() {
		URL url = getClass().getResource("Bug420338.uml"); //$NON-NLS-1$
		return (Package) UML2Util.load(rset,
			URI.createURI(url.toExternalForm()), UMLPackage.Literals.PACKAGE);
	}

	void convertToEcore() {
		eFixture = convert(fixture);
	}

	EPackage convert(Package package_) {
		Map<String, String> options = new HashMap<String, String>();
		options.put(UMLUtil.UML2EcoreConverter.OPTION__OPPOSITE_ROLE_NAMES,
			UMLUtil.OPTION__PROCESS);

		Collection<EPackage> ecores = UMLUtil.convertToEcore(package_, options);

		assertNotNull(ecores);
		assertTrue(ecores.size() > 0);

		// we need to be able to clean these up, later
		for (EPackage next : ecores) {
			if (next.eResource() == null) {
				Resource res = rset.createResource(URI.createURI(String.format(
					"http:///%s.ecore", System.identityHashCode(next))));
				res.getContents().add(next);
			}
		}

		EPackage result = ecores.iterator().next();
		assertEquals("bug420338", result.getName());

		return result;
	}

	void convertToUML() {
		fixture = convert(eFixture);
	}

	Package convert(EPackage ePackage) {
		Map<String, String> options = new HashMap<String, String>();
		options.put(UMLUtil.Ecore2UMLConverter.OPTION__OPPOSITE_ROLE_NAMES,
			UMLUtil.OPTION__PROCESS);

		Collection<Package> umls = UMLUtil.convertFromEcore(ePackage, options);

		assertNotNull(umls);
		assertTrue(umls.size() > 0);

		// we need to be able to clean these up, later
		for (Package next : umls) {
			if (next.eResource() == null) {
				Resource res = rset.createResource(URI.createURI(String.format(
					"http:///%s.uml", System.identityHashCode(next))));
				res.getContents().add(next);
			}
		}

		Package result = umls.iterator().next();
		assertEquals("bug420338", result.getName());

		return result;
	}

	EClass getEClass(String name) {
		return getEClass(eFixture, name);
	}

	EClass getEClass(EPackage ePackage, String name) {
		return getEClassifier(ePackage, name, EClass.class);
	}

	<T extends EClassifier> T getEClassifier(EPackage ePackage, String name,
			Class<T> metaclass) {
		EClassifier result = ePackage.getEClassifier(name);
		assertTrue(metaclass.isInstance(result));
		return metaclass.cast(result);
	}

	EReference getEReference(EClass eClass, String name) {
		return getEStructuralFeature(eClass, name, EReference.class);
	}

	<T extends EStructuralFeature> T getEStructuralFeature(EClass eClass,
			String name, Class<T> metaclass) {

		EStructuralFeature result = eClass.getEStructuralFeature(name);
		assertTrue(metaclass.isInstance(result));
		return metaclass.cast(result);
	}

	org.eclipse.uml2.uml.Class getClass(String name) {
		return getClass(fixture, name);
	}

	org.eclipse.uml2.uml.Class getClass(Package package_, String name) {
		return getType(package_, name, org.eclipse.uml2.uml.Class.class);
	}

	<T extends Type> T getType(Package package_, String name, Class<T> metaclass) {
		Type result = package_.getOwnedType(name);
		assertTrue(metaclass.isInstance(result));
		return metaclass.cast(result);
	}

	void assertOppositeRoleName(EReference reference, String roleName) {
		String actual = EcoreUtil
			.getAnnotation(
				reference,
				EMOFExtendedMetaData.EMOF_PROPERTY_OPPOSITE_ROLE_NAME_ANNOTATION_SOURCE,
				EMOFExtendedMetaData.EMOF_COMMENT_BODY);
		assertEquals(roleName, actual);
	}

	void assertNoOppositeRoleName(EReference reference) {
		String actual = EcoreUtil
			.getAnnotation(
				reference,
				EMOFExtendedMetaData.EMOF_PROPERTY_OPPOSITE_ROLE_NAME_ANNOTATION_SOURCE,
				EMOFExtendedMetaData.EMOF_COMMENT_BODY);
		assertNull(actual);
	}

	void assertOppositeRoleName(Property property, String roleName) {
		assertNotNull(property);
		Property opposite = property.getOtherEnd();
		assertNotNull(opposite);
		assertEquals(roleName, opposite.getName());
	}

	void assertNoOppositeRoleName(Property property) {
		assertNotNull(property);
		Property opposite = property.getOtherEnd();
		assertNotNull(opposite); // Ecore-to-UML always creates an association
		assertNull(opposite.getName());
	}

}