/*******************************************************************************
 * Copyright (c) 2011, 2013 E.D.Willink and others.
 * 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:
 *     E.D.Willink - initial API and implementation
 *     E.D.Willink (CEA LIST) - Bug 399378
 *******************************************************************************/
package org.eclipse.ocl.examples.pivot.manager;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.WeakHashMap;

import org.apache.log4j.Logger;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
import org.eclipse.ocl.examples.domain.DomainConstants;
import org.eclipse.ocl.examples.domain.elements.DomainPackage;
import org.eclipse.ocl.examples.domain.elements.DomainType;
import org.eclipse.ocl.examples.domain.ids.IdManager;
import org.eclipse.ocl.examples.domain.ids.PackageId;
import org.eclipse.ocl.examples.domain.utilities.DomainUtil;
import org.eclipse.ocl.examples.pivot.AnyType;
import org.eclipse.ocl.examples.pivot.ElementExtension;
import org.eclipse.ocl.examples.pivot.Library;
import org.eclipse.ocl.examples.pivot.ParameterableElement;
import org.eclipse.ocl.examples.pivot.PrimitiveType;
import org.eclipse.ocl.examples.pivot.Root;
import org.eclipse.ocl.examples.pivot.Stereotype;
import org.eclipse.ocl.examples.pivot.TemplateBinding;
import org.eclipse.ocl.examples.pivot.TemplateParameter;
import org.eclipse.ocl.examples.pivot.TemplateParameterSubstitution;
import org.eclipse.ocl.examples.pivot.Type;
import org.eclipse.ocl.examples.pivot.utilities.IllegalMetamodelException;
import org.eclipse.ocl.examples.pivot.utilities.PivotUtil;

/**
 * PackageManager encapsulates the knowledge about known packages and their nsURIs.
 */
public class PackageManager implements PackageServerParent
{
	private static final Logger logger = Logger.getLogger(PackageManager.class);

	/**
	 * The MetaModelManager for which this PackageManager manages the packages.
	 */
	protected final @NonNull MetaModelManager metaModelManager;

	/**
	 * Map of (nested) package-name to package server.
	 */
	private final @NonNull Map<String, RootPackageServer> packageServers = new HashMap<String, RootPackageServer>();

	private final @NonNull Set<RootTracker> rootTrackers = new HashSet<RootTracker>();

	/**
	 * Map from package URI to primary package. 
	 */
	private final @NonNull Map<String, PackageServer> uri2package = new HashMap<String, PackageServer>();
	
	/**
	 * Map of synonym URI to shared URI.
	 */
	private final @NonNull Map<String, String> synonymURI2sharedURI = new HashMap<String, String>();
	
	/**
	 * Map of shared URIs to synonyms
	 */
	private final @NonNull Map<String, Set<String>> sharedURI2synonymURIs = new HashMap<String, Set<String>>();

	/**
	 * Map from each merged package to the PackageTracker that supervises its merge. PackageTrackers are only
	 * created for merged packages, so a missing entry just denotes an unmerged package. 
	 */
	private final @NonNull Map<DomainPackage, PackageTracker> package2tracker = new HashMap<DomainPackage, PackageTracker>();

	/**
	 * Map from each merged type to the TypeTracker that supervises its merge. TypeTrackers are only
	 * created for merged types, so a missing entry just denotes an unmerged type. 
	 */
	private final @NonNull Map<DomainType, TypeTracker> type2tracker = new WeakHashMap<DomainType, TypeTracker>();

	/**
	 * Map from each primitive type name to the TypeServer that supervises its merge. 
	 */
	private final @NonNull Map<String, PrimitiveTypeServer> primitiveType2server = new HashMap<String, PrimitiveTypeServer>();
	
	/**
	 * Lazily computed, eagerly invalidated analysis of final classes and operations.
	 */
	private @Nullable FinalAnalysis finalAnalysis = null;
	
	protected PackageManager(@NonNull MetaModelManager metaModelManager) {
		this.metaModelManager = metaModelManager;
	}

