package org.andromda.core.engine;

import java.text.Collator;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import org.andromda.core.ModelValidationException;
import org.andromda.core.cartridge.Cartridge;
import org.andromda.core.common.AndroMDALogger;
import org.andromda.core.common.BuildInformation;
import org.andromda.core.common.ComponentContainer;
import org.andromda.core.common.ExceptionRecorder;
import org.andromda.core.common.Introspector;
import org.andromda.core.common.ResourceWriter;
import org.andromda.core.common.XmlObjectFactory;
import org.andromda.core.configuration.Configuration;
import org.andromda.core.configuration.Filters;
import org.andromda.core.configuration.Model;
import org.andromda.core.configuration.Namespace;
import org.andromda.core.configuration.Namespaces;
import org.andromda.core.configuration.Property;
import org.andromda.core.configuration.Repository;
import org.andromda.core.metafacade.MetafacadeFactory;
import org.andromda.core.metafacade.ModelAccessFacade;
import org.andromda.core.metafacade.ModelValidationMessage;
import org.andromda.core.namespace.NamespaceComponents;
import org.andromda.core.repository.Repositories;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.collections.Predicate;
import org.apache.commons.collections.comparators.ComparatorChain;
import org.apache.commons.lang.StringUtils;
import org.apache.log4j.Logger;

/**
 * <p>
 * Handles the processing of models. Facilitates Model Driven
 * Architecture by enabling the generation of source code, configuration files, and other such artifacts from a single
 * or multiple models. </p>
 *
 * @author Chad Brandon
 * @author Bob Fields
 * @author Michail Plushnikov
 */
public class ModelProcessor
{
    /**
     * The logger instance.
     */
    private static final Logger logger = Logger.getLogger(ModelProcessor.class);

    /**
     * Creates a new instance the ModelProcessor.
     *
     * @return the shared ModelProcessor instance.
     */
    public static ModelProcessor newInstance()
    {
        return new ModelProcessor();
    }

    private ModelProcessor()
    {
        // - do not allow instantiation
    }

    /**
     * Re-configures this model processor from the given <code>configuration</code>
     * instance (if different from that of the one passed in during the call to
     * {@link #initialize(Configuration)}), and runs the model processor.
     *
     * @param configuration the configuration from which to configure this model
     *        processor instance.
     * @return any model validation messages collected during model processing (if
     *         model validation is enabled).
     */
    public ModelValidationMessage[] process(final Configuration configuration)
    {
        this.configure(configuration);
        final List<ModelValidationMessage> messages = this.process(configuration.getRepositories());
        return messages != null ? messages.toArray(new ModelValidationMessage[messages.size()])
                                : new ModelValidationMessage[0];
    }

    /**
     * Configures (or re-configures) the model processor if configuration
     * is required (the configuration has changed since the previous, or has
     * yet to be used).
     *
     * @param configuration the AndroMDA configuration instance.
     */
    private void configure(final Configuration configuration)
    {
        if (this.requiresConfiguration(configuration))
        {
            configuration.initialize();
            this.reset();
            final Property[] properties = configuration.getProperties();
            final Introspector introspector = Introspector.instance();
            for (Property property : properties)
            {
                try
                {
                    introspector.setProperty(
                        this,
                        property.getName(),
                        property.getValue());
                }
                catch (final Throwable throwable)
                {
                    AndroMDALogger.warn(
                        "Could not set model processor property '" + property.getName() + "' with a value of '" +
                        property.getValue() + '\'');
                }
            }
            this.currentConfiguration = configuration;
        }
    }

    /**
     * Processes all models contained within the <code>repositories</code>
     * with the discovered cartridges.
     *
     * @return any model validation messages that may have been collected during model loading/validation.
     */
    private List<ModelValidationMessage> process(final Repository[] repositories)
    {
        List<ModelValidationMessage> messages = null;
        final long startTime = System.currentTimeMillis();
        for (Repository repository : repositories)
        {
            if (repository != null)
            {
                final String repositoryName = repository.getName();

                // - filter out any invalid models (ones that don't have any uris defined)
                final Model[] models = this.filterInvalidModels(repository.getModels());
                if (models.length > 0)
                {
                    messages = this.processModels(
                            repositoryName,
                            models);
                    AndroMDALogger.info(
                        "completed model processing --> TIME: " + this.getDurationInSeconds(startTime) +
                        "[s], RESOURCES WRITTEN: " + ResourceWriter.instance().getWrittenCount());
                }
                else
                {
                    AndroMDALogger.warn("No model(s) found to process for repository '" + repositoryName + '\'');
                }
            }
        }
        if(messages == null)
        {
            messages = Collections.emptyList();
        }
        return messages;
    }

