/*******************************************************************************
 * Copyright (c) 2012 Oracle. 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:
 *     Oracle - initial API and implementation
 ******************************************************************************/
package org.eclipse.jpt.jpa.eclipselink.ui.internal.entity.data.model;

import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;
import java.util.Set;

import org.eclipse.core.resources.IProject;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Status;
import org.eclipse.jdt.core.ICompilationUnit;
import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.IPackageFragment;
import org.eclipse.jdt.core.IPackageFragmentRoot;
import org.eclipse.jdt.core.IType;
import org.eclipse.jdt.core.JavaConventions;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.core.Signature;
import org.eclipse.jpt.common.utility.internal.CollectionTools;
import org.eclipse.jpt.common.utility.internal.StringTools;
import org.eclipse.jpt.common.utility.internal.iterables.TransformationIterable;
import org.eclipse.jpt.jpa.core.JpaFacet;
import org.eclipse.jpt.jpa.core.JpaProject;
import org.eclipse.jpt.jpa.core.MappingKeys;
import org.eclipse.jpt.jpa.core.context.JpaRootContextNode;
import org.eclipse.jpt.jpa.core.context.persistence.Persistence;
import org.eclipse.jpt.jpa.core.context.persistence.PersistenceUnit;
import org.eclipse.jpt.jpa.core.context.persistence.PersistenceXml;
import org.eclipse.jpt.jpa.core.resource.xml.JpaXmlResource;
import org.eclipse.jpt.jpa.eclipselink.core.context.persistence.EclipseLinkPersistenceUnit;
import org.eclipse.jpt.jpa.eclipselink.ui.JptJpaEclipseLinkUiPlugin;
import org.eclipse.jpt.jpa.eclipselink.ui.internal.EclipseLinkUiMessages;
import org.eclipse.jpt.jpa.eclipselink.ui.internal.entity.data.operation.NewDynamicEntityClassOperation;
import org.eclipse.jpt.jpa.ui.JptJpaUiPlugin;
import org.eclipse.jpt.jpa.ui.internal.wizards.entity.data.model.IEntityDataModelProperties;
import org.eclipse.jst.j2ee.internal.common.J2EECommonMessages;
import org.eclipse.jst.j2ee.internal.common.operations.NewJavaClassDataModelProvider;
import org.eclipse.osgi.util.NLS;
import org.eclipse.wst.common.frameworks.datamodel.IDataModel;
import org.eclipse.wst.common.frameworks.datamodel.IDataModelOperation;
import org.eclipse.wst.common.frameworks.datamodel.IDataModelProvider;
import org.eclipse.wst.common.frameworks.internal.plugin.WTPCommonPlugin;

import com.ibm.icu.text.MessageFormat;

public class DynamicEntityDataModelProvider extends NewJavaClassDataModelProvider implements IEntityDataModelProperties {

	private static final String DOT = "."; //$NON-NLS-1$

	@Override
	public IDataModelOperation getDefaultOperation() {
		return new NewDynamicEntityClassOperation(getDataModel());
	}

	// ************** model properties ****************
	/**
	 * Extends: <code>IDataModelProvider#getPropertyNames()</code>
	 * and add own data model's properties specific for the dynamic entity model
	 * 
	 * @see org.eclipse.wst.common.frameworks.datamodel.IDataModelProvider#getPropertyNames()
	 */
	@Override
	public Set<String> getPropertyNames() {		
		Set<String> propertyNames = super.getPropertyNames();
		propertyNames.add(ENTITY);
		propertyNames.add(XML_NAME);
		propertyNames.add(ENTITY_NAME);
		propertyNames.add(TABLE_NAME_DEFAULT);		
		propertyNames.add(TABLE_NAME);
		propertyNames.add(ENTITY_FIELDS);
		propertyNames.add(PK_FIELDS);
		return propertyNames;
	}