	void addPackage(@NonNull PackageServerParent parentPackageServer, @NonNull DomainPackage pivotPackage) {
		PackageServer packageServer = null;
		String name = pivotPackage.getName();
		String nsURI = pivotPackage.getNsURI();
		if (nsURI != null) {										// Explicit nsURI for explicit package (merge)
			packageServer = uri2package.get(nsURI);
		}
		else if (name != null) {										// Null nsURI can merge into same named package
			packageServer = getMemberPackage(name);
		}
		if (packageServer == null) {
			packageServer = parentPackageServer.getMemberPackageServer(pivotPackage);
			packageServer.assertSamePackage(pivotPackage);
		}
		packageServer.addTrackedPackage(pivotPackage);
		for (DomainPackage nestedPackage : pivotPackage.getNestedPackage()) {
			if (nestedPackage != null) {
				addPackage(packageServer, nestedPackage);
			}
		}
	}

	/**
	 * The OCL Standard Library is normally registered under it's own nsURI and the OCL Pivot MetaModel is changed to share
	 * the same URI. This routine allows the original OCL Pivot MetaModel nsURI to reference the merged packes too.
	 */

	public void addPackageNsURISynonym(@NonNull String newURI, @NonNull String oldURI) {
		String sharedURI = synonymURI2sharedURI.get(newURI);
		if (oldURI.equals(sharedURI)) {
			return;
		}
		if (sharedURI != null) {
			throw new IllegalMetamodelException(oldURI, sharedURI);	// FIXME Better name
		}
		if (sharedURI2synonymURIs.containsKey(newURI)) {
			throw new IllegalMetamodelException(newURI, sharedURI);	// FIXME Better name
		}
		synonymURI2sharedURI.put(newURI, oldURI);
		Set<String> synonymURIs = sharedURI2synonymURIs.get(oldURI);
		if (synonymURIs == null) {
			synonymURIs = new HashSet<String>();
			sharedURI2synonymURIs.put(oldURI, synonymURIs);
		}
		synonymURIs.add(newURI);
	}

	void addPackageServer(@NonNull PackageServer packageServer) {
		String nsURI = packageServer.getNsURI();
		PackageServer oldPackageServer = uri2package.put(nsURI, packageServer);
		if (packageServer instanceof RootPackageServer) {
			String sharedNsURI = getSharedURI(nsURI);
			if ((sharedNsURI != null) && (sharedNsURI == nsURI)) {
				packageServers.put(nsURI, (RootPackageServer) packageServer);
			}
		}
		assert oldPackageServer == null;
	}

	void addPackageTracker(@NonNull DomainPackage pivotPackage, @NonNull PackageTracker packageTracker) {
		packageTracker.getPackageServer().assertSamePackage(pivotPackage);
		PackageTracker oldTracker = package2tracker.put(pivotPackage, packageTracker);
		assert oldTracker == null;
	}
	
	public synchronized void addRoot(@NonNull Root pivotRoot) {
		for (org.eclipse.ocl.examples.pivot.Package asPackage : pivotRoot.getNestedPackage()) {
			String nsURI = asPackage.getNsURI();
			String sharedURI = getSharedURI(nsURI);
			if (sharedURI == nsURI) {
				PackageId packageId = asPackage.getPackageId();
				if (packageId == IdManager.METAMODEL) {
					if (nsURI != null) {
						addPackageNsURISynonym(nsURI, DomainConstants.METAMODEL_NAME);
					}
				}
			}
		}
		rootTrackers.add(new RootTracker(this, pivotRoot));
		for (DomainPackage pivotPackage : pivotRoot.getNestedPackage()) {
			if (pivotPackage != null) {
				addPackage(this, pivotPackage);
			}
		}
	}

	void addTypeTracker(@NonNull DomainType pivotType, @NonNull TypeTracker typeTracker) {
		TypeTracker oldTracker = type2tracker.put(pivotType, typeTracker);
		assert oldTracker == null;
	}

	public void addedMemberPackage(@NonNull DomainPackage pivotPackage) {
		PackageServer packageServer = getMemberPackageServer(pivotPackage);
		packageServer.addTrackedPackage(pivotPackage);
	}

	void addedNestedPrimaryPackage(@NonNull DomainPackage pivotPackage) {
		String nsURI = PivotUtil.getNsURI(pivotPackage);
		DomainPackage primaryPackage = null;
		if (nsURI != null) {
			primaryPackage = getPackageByURI(nsURI);
		}
		if (primaryPackage == pivotPackage) {
			// Recursive call
		}
		else if (primaryPackage != null) {
			throw new IllegalArgumentException("Duplicate nsURI '" + nsURI + "'");
		}
		else {
			getPackageTracker(pivotPackage);
		}
	}