    /**
     * The shared metafacade factory instance.
     */
    private final MetafacadeFactory factory = MetafacadeFactory.getInstance();

    /**
     * The shared namespaces instance.
     */
    private final Namespaces namespaces = Namespaces.instance();

    /**
     * The shared repositories instance.
     */
    private final Repositories repositories = Repositories.instance();

    /**
     * Check if files have not been modified since last model modification date.
     * Do not generate from model if no modifications made.
     */
    private boolean lastModifiedCheck = true;

    /**
     * Location where model generation file list is written, normally /target.
     */
    private String historyDir = null;

    /**
     * @param lastModifiedCheck the lastModifiedCheck to set
     */
    public void setLastModifiedCheck(boolean lastModifiedCheck)
    {
        this.lastModifiedCheck = lastModifiedCheck;
    }

    /**
     * @param historyDir the historyDir to set
     */
    public void setHistoryDir(String historyDir)
    {
        this.historyDir = historyDir;
    }

    /**
     * Processes multiple <code>models</code>.
     *
     * @param repositoryName the name of the repository that loads/reads the model.
     * @param models the Model(s) to process.
     * @return any model validation messages that may have been collected during validation/loading of
     *         the <code>models</code>.
     */
    private List<ModelValidationMessage> processModels(
        final String repositoryName,
        final Model[] models)
    {
        List<ModelValidationMessage> messages = null;
        String cartridgeName = null;
        try
        {
            // If lastModifiedCheck = true, always check for modification times
            long lastModified = 0;
            final ResourceWriter writer = ResourceWriter.instance();
            writer.setHistoryStorage(historyDir);

            // - get the time from the model that has the latest modified time
            for (Model model : models)
            {
                writer.resetHistory(model.getUris()[0]);
                // lastModifiedCheck from andromda.xml can override the global lastModifiedCheck from maven if true
                this.lastModifiedCheck = model.isLastModifiedCheck() || this.lastModifiedCheck;

                // - we go off the model that was most recently modified.
                if (model.getLastModified() > lastModified)
                {
                    lastModified = model.getLastModified();
                }
            }

            if (!this.lastModifiedCheck || writer.isHistoryBefore(lastModified))
            {
                final Collection<Cartridge> cartridges = ComponentContainer.instance().findComponentsOfType(Cartridge.class);
                if (cartridges.isEmpty())
                {
                    AndroMDALogger.warn("WARNING! No cartridges found, check your classpath!");
                }

                final Map<String, Cartridge> cartridgesByNamespace = this.loadCartridgesByNamespace(cartridges);

                // - we want to process by namespace so that the order within the configuration is kept
                final Collection<Namespace> namespaces = this.namespaces.getNamespaces();

                // - pre-load the models
                messages = this.loadIfNecessary(models);
                for (Namespace namespace : namespaces)
                {
                    final Cartridge cartridge = cartridgesByNamespace.get(namespace.getName());
                    if (cartridge != null)
                    {
                        cartridgeName = cartridge.getNamespace();
                        if (this.shouldProcess(cartridgeName))
                        {
                             // - set the active namespace on the shared factory and profile instances
                            this.factory.setNamespace(cartridgeName);
                            cartridge.initialize();

                            // - process each model with the cartridge
                            for (Model model : models)
                            {
                                AndroMDALogger.info("Processing cartridge " + cartridge.getNamespace() + " on model " + model);

                                // - set the namespace on the metafacades instance so we know the
                                //   correct facades to use
                                this.factory.setModel(
                                    this.repositories.getImplementation(repositoryName).getModel(),
                                    model.getType());
                                cartridge.processModelElements(this.factory);
                                writer.writeHistory();
                            }
                            cartridge.shutdown();
                        }
                    }
                }
            }
            else
            {
                AndroMDALogger.info("Files are up-to-date, skipping AndroMDA execution");
            }
        }
        catch (final ModelValidationException exception)
        {
            // - we don't want to record model validation exceptions
            throw exception;
        }
        catch (final Throwable throwable)
        {
            final String messsage =
                "Error performing ModelProcessor.process with model(s) --> '" + StringUtils.join(
                    models,
                    ",") + '\'';
            logger.error(messsage);
            ExceptionRecorder.instance().record(
                messsage,
                throwable,
                cartridgeName);
            throw new ModelProcessorException(messsage, throwable);
        }
        if(messages == null)
        {
            messages = Collections.emptyList();
        }
        return messages;
    }