	/**
	 * Returns the default value of the parameter (which should present a valid data model property).  
	 * This method does not accept a null parameter. It may return null. 
	 * 
	 * @see NewJavaClassDataModelProvider#getDefaultProperty(String)
	 * @see IDataModelProvider#getDefaultProperty(String)
	 * 
	 * @param propertyName
	 * @return Object default value of property
	 */
	@Override
	public Object getDefaultProperty(String propertyName) {

		if (propertyName.equals(ENTITY)) {
			return Boolean.TRUE;
		} else if (propertyName.equals(XML_NAME)) {
			return EMPTY_STRING;			
		} else if (propertyName.equals(ENTITY_NAME)) {
			return getStringProperty(CLASS_NAME);			
		} else if (propertyName.equals(TABLE_NAME_DEFAULT)) {
			return Boolean.TRUE;
		} else if (propertyName.equals(TABLE_NAME)) {
			return getStringProperty(CLASS_NAME);			
		} else if (propertyName.equals(ENTITY_FIELDS)) {
			return new ArrayList<DynamicEntityField>();
		} else if (propertyName.equals(PK_FIELDS)) {
			return new ArrayList<DynamicEntityField>();
		} else if (propertyName.equals(JAVA_PACKAGE_FRAGMENT_ROOT))
			return getJavaPackageFragmentRoots();

		// Otherwise check super for default value for property
		return super.getDefaultProperty(propertyName);
	}

	@Override
	public boolean propertySet(String propertyName, Object propertyValue) {
		boolean ok = super.propertySet(propertyName, propertyValue);
		if (ok) {
			if (PROJECT_NAME.equals(propertyName) || XML_SUPPORT.equals(propertyName)) {
				this.model.notifyPropertyChange(XML_NAME, IDataModel.VALID_VALUES_CHG);
			}
		}
		return ok;
	}

	/**
	 * Returns all the the existing source path roots cross the selected project
	 * @return a set of IPackageFragmentRoot with the kind of source path
	 */
	protected IPackageFragmentRoot[] getJavaPackageFragmentRoots() {
		JpaProject jpaProject = getJpaProject();
		IPackageFragmentRoot[] packRoots = new IPackageFragmentRoot[0];
		List<IPackageFragmentRoot> rootList = new ArrayList<IPackageFragmentRoot>();
		if (jpaProject != null) {
			IJavaProject javaProject = jpaProject.getJavaProject();
			if (javaProject != null) {
				try {
					packRoots = javaProject.getAllPackageFragmentRoots();
					for (IPackageFragmentRoot root : packRoots) {
						if (root.getKind() == IPackageFragmentRoot.K_SOURCE) {
							rootList.add(root);
						}
					}
					packRoots = new IPackageFragmentRoot[rootList.size()];
					rootList.toArray(packRoots);
				} catch (JavaModelException e) {
					// fall through
					JptJpaEclipseLinkUiPlugin.log(e);
				}
			}
		}
		return packRoots;
	}

	//************** model validation ****************

	@Override
	public IStatus validate(String propertyName) {
		IStatus result = super.validate(propertyName);
		if (propertyName.equals(JAVA_PACKAGE)) {
			return validateJavaPackage(getStringProperty(propertyName));
		}
		if (propertyName.equals(XML_NAME)) {
			return validateXmlName(getStringProperty(propertyName));
		}
		if (propertyName.equals(ENTITY_FIELDS)) {
			return validateFieldsList((ArrayList<DynamicEntityField>) getProperty(propertyName));
		}
		if (propertyName.equals(PK_FIELDS)) {
			return validatePrimaryKeyFieldsList((ArrayList<DynamicEntityField>) getProperty(propertyName));
		}
		return result;		
	}

	/**
	 * This method is intended for internal use only. It will be used to validate the correctness 
	 * of entity package in accordance with Java convention requirements. 
	 * This method will accept a null parameter. 
	 * 
	 * @param packName
	 * @return IStatus is the package name satisfies Java convention requirements
	 */
	private IStatus validateJavaPackage(String packName) {		
		if (packName == null || packName.equals(EMPTY_STRING)) {
			return new Status(
					IStatus.WARNING, JptJpaEclipseLinkUiPlugin.PLUGIN_ID,
					EclipseLinkUiMessages.DynamicEntityClassWizardPage_defaultPackageWarning);
		}			
		// Use standard java conventions to validate the package name
		IStatus javaStatus = JavaConventions.validatePackageName(packName, JavaCore.VERSION_1_5, JavaCore.VERSION_1_5);
		if (javaStatus.getSeverity() == IStatus.ERROR) {
			String msg = J2EECommonMessages.ERR_JAVA_PACAKGE_NAME_INVALID + javaStatus.getMessage();
			return WTPCommonPlugin.createErrorStatus(msg);
		} else if (javaStatus.getSeverity() == IStatus.WARNING) {
			String msg = J2EECommonMessages.ERR_JAVA_PACKAGE_NAME_WARNING + javaStatus.getMessage();
			return WTPCommonPlugin.createWarningStatus(msg);
		}		
		// java package name is valid
		return Status.OK_STATUS;
	}