	protected @NonNull RootPackageServer createRootPackageServer(@NonNull DomainPackage pivotPackage) {
		String name = pivotPackage.getName();
//		if (name == null) {
//			throw new IllegalStateException("Unnamed package");
//		}
		String nonNullName = name;
		if (nonNullName == null) {
			nonNullName = "$anon_" + Integer.toHexString(System.identityHashCode(pivotPackage));
		}
		String nsPrefix = pivotPackage.getNsPrefix();
		String nsURI = getSharedURI(pivotPackage.getNsURI());
		PackageId packageId = pivotPackage.getPackageId();
		RootPackageServer rootPackageServer;
		if (Orphanage.isTypeOrphanage(pivotPackage)) {
			rootPackageServer = new OrphanPackageServer(this, nonNullName, nsPrefix, nsURI, packageId);
		}
		else {
			PackageId metapackageId = metaModelManager.getMetapackageId(pivotPackage);
			rootPackageServer = new RootPackageServer(this, nonNullName, nsPrefix, nsURI, packageId, metapackageId);
		}
		if (name != null) {
			if (!packageServers.containsKey(name)) {
				PackageServer oldPackageServer = packageServers.put(name, rootPackageServer);		// New name
				assert oldPackageServer == null;
			}
			else {
				packageServers.put(name, null);														// Ambiguous name
			}
		}
		if (nsURI != null) {
			addPackageServer(rootPackageServer);
		}
		return rootPackageServer;
	}

	public synchronized void dispose() {
		if (!rootTrackers.isEmpty()) {
			Collection<RootTracker> savedRootTrackers = new ArrayList<RootTracker>(rootTrackers);
			rootTrackers.clear();
			for (RootTracker rootTracker : savedRootTrackers) {
				rootTracker.dispose();
			}
		}
		if (!package2tracker.isEmpty()) {
			Collection<PackageTracker> savedPackageTrackers = new ArrayList<PackageTracker>(package2tracker.values());
			package2tracker.clear();
			for (PackageTracker packageTracker : savedPackageTrackers) {
				packageTracker.dispose();
			}
		}
		if (!type2tracker.isEmpty()) {
			Collection<TypeTracker> savedTypeTrackers = new ArrayList<TypeTracker>(type2tracker.values());
			type2tracker.clear();
			for (TypeTracker typeTracker : savedTypeTrackers) {
				typeTracker.dispose();
			}
		}
		uri2package.clear();
		Collection<RootPackageServer> savedPackageServers = new ArrayList<RootPackageServer>(packageServers.values());
		packageServers.clear();
		for (RootPackageServer packageServer : savedPackageServers) {
			packageServer.dispose();
		}
	}

	public void disposedRootPackageServer(@NonNull RootPackageServer packageServer) {
		packageServers.remove(packageServer.getName());
		disposedPackageServer(packageServer.getNsURI());
	}

	void disposedPackageServer(@Nullable String nsURI) {
		if (nsURI != null) {
			uri2package.remove(nsURI);
			Set<String> synonymURIs = sharedURI2synonymURIs.remove(nsURI);
			if (synonymURIs != null) {
				for (String synonymURI : synonymURIs) {
					synonymURI2sharedURI.remove(synonymURI);
				}
			}
		}
	}

	void disposedPackageTracker(@NonNull PackageTracker packageTracker) {
		if (!package2tracker.isEmpty()) {						// Empty if disposing
			package2tracker.remove(packageTracker.getPackage());
		}
	}

	void disposedRootTracker(@NonNull RootTracker rootTracker) {
		rootTrackers.remove(rootTracker);
	}

	void disposedTypeTracker(@NonNull TypeTracker typeTracker) {
		type2tracker.remove(typeTracker.getTarget());
	}

	@Nullable PackageTracker findPackageTracker(@NonNull DomainPackage pivotPackage) {
		return package2tracker.get(pivotPackage);
	}
	
	public @Nullable ExtensibleTypeServer findTypeServer(@NonNull DomainType pivotType) {
		TypeTracker typeTracker = type2tracker.get(pivotType);
		return typeTracker != null ? typeTracker.getTypeServer() : null;
	}
	
	@SuppressWarnings("unused")
	private final @Nullable TypeTracker findTypeTracker(@NonNull DomainType pivotType) {		
		throw new UnsupportedOperationException("Not implemented since specializations have a TypeServer but no TypeTracker");
		//return type2tracker.get(pivotType);
	}

	@SuppressWarnings("null")
	public @NonNull Iterable<PackageServer> getAllPackages() {
		return uri2package.values();
	}