    /**
     * Loads the given list of <code>cartridges</code> into a map keyed by namespace.
     *
     * @param cartridges the cartridges loaded.
     * @return the loaded cartridge map.
     */
    private Map<String, Cartridge> loadCartridgesByNamespace(final Collection<Cartridge> cartridges)
    {
        final Map<String, Cartridge> cartridgesByNamespace = new LinkedHashMap<String, Cartridge>();
        for (Cartridge cartridge : cartridges)
        {
            cartridgesByNamespace.put(cartridge.getNamespace(), cartridge);
        }
        return cartridgesByNamespace;
    }

    /**
     * Initializes this model processor instance with the given
     * configuration.  This configuration information is overridden (if changed)
     * when calling {@link #process(Configuration)}
     *
     * @param configuration the configuration instance by which to initialize this
     *        model processor instance.
     */
    public void initialize(final Configuration configuration)
    {
        final long startTime = System.currentTimeMillis();

        // - first, print the AndroMDA header
        this.printConsoleHeader();

        // - second, configure this model processor
        // - the ordering of this step is important: it needs to occur
        //   before everything else in the framework is initialized so that
        //   we have all configuration information available (such as the
        //   namespace properties)
        this.configure(configuration);

        // - the logger configuration may have changed - re-init the logger.
        AndroMDALogger.initialize();

        // - discover all namespace components
        NamespaceComponents.instance().discover();

        // - find and initialize any repositories
        repositories.initialize();

        // - finally initialize the metafacade factory
        this.factory.initialize();
        this.printWorkCompleteMessage(
            "core initialization",
            startTime);
    }

    /**
     * Loads the model into the repository only when necessary (the model has a timestamp
     * later than the last timestamp of the loaded model).
     *
     * @param model the model to be loaded.
     * @return List validation messages
     */
    protected final List<ModelValidationMessage> loadModelIfNecessary(final Model model)
    {
        final List<ModelValidationMessage> validationMessages = new ArrayList<ModelValidationMessage>();
        final long startTime = System.currentTimeMillis();
        if (this.repositories.loadModel(model))
        {
            this.printWorkCompleteMessage(
                "loading",
                startTime);

            // - validate the model since loading has successfully occurred
            final Repository repository = model.getRepository();
            final String repositoryName = repository != null ? repository.getName() : null;
            validationMessages.addAll(this.validateModel(
                    repositoryName,
                    model));
        }
        return validationMessages;
    }

    /**
     * Validates the entire model with each cartridge namespace,
     * and returns any validation messages that occurred during validation
     * (also logs any validation failures).
     *
     * @param repositoryName the name of the repository storing the model to validate.
     * @param model the model to validate
     * @return any {@link ModelValidationMessage} instances that may have been collected
     *         during validation.
     */
    private List<ModelValidationMessage> validateModel(
        final String repositoryName,
        final Model model)
    {
        final Filters constraints = model != null ? model.getConstraints() : null;
        final List<ModelValidationMessage> validationMessages = new ArrayList<ModelValidationMessage>();
        if (ModelProcessor.modelValidation && model != null)
        {
            final long startTime = System.currentTimeMillis();
            AndroMDALogger.info("- validating model -");
            final Collection<Cartridge> cartridges = ComponentContainer.instance().findComponentsOfType(Cartridge.class);
            final ModelAccessFacade modelAccessFacade =
                this.repositories.getImplementation(repositoryName).getModel();

            // - clear out the factory's caches (such as any previous validation messages, etc.)
            this.factory.clearCaches();
            this.factory.setModel(
                modelAccessFacade,
                model.getType());
            for (Cartridge cartridge : cartridges)
            {
                final String cartridgeName = cartridge.getNamespace();
                if (this.shouldProcess(cartridgeName))
                {
                    // - set the active namespace on the shared factory and profile instances
                    this.factory.setNamespace(cartridgeName);
                    this.factory.validateAllMetafacades();
                }
            }
            final List<ModelValidationMessage> messages = this.factory.getValidationMessages();
            this.filterAndSortValidationMessages(
                messages,
                constraints);
            this.printValidationMessages(messages);
            this.printWorkCompleteMessage(
                "validation",
                startTime);
            if (messages != null && !messages.isEmpty())
            {
                validationMessages.addAll(messages);
            }
        }
        return validationMessages;
    }