	/**
	 * This method is intended for internal use only. It will be used to validate 
	 * the validity of a specified mapping file and if a specified mapping file
	 * is included in the persistence unit.
	 * This method will accept a null parameter. 
	 * 
	 * @param xmlName
	 * @return IStatus is the mapping file exists or is the mapping file included
	 * in the persistence unit
	 */
	private IStatus validateXmlName(String xmlName) {
		IProject project = this.getTargetProject();
		if (project != null) {
			JpaXmlResource ormXmlResource = StringTools.stringIsEmpty(xmlName) ? null : getOrmXmlResource(xmlName);
			if (ormXmlResource == null) {
				return new Status(
						IStatus.ERROR, JptJpaEclipseLinkUiPlugin.PLUGIN_ID,
						EclipseLinkUiMessages.DynamicEntityClassWizardPage_invalidXMLName);
			}
			else if (this.getJpaProject().getJpaFile(ormXmlResource.getFile()).getRootStructureNodesSize() == 0) {
				return new Status(
						IStatus.ERROR, JptJpaEclipseLinkUiPlugin.PLUGIN_ID,
						EclipseLinkUiMessages.DynamicEntityClassWizardPage_xmlNotListedError);
			}
		}
		return Status.OK_STATUS;
	}

	protected JpaXmlResource getOrmXmlResource(String xmlName) {
		return getJpaProject()== null ? null : getJpaProject().getMappingFileXmlResource(new Path(xmlName));
	}

	/**
	 * This method is intended for internal use only. It will be used to validate
	 * the list of created dynamic entity fields to ensure there are no duplicates,
	 * to validate the validity and existence of a field's given attribute type, 
	 * and to validate the validity of the mapping types of the created fields.
	 * This method will accept a null parameter. 
	 * 
	 * @param list of DynamicEntityField
	 * @return IStatus are the dynamic entity field names unique
	 * 				   or is the dynamic entity field attribute type valid
	 * 				   or are the dynamic entity field mapping types valid
	 */
	private IStatus validateFieldsList(ArrayList<DynamicEntityField> fields) {
		if (fields != null && !fields.isEmpty()) {
			// Ensure there are no dynamic entity fields that have the same name in the table
			boolean hasDuplicates = hasDuplicatesInEntityFields(fields);
			if (hasDuplicates) {
				return new Status(
						IStatus.ERROR, JptJpaEclipseLinkUiPlugin.PLUGIN_ID,
						EclipseLinkUiMessages.DynamicEntityFieldsWizardPage_duplicateEntityFieldsError);
			}
			// Ensure ID and EmbeddedID mapping are not defined at the same time
			// and also ensure there's no multiple EmbeddedID mappings defined
			String errorMsg1 = checkInputFieldsMappingTypes(fields);
			if (errorMsg1 != null) {
				return new Status(IStatus.ERROR, JptJpaEclipseLinkUiPlugin.PLUGIN_ID, errorMsg1);
			}
			// Ensure that the given type of the dynamic entity fields in the table are valid
			String errorMsg2 = checkInputFieldsAttributeTypeValidity(fields);
			if (errorMsg2 != null) {
				return new Status(IStatus.ERROR, JptJpaEclipseLinkUiPlugin.PLUGIN_ID, errorMsg2);
			}
			// Ensure that the given type of the dynamic entity fields in the table exist
			String warningMsg = checkInputFieldsAttributeTypeExistence(fields);
			if (warningMsg != null) {
				return new Status(IStatus.WARNING, JptJpaEclipseLinkUiPlugin.PLUGIN_ID, warningMsg);
			}
		}
		return Status.OK_STATUS;
	}

	private String checkInputFieldsMappingTypes(ArrayList<DynamicEntityField> fields) {
		IStatus validateFieldMappingTypeStatus = Status.OK_STATUS;
		Iterable<String> mappingKeys = this.getMappingKeys(fields);
		if (hasIDAndEmbeddedIDMappingDefined(mappingKeys)) {
			validateFieldMappingTypeStatus = new Status(IStatus.ERROR, JptJpaUiPlugin.PLUGIN_ID, 
					EclipseLinkUiMessages.EclipseLinkDynamicEntityWizard_bothIDAndEmbeddedIDDefinedError);
		} else if (hasMultipleEmbeddedIDMappings(mappingKeys)) {
			validateFieldMappingTypeStatus = new Status(IStatus.ERROR, JptJpaUiPlugin.PLUGIN_ID, 
					EclipseLinkUiMessages.EclipseLinkDynamicEntityWizard_multipleEmbeddedIDsDefinedError);
		}
		if (!validateFieldMappingTypeStatus.isOK()) {
			return validateFieldMappingTypeStatus.getMessage();
		}
		return null;
	}