	@SuppressWarnings("null")
	public @NonNull Iterable<PackageServer> getAllPackagesWithUris() {
		return uri2package.values();
	}
	
	public @NonNull FinalAnalysis getFinalAnalysis() {
		FinalAnalysis finalAnalysis2 = finalAnalysis;
		if (finalAnalysis2 == null) {
			finalAnalysis = finalAnalysis2 = new FinalAnalysis(this);
		}
		return finalAnalysis2;
	}

	public @Nullable RootPackageServer getMemberPackage(@NonNull String memberPackageName) {
		return packageServers.get(memberPackageName);
	}
	public @NonNull RootPackageServer getMemberPackageServer(@NonNull DomainPackage pivotPackage) {
		//
		//	Try to find package by nsURI
		//
		String nsURI = pivotPackage.getNsURI();
		if (nsURI != null) {
			String sharedURI = getSharedURI(nsURI);
			PackageServer packageServer = uri2package.get(sharedURI);
			if (packageServer != null) {
				return (RootPackageServer) packageServer;
			}
		}
		//
		//	Else generate an error for a name-less Package, fatally if also nsURI-less.
		//
		String name = pivotPackage.getName();
		if (name == null) {
			String message = null;
			if (pivotPackage instanceof EObject) {
				for (EObject eObject = (EObject) pivotPackage; eObject != null; eObject = eObject.eContainer()) {
					if (eObject instanceof Root) {
						message = "Unnamed package for '" + nsURI + "' in '" + ((Root)eObject).getExternalURI() + "'";
						break;
					}
				}
			}
			if (message == null) {
				message = "Unnamed package for '" + nsURI + "'";
			}
			logger.error(message);
			name = nsURI;
			if (name == null) {
				throw new IllegalStateException(message);
			}
		}
		//
		//	Try to find package by name, provided there is no nsURI conflict
		//
		RootPackageServer rootPackageServer = packageServers.get(name);
		if (rootPackageServer != null) {
			String nsURI2 = rootPackageServer.getNsURI();
			if ((nsURI == null) || (nsURI2 == null) || nsURI.equals(nsURI2)) {
				return rootPackageServer;
			}
		}
		rootPackageServer = createRootPackageServer(pivotPackage);
		return rootPackageServer;
	}

	public @NonNull Iterable<RootPackageServer> getMemberPackages() {
		@SuppressWarnings("null")
		@NonNull Collection<RootPackageServer> values = packageServers.values();
		return values;
	}

	public @NonNull MetaModelManager getMetaModelManager() {
		return metaModelManager;
	}

	public @Nullable PackageServer getPackageByURI(@NonNull String nsURI) {
		int lastIndex = nsURI.lastIndexOf("#/");
		if (lastIndex > 0) {
			@SuppressWarnings("null") @NonNull String substring = nsURI.substring(0, lastIndex);
			nsURI = substring;
		}
		String sharedURI = getSharedURI(nsURI);
		return uri2package.get(sharedURI);
	}

	public @NonNull PackageServer getPackageServer(@NonNull DomainPackage pivotPackage) {
		PackageServer packageServer = null;
		if (pivotPackage instanceof PackageServer) {
			((PackageServer)pivotPackage).assertSamePackage(pivotPackage);
			packageServer = (PackageServer)pivotPackage;
		}
		else {
			String nsURI = pivotPackage.getNsURI();
			if (nsURI != null) {
				String sharedURI = getSharedURI(nsURI);
				packageServer = uri2package.get(sharedURI);
			}
			if (packageServer == null) {
				PackageServerParent packageServerParent;
				DomainPackage pivotPackageParent = pivotPackage.getNestingPackage();
				if (pivotPackageParent == null) {
					packageServerParent = this;
				}
				else {
					PackageTracker parentTracker = getPackageTracker(pivotPackageParent);
					packageServerParent = parentTracker.getPackageServer();
					((PackageServer)packageServerParent).assertSamePackage(pivotPackageParent);
				}
				packageServer = packageServerParent.getMemberPackageServer(pivotPackage);
				packageServer.addTrackedPackage(pivotPackage);
				packageServer.assertSamePackage(pivotPackage);
			}
		}
		packageServer.assertSamePackage(pivotPackage);
		return packageServer;
	}