    /**
     * Prints a work complete message using the type of <code>unitOfWork</code> and
     * <code>startTime</code> as input.
     * @param unitOfWork the type of unit of work that was completed
     * @param startTime the time the unit of work was started.
     */
    private void printWorkCompleteMessage(
        final String unitOfWork,
        final long startTime)
    {
        AndroMDALogger.info("- " + unitOfWork + " complete: " + this.getDurationInSeconds(startTime) + "[s] -");
    }

    /**
     * Calculates the duration in seconds between the
     * given <code>startTime</code> and the current time.
     * @param startTime the time to compare against.
     * @return the duration of time in seconds.
     */
    private double getDurationInSeconds(final long startTime)
    {
        return ((System.currentTimeMillis() - startTime) / 1000.0);
    }

    /**
     * Prints any model validation errors stored within the <code>factory</code>.
     */
    private void printValidationMessages(final List<ModelValidationMessage> messages)
    {
        // - log all error messages
        if (messages != null && !messages.isEmpty())
        {
            final StringBuilder header =
                new StringBuilder("Model Validation Failed - " + messages.size() + " VALIDATION ERROR");
            if (messages.size() > 1)
            {
                header.append('S');
            }
            AndroMDALogger.error(header);
            int ctr = 1;
            for (ModelValidationMessage message : messages)
            {
                AndroMDALogger.error(ctr + ") " + message);
                ctr++;
            }
            AndroMDALogger.reset();
            if (this.failOnValidationErrors)
            {
                throw new ModelValidationException("Model validation failed!");
            }
        }
    }

    /**
     * The current configuration of this model processor.
     */
    private Configuration currentConfiguration = null;

    /**
     * Determines whether or not this model processor needs to be reconfigured.
     * This is based on whether or not the new configuration is different
     * than the <code>currentConfiguration</code>.  We determine this checking
     * if their contents are equal or not, if not equal this method will
     * return true, otherwise false.
     *
     * @param configuration the configuration to compare to the lastConfiguration.
     * @return true/false
     */
    private boolean requiresConfiguration(final Configuration configuration)
    {
        boolean requiresConfiguration =
            this.currentConfiguration == null || this.currentConfiguration.getContents() == null ||
            configuration.getContents() == null;
        if (!requiresConfiguration)
        {
            requiresConfiguration = !this.currentConfiguration.getContents().equals(configuration.getContents());
        }
        return requiresConfiguration;
    }

    /**
     * Checks to see if <em>any</em> of the repositories contain models
     * that need to be reloaded, and if so, re-loads them.
     *
     * @param repositories the repositories from which to load the model(s).
     * @return messages
     */
    final List<ModelValidationMessage> loadIfNecessary(final org.andromda.core.configuration.Repository[] repositories)
    {
        final List<ModelValidationMessage> messages = new ArrayList<ModelValidationMessage>();
        if (repositories != null)
        {
            for (Repository repository : repositories)
            {
                if (repository != null)
                {
                    messages.addAll(this.loadIfNecessary(repository.getModels()));
                }
            }
        }
        return messages;
    }

    /**
     * Checks to see if <em>any</em> of the models need to be reloaded, and if so, re-loads them.
     *
     * @param models that will be loaded (if necessary).
     * @return any validation messages collected during loading.
     */
    private List<ModelValidationMessage> loadIfNecessary(final Model[] models)
    {
        final List<ModelValidationMessage> messages = new ArrayList<ModelValidationMessage>();
        if (models != null)
        {
            for (Model model : models)
            {
                messages.addAll(this.loadModelIfNecessary(model));
            }
        }
        return messages;
    }

    /**
     * Stores the current version of AndroMDA.
     */
    private static final String VERSION = BuildInformation.instance().getBuildVersion();

    /**
     * Prints the console header.
     */
    protected void printConsoleHeader()
    {
        AndroMDALogger.info("");
        AndroMDALogger.info("A n d r o M D A  -  " + VERSION);
        AndroMDALogger.info("");
    }

    /**
     * Whether or not model validation should be performed.
     */
    private static boolean modelValidation = true;