	private Iterable<String> getMappingKeys(ArrayList<DynamicEntityField> fields) {
		return new TransformationIterable<DynamicEntityField, String>(fields) {
			@Override
			protected String transform(DynamicEntityField field) {
				return field.getMappingType().getKey();
			}
		};
	}

	private boolean hasIDAndEmbeddedIDMappingDefined(Iterable<String> mappingKeys) {
		return CollectionTools.contains(mappingKeys, MappingKeys.ID_ATTRIBUTE_MAPPING_KEY) 
				&& CollectionTools.contains(mappingKeys, MappingKeys.EMBEDDED_ID_ATTRIBUTE_MAPPING_KEY);
	}

	private boolean hasMultipleEmbeddedIDMappings(Iterable<String> mappingKeys) {
		int i = 0;
		for (String key : mappingKeys) {
			if (key == MappingKeys.EMBEDDED_ID_ATTRIBUTE_MAPPING_KEY) {
				i++;
				if (i > 1) return true;
			}
		}
		return false;
	}

	private String checkInputFieldsAttributeTypeValidity(List<DynamicEntityField> fields) {
		IStatus validateFieldTypeStatus = Status.OK_STATUS;
		for (DynamicEntityField field: fields) {
			if (field.isKey() && !field.couldTypeBePKType()) {
				String message = MessageFormat.format(
						EclipseLinkUiMessages.EclipseLinkDynamicEntityWizard_invalidPKType, new Object[]{field.getFqnTypeName()});
				validateFieldTypeStatus = new Status(IStatus.ERROR,	JptJpaEclipseLinkUiPlugin.PLUGIN_ID, message);
				break;				
			}
			String sig = null;
			try {
				sig = Signature.createTypeSignature(field.getFqnTypeName(), true);
			} catch (IllegalArgumentException e) {
				String message = MessageFormat.format(EclipseLinkUiMessages.EclipseLinkDynamicEntityWizard_invalidArgument, new Object[]{e.getLocalizedMessage()});
				validateFieldTypeStatus = new Status(IStatus.ERROR, JptJpaEclipseLinkUiPlugin.PLUGIN_ID, message);
				break;
			}
			if (sig == null){
				validateFieldTypeStatus = JavaConventions.validateJavaTypeName(field.getType(), JavaCore.VERSION_1_5, JavaCore.VERSION_1_5);
				break;
			}
			int sigType = Signature.getTypeSignatureKind(sig);
			if (sigType == Signature.BASE_TYPE_SIGNATURE) {
				continue;
			}
			else if (sigType == Signature.ARRAY_TYPE_SIGNATURE) {
				String elementSignature = Signature.getElementType(sig);
				if (Signature.getTypeSignatureKind(elementSignature) == Signature.BASE_TYPE_SIGNATURE) {
					continue;
				}
			}
		}
		if (!validateFieldTypeStatus.isOK()) {
			return validateFieldTypeStatus.getMessage();
		}
		return null;
	}