	public @NonNull PackageTracker getPackageTracker(@NonNull DomainPackage pivotPackage) {	// FIXME Review wrt getMemberPackageServer()
		PackageTracker packageTracker = package2tracker.get(pivotPackage);
		if (packageTracker == null) {
			DomainPackage nestingPackage = pivotPackage.getNestingPackage();
			PackageServer packageServer;
			if (nestingPackage != null) {
				PackageServer nestingPackageServer = getPackageServer(nestingPackage);
				packageServer = nestingPackageServer.getMemberPackageServer(pivotPackage);
			}
			else {
				String sharedURI = getSharedURI(pivotPackage.getNsURI());
				packageServer = uri2package.get(sharedURI);
				if (packageServer == null) {
					packageServer = createRootPackageServer(pivotPackage);
				}
			}
			packageServer.assertSamePackage(pivotPackage);
			packageTracker = packageServer.getPackageTracker(pivotPackage);
		}
		else {
			packageTracker.getPackageServer().assertSamePackage(pivotPackage);
		}
		return packageTracker;
	}

/*	public synchronized Iterable<DomainPackage> getPartialPackages(DomainPackage pkg) {
		PackageTracker packageTracker = findPackageTracker(pkg);
		Set<DomainPackage> allPackages = new HashSet<DomainPackage>();
		if (packageTracker != null) {
			for (DomainPackage aPackage : packageTracker.getPackageServer().getTrackedPackages()) {
				allPackages.add(aPackage);
			}
		}
		else {
			allPackages.add(pkg);
		}
		getAllPartialPackages(allPackages, allPackages);		// FIXME Inconsistent name/functionality
		return allPackages;
	} */

/*	private void getAllPartialPackages(Set<DomainPackage> knownPackages, Set<DomainPackage> newPackages) {
		Set<DomainPackage> morePackages = null;
		for (DomainPackage newPackage : newPackages) {
			for (DomainPackage importedPackage : newPackage.getImportedPackage()) {
				if (morePackages == null) {
					morePackages = new HashSet<DomainPackage>();
				}
				PackageTracker packageTracker = findPackageTracker(importedPackage);
				if (packageTracker != null) {
					for (DomainPackage aPackage : packageTracker.getPackageServer().getTrackedPackages()) {
						morePackages.add(aPackage);
					}
				}
				else {
					morePackages.add(importedPackage);
				}
			}
		}
		if (morePackages != null) {
			morePackages.removeAll(knownPackages);
			if (morePackages.size() > 0) {
				knownPackages.addAll(morePackages);
				getAllPartialPackages(knownPackages, morePackages);
			}
		}
	} */

	public @NonNull PrimitiveTypeServer getPrimitiveTypeServer(@NonNull PrimitiveType primitiveType) {
		String name = primitiveType.getName();
		PrimitiveTypeServer primitiveTypeServer = primitiveType2server.get(name);
		if (primitiveTypeServer == null) {
			org.eclipse.ocl.examples.pivot.Package primitivePackage = primitiveType.getPackage();
			if (!(primitivePackage instanceof Library)) {
				AnyType oclAnyType = metaModelManager.getOclAnyType();
				primitivePackage = DomainUtil.nonNullState(oclAnyType.getPackage());
			}
			PackageServer packageServer = getPackageServer(primitivePackage);
			primitiveTypeServer = new PrimitiveTypeServer(packageServer, primitiveType);
			primitiveType2server.put(name, primitiveTypeServer);
		}
		return primitiveTypeServer;
	}

//	@SuppressWarnings("null")
//	public @NonNull Iterable<Root> getRoots() {
//		return Iterables.transform(rootTrackers, RootTracker.tracker2root);
//	}

	public @Nullable org.eclipse.ocl.examples.pivot.Package getRootPackage(@NonNull String name) {
		PackageServer packageServer = packageServers.get(name);
//		if (packageServer == null) {
//			packageServer = uri2package.get(name);		// FIXME avoid double lookup
//		}
		return packageServer != null ? packageServer.getPivotPackage() : null;
	}

	/**
	 * @since 3.5
	 */
	public @Nullable String getSharedURI(@Nullable String nsURI) {
		String sharedURI = synonymURI2sharedURI.get(nsURI);
		if (sharedURI != null) {
			return sharedURI;
		}
		else {
			return nsURI;
		}
	}
	