    /**
     * Sets whether or not model validation should occur. This is useful for
     * performance reasons (i.e. if you have a large model it can significantly decrease the amount of time it takes for
     * AndroMDA to process a model). By default this is set to <code>true</code>.
     *
     * @param modelValidationIn true/false on whether model validation should be performed or not.
     */
    public void setModelValidation(final boolean modelValidationIn)
    {
        ModelProcessor.modelValidation = modelValidationIn;
    }

    /**
     * Gets whether or not model validation should occur. This is useful for
     * performance reasons (i.e. if you have a large model it can significantly decrease the amount of time it takes for
     * AndroMDA to process a model). By default this is set to <code>true</code>.
     *
     * @return modelValidation true/false on whether model validation should be performed or not.
     */
    public static boolean getModelValidation()
    {
        return ModelProcessor.modelValidation;
    }

    /**
     * A flag indicating whether or not failure should occur
     * when model validation errors are present.
     */
    private boolean failOnValidationErrors = true;

    /**
     * Sets whether or not processing should fail when validation errors occur, default is <code>true</code>.
     *
     * @param failOnValidationErrors whether or not processing should fail if any validation errors are present.
     */
    public void setFailOnValidationErrors(final boolean failOnValidationErrors)
    {
        this.failOnValidationErrors = failOnValidationErrors;
    }

    /**
     * Stores the cartridge filter.
     */
    private List cartridgeFilter = null;

    /**
     * Denotes whether or not the complement of filtered cartridges should be processed
     */
    private boolean negateCartridgeFilter = false;

    /**
     * Indicates whether or not the <code>namespace</code> should be processed. This is determined in conjunction with
     * {@link #setCartridgeFilter(String)}. If the <code>cartridgeFilter</code> is not defined and the namespace is
     * present within the configuration, then this method will <strong>ALWAYS </strong> return true.
     *
     * @param namespace the name of the namespace to check whether or not it should be processed.
     * @return true/false on whether or not it should be processed.
     */
    protected boolean shouldProcess(final String namespace)
    {
        boolean shouldProcess = this.namespaces.namespacePresent(namespace);
        if (shouldProcess)
        {
            shouldProcess = this.cartridgeFilter == null || this.cartridgeFilter.isEmpty();
            if (!shouldProcess)
            {
                shouldProcess =
                    this.negateCartridgeFilter ^ this.cartridgeFilter.contains(StringUtils.trimToEmpty(namespace));
            }
        }
        return shouldProcess;
    }

    /**
     * The prefix used for cartridge filter negation.
     */
    private static final String CARTRIDGE_FILTER_NEGATOR = "~";

    /**
     * <p>
     * Sets the current cartridge filter. This is a comma separated list of namespaces (matching cartridges names) that
     * should be processed. </p>
     * <p>
     * If this filter is defined, then any cartridge names found in this list <strong>will be processed </strong>, while
     * any other discovered cartridges <strong>will not be processed </strong>. </p>
     *
     * @param namespaces a comma separated list of the cartridge namespaces to be processed.
     */
    public void setCartridgeFilter(String namespaces)
    {
        if (namespaces != null)
        {
            namespaces = StringUtils.deleteWhitespace(namespaces);
            if (namespaces.startsWith(CARTRIDGE_FILTER_NEGATOR))
            {
                this.negateCartridgeFilter = true;
                namespaces = namespaces.substring(1);
            }
            else
            {
                this.negateCartridgeFilter = false;
            }
            if (StringUtils.isNotBlank(namespaces))
            {
                this.cartridgeFilter = Arrays.asList(namespaces.split(","));
            }
        }
    }

    /**
     * Sets the encoding (UTF-8, ISO-8859-1, etc) for all output
     * produced during model processing.
     *
     * @param outputEncoding the encoding.
     */
    public void setOutputEncoding(final String outputEncoding)
    {
        ResourceWriter.instance().setEncoding(outputEncoding);
    }

    /**
     * Sets <code>xmlValidation</code> to be true/false. This defines whether XML resources loaded by AndroMDA (such as
     * plugin descriptors) should be validated. Sometimes underlying parsers don't support XML Schema validation and in
     * that case, we want to be able to turn it off.
     *
     * @param xmlValidation true/false on whether we should validate XML resources used by AndroMDA
     */
    public void setXmlValidation(final boolean xmlValidation)
    {
        XmlObjectFactory.setDefaultValidating(xmlValidation);
    }