	protected String checkInputFieldsAttributeTypeExistence(List<DynamicEntityField> fields) {
		IStatus validateFieldTypeStatus=Status.OK_STATUS;
		for (DynamicEntityField field: fields) {
			String sig = Signature.createTypeSignature(field.getFqnTypeName() ,true);
			if (sig == null) {
				String message = MessageFormat.format(
						EclipseLinkUiMessages.EclipseLinkDynamicEntityWizard_typeNotInProjectClasspath, new Object[]{field.getFqnTypeName()});
				validateFieldTypeStatus = new Status(IStatus.ERROR, JptJpaEclipseLinkUiPlugin.PLUGIN_ID, message);
				break;
			}
			int sigType = Signature.getTypeSignatureKind(sig);
			if (sigType == Signature.BASE_TYPE_SIGNATURE){
				continue;
			} else if (sigType == Signature.ARRAY_TYPE_SIGNATURE) {
				String elementSignature = Signature.getElementType(sig);
				if(Signature.getTypeSignatureKind(elementSignature) == Signature.BASE_TYPE_SIGNATURE){
					continue;
				}
				String qualifiedName = Signature.toString(elementSignature);
				IProject project = getTargetProject();
				IJavaProject javaProject = JavaCore.create(project);
				IType type = null;
				try {
					type = javaProject.findType(qualifiedName);
				} catch (JavaModelException e) {
					validateFieldTypeStatus = e.getStatus();
					break;
				} 
				if (type == null) {
					String message = MessageFormat.format(
							EclipseLinkUiMessages.EclipseLinkDynamicEntityWizard_typeNotInProjectClasspath, new Object[]{field.getFqnTypeName()});
					validateFieldTypeStatus = new Status(IStatus.ERROR,
							JptJpaEclipseLinkUiPlugin.PLUGIN_ID, message);
					break;
				}
			} else {
				IProject project = getTargetProject();
				IJavaProject javaProject = JavaCore.create(project);
				IType type = null;
				try {
					type = javaProject.findType(field.getFqnTypeName());
				} catch (JavaModelException e) {
					validateFieldTypeStatus = e.getStatus();
					break;
				}
				if (type == null) {
					String message = MessageFormat.format(
							EclipseLinkUiMessages.EclipseLinkDynamicEntityWizard_typeNotInProjectClasspath, new Object[]{field.getFqnTypeName()});
					validateFieldTypeStatus = new Status(IStatus.ERROR,
							JptJpaEclipseLinkUiPlugin.PLUGIN_ID, message);
					break;
				}
			}
		}
		if(!validateFieldTypeStatus.isOK()) {
			return validateFieldTypeStatus.getMessage();
		}
		return null;
	}

	/**
	 * This method is intended for internal use only. It provides a simple 
	 * algorithm for detecting dynamic entity fields that have duplicate names. 
	 * It will accept a null parameter and return boolean.
	 * 
	 * @param list of DynamicEntityField
	 * @return boolean true if duplicate fields exist; otherwise, false
	 */
	private boolean hasDuplicatesInEntityFields(ArrayList<DynamicEntityField> fields) {
		if (fields == null) {
			return false;
		}
		int n = fields.size();
		// nested for loops to check each element to see if other elements are the same
		for (int i = 0; i < n; i++) {
			DynamicEntityField field = fields.get(i);
			for (int j = i + 1; j < n; j++) {
				DynamicEntityField intEntity = fields.get(j);
				if (intEntity.getName().equals(field.getName())) {
					return true;
				}
			}
		}
		return false;
	}

	/**
	 * This method is intended for internal use only. It will be used to validate if
	 * there are multiple dynamic entity field with ID mapping type defined and give
	 * the corresponding information if there are.
	 * It will accept a null parameter.
	 * 
	 * @param list of DynamicEntityField with ID mapping type
	 * @return boolean true if duplicate fields exist; otherwise, false
	 */
	private IStatus validatePrimaryKeyFieldsList(ArrayList<DynamicEntityField> pkFields) {
		if (pkFields.size() > 1) {
			return new Status(
					IStatus.INFO, JptJpaEclipseLinkUiPlugin.PLUGIN_ID,
					EclipseLinkUiMessages.EclipseLinkDynamicEntityWizard_applyEmbeddedIdMappingInfo);
		}
		return null;
	}