	public @NonNull TypeServer getTypeServer(@NonNull DomainType pivotType) {
		if (pivotType instanceof ElementExtension) {
			Stereotype stereotype = ((ElementExtension)pivotType).getStereotype();
			if (stereotype != null) {
				pivotType = stereotype;
			}
		}
		if (pivotType instanceof TypeServer) {
			return (TypeServer)pivotType;
		}
		assert metaModelManager.isTypeServeable(pivotType);
		TypeTracker typeTracker = type2tracker.get(pivotType);
		if (typeTracker != null) {
			return typeTracker.getTypeServer();
		}
		else if (pivotType instanceof PrimitiveType) {
			PrimitiveTypeServer primitiveTypeServer = getPrimitiveTypeServer((PrimitiveType) pivotType);
			primitiveTypeServer.getTypeTracker(pivotType);
			return primitiveTypeServer;
		}
		else {
			DomainPackage pivotPackage = pivotType.getPackage();
			if (pivotPackage == null) {
				throw new IllegalStateException("type has no package");
			}
			PackageServer packageServer = getPackageServer(pivotPackage);
			return packageServer.getTypeServer(pivotType);
		}
	}

//	public void installAs(@NonNull String nsURI, @NonNull EcoreExecutorPackage tablesPackage) {
//		PackageServer packageServer = uri2package.get(nsURI);
//		if (packageServer != null) {
//			packageServer.addTrackedPackage(tablesPackage);
//			for (DomainPackage nestedPackage : tablesPackage.getNestedPackage()) {
//				if (nestedPackage != null) {
//					addPackage(packageServer, nestedPackage);
//				}
//			}
//		}
//	}
	
	public synchronized void removeRoot(@NonNull Root pivotRoot) {
		for (RootTracker rootTracker : rootTrackers) {
			if (rootTracker.getTarget() == pivotRoot) {
				pivotRoot.getNestedPackage().clear();
				rootTracker.dispose();
				break;
			}
		}
	}

	void removedPackage(@NonNull DomainPackage pivotPackage) {
		PackageTracker packageTracker = package2tracker.get(pivotPackage);
		if (packageTracker != null) {
			packageTracker.dispose();
		}
	}

	void removedType(@NonNull DomainType pivotType) {
		TypeTracker typeTracker = type2tracker.get(pivotType);
		if (typeTracker != null) {
			typeTracker.dispose();
		}
	}

	void resolveSuperClasses(@NonNull Type specializedClass, @NonNull Type unspecializedClass, Map<TemplateParameter, ParameterableElement> allBindings) {
		for (Type superType : unspecializedClass.getSuperClass()) {
			List<TemplateBinding> superTemplateBindings = superType.getTemplateBinding();
			if (superTemplateBindings.size() > 0) {
				List<ParameterableElement> superTemplateArgumentList = new ArrayList<ParameterableElement>();
				for (TemplateBinding superTemplateBinding : superTemplateBindings) {
					for (TemplateParameterSubstitution superParameterSubstitution : superTemplateBinding.getParameterSubstitution()) {
						ParameterableElement superActual = superParameterSubstitution.getActual();
						TemplateParameter superTemplateParameter = superActual.getTemplateParameter();
						ParameterableElement actualActual = allBindings.get(superTemplateParameter);
						superTemplateArgumentList.add(actualActual);
					}
				}
				@NonNull Type unspecializedSuperType = PivotUtil.getUnspecializedTemplateableElement(superType);
				TypeServer superTypeServer = metaModelManager.getTypeServer(unspecializedSuperType);
				if ((superTypeServer instanceof CollectionTypeServer) && (superTemplateArgumentList.size() == 1)) {
					ParameterableElement templateArgument = superTemplateArgumentList.get(0);
					if (templateArgument instanceof Type) {
						Type specializedSuperType = ((CollectionTypeServer)superTypeServer).getSpecializedType((Type)templateArgument, null, null);
						specializedClass.getSuperClass().add(specializedSuperType);
					}
				}
				else if ((superTypeServer instanceof MetaclassServer) && (superTemplateArgumentList.size() == 1)) {
					ParameterableElement templateArgument = superTemplateArgumentList.get(0);
					if (templateArgument instanceof Type) {
						Type superMetaclass = ((MetaclassServer)superTypeServer).getMetaclass((Type)templateArgument);
						specializedClass.getSuperClass().add(superMetaclass);
					}
				}
				else if (superTypeServer instanceof TemplateableTypeServer) {
					Type specializedSuperType = ((TemplateableTypeServer)superTypeServer).getSpecializedType(superTemplateArgumentList);
					specializedClass.getSuperClass().add(specializedSuperType);
				}
			}
			else {
				specializedClass.getSuperClass().add(superType);
			}
		}
	}
}