    /**
     * <p>
     * Sets the <code>loggingConfigurationUri</code> for AndroMDA. This is the URI to an external logging configuration
     * file. This is useful when you want to override the default logging configuration of AndroMDA. </p>
     * <p>
     * You can retrieve the default log4j.xml contained within the {@link org.andromda.core.common}package, customize
     * it, and then specify the location of this logging file with this operation. </p>
     *
     * @param loggingConfigurationUri the URI to the external logging configuration file.
     */
    public void setLoggingConfigurationUri(final String loggingConfigurationUri)
    {
        AndroMDALogger.setLoggingConfigurationUri(loggingConfigurationUri);
    }

    /**
     * Filters out any <em>invalid</em> models. This means models that either are null within the specified
     * <code>models</code> array or those that don't have URLs set.
     *
     * @param models the models to filter.
     * @return the array of valid models
     */
    private Model[] filterInvalidModels(final Model[] models)
    {
        final Collection<Model> validModels = new ArrayList<Model>(Arrays.asList(models));
        CollectionUtils.filter(validModels, new Predicate() {
            public boolean evaluate(Object o) {
                final Model model = (Model)o;
                return model != null && model.getUris() != null && model.getUris().length > 0;
            }
        });

        return validModels.toArray(new Model[validModels.size()]);
    }

    /**
     * Shuts down the model processor (reclaims any
     * resources).
     */
    public void shutdown()
    {
        // - shutdown the metafacade factory instance
        this.factory.shutdown();

        // - shutdown the configuration namespaces instance
        this.namespaces.clear();

        // - shutdown the container instance
        ComponentContainer.instance().shutdown();

        // - shutdown the namespace components registry
        NamespaceComponents.instance().shutdown();

        // - shutdown the introspector
        Introspector.instance().shutdown();

        // - clear out any caches used by the configuration
        Configuration.clearCaches();

        // - clear out any repositories
        this.repositories.clear();
    }

    /**
     * Reinitializes the model processor's resources.
     */
    private void reset()
    {
        this.factory.reset();
        this.cartridgeFilter = null;
        this.setXmlValidation(true);
        this.setOutputEncoding(null);
        this.setModelValidation(true);
        this.setFailOnValidationErrors(true);
    }

    /**
     * Filters out any messages that should not be applied according to the AndroMDA configuration's
     * constraints and sorts the resulting <code>messages</code> first by type (i.e. the metafacade class)
     * and then by the <code>name</code> of the model element to which the validation message applies.
     *
     * @param messages the collection of messages to sort.
     * @param constraints any constraint filters to apply to the validation messages.
     */
    protected void filterAndSortValidationMessages(
        final List<ModelValidationMessage> messages,
        final Filters constraints)
    {
        if (constraints != null)
        {
            // - perform constraint filtering (if any applies)
            CollectionUtils.filter(messages, new Predicate() {
                public boolean evaluate(Object o) {
                    ModelValidationMessage message = (ModelValidationMessage)o;
                    return constraints.isApply(message.getName());
                }
            });
        }

        if (messages != null && !messages.isEmpty())
        {
            final ComparatorChain chain = new ComparatorChain();
            chain.addComparator(new ValidationMessageTypeComparator());
            chain.addComparator(new ValidationMessageNameComparator());
            Collections.sort(
                messages,
                chain);
        }
    }

    /**
     * Used to sort validation messages by <code>metafacadeClass</code>.
     */
    private static final class ValidationMessageTypeComparator
        implements Comparator<ModelValidationMessage>
    {
        private final Collator collator = Collator.getInstance();

        ValidationMessageTypeComparator()
        {
            collator.setStrength(Collator.PRIMARY);
        }

        public int compare(
            final ModelValidationMessage objectA,
            final ModelValidationMessage objectB)
        {
            return collator.compare(
                objectA.getMetafacadeClass().getName(),
                objectB.getMetafacadeClass().getName());
        }
    }

    /**
     * Used to sort validation messages by <code>modelElementName</code>.
     */
    private static final class ValidationMessageNameComparator
        implements Comparator<ModelValidationMessage>
    {
        private final Collator collator = Collator.getInstance();

        ValidationMessageNameComparator()
        {
            collator.setStrength(Collator.PRIMARY);
        }

        public int compare(
            final ModelValidationMessage objectA,
            final ModelValidationMessage objectB)
        {
            return collator.compare(
                StringUtils.trimToEmpty(objectA.getMetafacadeName()),
                StringUtils.trimToEmpty(objectB.getMetafacadeName()));
        }
    }
}