	/**
	 * This method is used to validate if a type with the same full qualified name as the dynamic
	 * entity exists. If a Java type or a static ORM type with the given name exists, a warning is given; 
	 * if a dynamic type with the given name exists, an error is given. Different message is 
	 * given if the given name and the existing one are same but with different cases.
	 * 
	 * Since source folder is not a consideration of dynamic entities, we will give a warning
	 * message if a Java type with the given full qualified name (package name + type name) exists
	 * regardless which source folder the Java type exists in.
	 * 
	 * @param packageName package name specified
	 * 		  typeName    class name specified
	 * @return IStatus does the type with the given full qualified name exists
	 */
	@Override
	protected IStatus canCreateTypeInClasspath(String packageName, String typeName) {
		String fullyQualifiedName = StringTools.EMPTY_STRING;
		if (!StringTools.stringIsEmpty(packageName)) {
			fullyQualifiedName = packageName + DOT + typeName;
		} else {
			fullyQualifiedName = typeName;
		}
		//Since the existence of a static ORM type depends on the corresponding Java type,
		//there is no need for a separate validation of it.
		for (String name : this.getJavaTypeNames()) {
			if (StringTools.stringsAreEqual(name, fullyQualifiedName)) {
				String message = NLS.bind(
						EclipseLinkUiMessages.EclipseLinkDynamicEntityWizard_typeExistsWarning, 
						new Object[] { fullyQualifiedName });
				return new Status(IStatus.WARNING, JptJpaEclipseLinkUiPlugin.PLUGIN_ID, message);

			} else if (StringTools.stringsAreEqualIgnoreCase(name, fullyQualifiedName)) {
				String message = NLS.bind(
						EclipseLinkUiMessages.EclipseLinkDynamicEntityWizard_typeWithDiffCaseExistsWarning, 
						new Object[] { fullyQualifiedName });
				return new Status(IStatus.WARNING, JptJpaEclipseLinkUiPlugin.PLUGIN_ID, message);
			}
		}
		PersistenceUnit pu = this.getPersistenceUnit();
		if (pu != null) {
			for (String name : ((EclipseLinkPersistenceUnit)this.getPersistenceUnit()).getEclipseLinkDynamicPersistentTypeNames()) {
				if (StringTools.stringsAreEqual(name, fullyQualifiedName)) {
					String message = NLS.bind(
							EclipseLinkUiMessages.EclipseLinkDynamicEntityWizard_dynamicTypeExistsError, 
							new Object[] { fullyQualifiedName });
					return new Status(IStatus.ERROR, JptJpaEclipseLinkUiPlugin.PLUGIN_ID, message);

				} else if (StringTools.stringsAreEqualIgnoreCase(name, fullyQualifiedName)) {
					String message = NLS.bind(
							EclipseLinkUiMessages.EclipseLinkDynamicEntityWizard_dynamicTypeWithDiffCaseExistsError, 
							new Object[] { fullyQualifiedName });
					return new Status(IStatus.ERROR, JptJpaEclipseLinkUiPlugin.PLUGIN_ID, message);
				}
			}
		} else {
			return new Status(IStatus.ERROR, JptJpaEclipseLinkUiPlugin.PLUGIN_ID, 
					EclipseLinkUiMessages.EclipseLinkDynamicEntityWizard_persistenceUnitNotFoundError);
		}
		return Status.OK_STATUS;
	}

	/**
	 * Returns the names of the given list of IType
	 */
	private Iterable<String> getJavaTypeNames() {
		return new TransformationIterable<IType, String>(this.getJavaTypes()) {
			@Override
			protected String transform(IType type) {
				return type.getFullyQualifiedName();
			}
		};
	}

	/**
	 * Returns all the Java types cross the select project
	 */
	protected List<IType> getJavaTypes() {
		IPackageFragmentRoot[] packRoots = this.getJavaPackageFragmentRoots();
		List<IType> typesList = new ArrayList<IType>();
		for (IPackageFragmentRoot root : packRoots) {
			try {
				IJavaElement[] jElements = root.getChildren();
				for (IJavaElement jElement : jElements) {
					if (jElement.getElementType() == IJavaElement.PACKAGE_FRAGMENT) {
						ICompilationUnit[] units = ((IPackageFragment) jElement).getCompilationUnits();
						for (ICompilationUnit unit : units) {
							CollectionTools.addAll(typesList, unit.getTypes());
						}
					}
				}
			} catch (JavaModelException e) {
				// fall through
				JptJpaEclipseLinkUiPlugin.log(e);
			}
		}	
		return typesList;
	}

	// ****************** misc ***********************

	protected JpaProject getJpaProject() {
		IProject project = getTargetProject();
		return ((project != null) && JpaFacet.isInstalled(project)) ?
				this.getJpaProject(project) :
					null;
	}

	protected JpaProject getJpaProject(IProject project) {
		return (JpaProject) project.getAdapter(JpaProject.class);
	}

	protected PersistenceUnit getPersistenceUnit() {
		Persistence p = this.getPersistence();
		if (p == null) {
			return null;
		}
		ListIterator<PersistenceUnit> units = p.getPersistenceUnits().iterator();
		return units.hasNext() ? units.next() : null;
	}

	protected Persistence getPersistence() {
		PersistenceXml pxml = this.getPersistenceXml();
		return (pxml == null) ? null : pxml.getPersistence();
	}

	protected PersistenceXml getPersistenceXml() {
		JpaRootContextNode rcn = this.getJpaProject().getRootContextNode();
		return (rcn == null) ? null : rcn.getPersistenceXml();
	}
}