/**
 *  Licensed to the Apache Software Foundation (ASF) under one or more
 *  contributor license agreements.  See the NOTICE file distributed with
 *  this work for additional information regarding copyright ownership.
 *  The ASF licenses this file to You under the Apache License, Version 2.0
 *  (the "License"); you may not use this file except in compliance with
 *  the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */

package org.apache.geronimo.deployment;

import java.io.File;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.URI;
import java.net.URL;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.jar.Attributes;
import java.util.jar.JarFile;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;

import javax.xml.bind.JAXBException;
import javax.xml.stream.XMLStreamException;
import org.apache.geronimo.common.DeploymentException;
import org.apache.geronimo.common.IllegalConfigurationException;
import org.apache.geronimo.deployment.util.osgi.DummyExportPackagesSelector;
import org.apache.geronimo.deployment.util.osgi.OSGiMetaDataBuilder;
import org.apache.geronimo.gbean.AbstractName;
import org.apache.geronimo.gbean.AbstractNameQuery;
import org.apache.geronimo.gbean.GAttributeInfo;
import org.apache.geronimo.gbean.GBeanData;
import org.apache.geronimo.gbean.GBeanInfo;
import org.apache.geronimo.gbean.GOperationInfo;
import org.apache.geronimo.gbean.GReferenceInfo;
import org.apache.geronimo.gbean.ReferencePatterns;
import org.apache.geronimo.kernel.GBeanAlreadyExistsException;
import org.apache.geronimo.kernel.GBeanNotFoundException;
import org.apache.geronimo.kernel.Naming;
import org.apache.geronimo.kernel.config.Configuration;
import org.apache.geronimo.kernel.config.ConfigurationData;
import org.apache.geronimo.kernel.config.ConfigurationManager;
import org.apache.geronimo.kernel.config.ConfigurationModuleType;
import org.apache.geronimo.kernel.config.Manifest;
import org.apache.geronimo.kernel.config.ManifestException;
import org.apache.geronimo.kernel.repository.Artifact;
import org.apache.geronimo.kernel.repository.Dependency;
import org.apache.geronimo.kernel.repository.Environment;
import org.apache.geronimo.kernel.repository.Repository;
import org.apache.geronimo.system.plugin.model.ArtifactType;
import org.apache.geronimo.system.plugin.model.DependencyType;
import org.apache.geronimo.system.plugin.model.PluginArtifactType;
import org.apache.geronimo.system.plugin.model.PluginType;
import org.apache.geronimo.system.plugin.model.PluginXmlUtil;
import org.apache.xbean.osgi.bundle.util.BundleUtils;
import org.osgi.framework.Bundle;
import org.osgi.framework.BundleContext;
import org.osgi.framework.BundleException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * @version $Rev:385232 $ $Date$
 */
public class DeploymentContext {

    private static final Logger log = LoggerFactory.getLogger(DeploymentContext.class);

    protected final File baseDir;
    protected final File inPlaceConfigurationDir;
    protected final ResourceContext resourceContext;
    protected final Map<String, ConfigurationData> childConfigurationDatas = new LinkedHashMap<String, ConfigurationData>();
    protected final ConfigurationManager configurationManager;
    protected final Naming naming;
    protected final List<ConfigurationData> additionalDeployment = new ArrayList<ConfigurationData>();
    protected final AbstractName moduleName;
    protected final LinkedHashSet<String> bundleClassPath = new LinkedHashSet<String>();
    protected final ConfigurationModuleType moduleType;
    protected final Environment environment;
    //This provides services such as loading more bundles, it is NOT for the configuration we are constructing here.
    //It should be a disposable nested framework so as to not pollute the main framework with stuff we load as deployment parents.
    private final BundleContext bundleContext;
    protected Configuration configuration;
    private Bundle tempBundle;


    public DeploymentContext(File baseDir,
                             File inPlaceConfigurationDir,
                             Environment environment,
                             AbstractName moduleName,
                             ConfigurationModuleType moduleType,
                             Naming naming,
                             ConfigurationManager configurationManager,
                             Collection<Repository> repositories,
                             BundleContext bundleContext) throws DeploymentException {
        this(baseDir, inPlaceConfigurationDir, environment, moduleName, moduleType, naming,
             createConfigurationManager(configurationManager, repositories, bundleContext), bundleContext);
    }

    public DeploymentContext(File baseDir,
                             File inPlaceConfigurationDir,
                             Environment environment,
                             AbstractName moduleName,
                             ConfigurationModuleType moduleType,
                             Naming naming,
                             ConfigurationManager configurationManager,
                             BundleContext bundleContext) throws DeploymentException {
        if (environment == null) throw new NullPointerException("environment is null");
        if (moduleType == null) throw new NullPointerException("type is null");
        if (configurationManager == null) throw new NullPointerException("configurationManager is null");
        if (baseDir == null) throw new NullPointerException("baseDir is null");
        if (!baseDir.exists() && !baseDir.mkdirs()) {
            throw new DeploymentException("Could not create directory for deployment context assembly: " + baseDir);
        }
        if (bundleContext == null) {
            throw new NullPointerException("no bundle context");
        }

        this.baseDir = baseDir;
        this.inPlaceConfigurationDir = inPlaceConfigurationDir;
        this.moduleName = moduleName;
        this.naming = naming;
        this.moduleType = moduleType;
        this.environment = environment;
        this.configurationManager = createConfigurationManager(configurationManager, Collections.<Repository> emptyList(), bundleContext);
        this.bundleContext = bundleContext;

        if (null == inPlaceConfigurationDir) {
            this.resourceContext = new CopyResourceContext(this, baseDir);
        } else {
            this.resourceContext = new InPlaceResourceContext(this, inPlaceConfigurationDir);
        }
    }

    // For sub-classes only
    protected DeploymentContext(File baseDir,
                                File inPlaceConfigurationDir,
                                Environment environment,
                                AbstractName moduleName,
                                ConfigurationModuleType moduleType,
                                Naming naming,
                                ConfigurationManager configurationManager,
                                ResourceContext resourceContext,
                                BundleContext bundleContext) throws DeploymentException {
        if (bundleContext == null) {
            throw new NullPointerException("no bundle context");
        }
        this.baseDir = baseDir;
        this.inPlaceConfigurationDir = inPlaceConfigurationDir;
        this.moduleName = moduleName;
        this.naming = naming;
        this.moduleType = moduleType;
        this.environment = environment;
        this.configurationManager = createConfigurationManager(configurationManager, Collections.<Repository> emptyList(), bundleContext);
        this.resourceContext = resourceContext;
        this.bundleContext = bundleContext;
    }

    private static ConfigurationManager createConfigurationManager(ConfigurationManager configurationManager, Collection<Repository> repositories, BundleContext bundleContext) {
        if (configurationManager instanceof DeploymentConfigurationManager) {
            return configurationManager;
        }
        return new DeploymentConfigurationManager(configurationManager, repositories, bundleContext);
    }

    /**
     * call to set up the (empty) Configuration we will use to store the gbeans we add to the context. It will use a temporary BundleContext/Bundle for classloading.
     * @throws DeploymentException if configuration cannot be loaded successfully
     */
    public void initializeConfiguration() throws DeploymentException {
        this.configuration = createTempConfiguration();
    }

    private Configuration createTempConfiguration() throws DeploymentException {
        LinkedHashSet<Artifact> resolvedParentIds = null;
        try {
            ConfigurationData configurationData = new ConfigurationData(moduleType, null, childConfigurationDatas, environment, baseDir, inPlaceConfigurationDir, naming);
            createTempManifest();
            createPluginMetadata();
            String location = "reference:" + getConfigurationDir().toURI().toURL();
            tempBundle = bundleContext.installBundle(location);
            if (BundleUtils.canStart(tempBundle)) {
                tempBundle.start(Bundle.START_TRANSIENT);
            }
            configurationData.setBundleContext(tempBundle.getBundleContext());
            configurationManager.loadConfiguration(configurationData);
            return configurationManager.getConfiguration(environment.getConfigId());
        } catch (Exception e) {
            throw new DeploymentException("Unable to create configuration for deployment: dependencies: " + resolvedParentIds, e);
        }
    }

    private void createPluginMetadata() throws IOException, JAXBException, XMLStreamException {
        PluginType pluginType = getPluginMetadata();
        File metaInf = new File(getConfigurationDir(), "META-INF");
        metaInf.mkdirs();
        OutputStream out = new FileOutputStream(new File(metaInf, "geronimo-plugin.xml"));
        try {
            PluginXmlUtil.writePluginMetadata(pluginType, out);
        } finally {
            out.close();
        }
    }

    public PluginType getPluginMetadata() {
        PluginType pluginType = new PluginType();
        pluginType.setName("Temporary Plugin metadata for deployment");
        PluginArtifactType instance = new PluginArtifactType();
        instance.setModuleId(ArtifactType.newArtifactType(environment.getConfigId()));
        List<DependencyType> dependenciees = instance.getDependency();
        for (Dependency dependency: environment.getDependencies()) {
            dependenciees.add(DependencyType.newDependencyType(dependency));
        }
        pluginType.getPluginArtifact().add(instance);
        return pluginType;
    }

    private void createTempManifest() throws DeploymentException, IOException {
        Environment env = new Environment(environment);
        Artifact id = env.getConfigId();
        env.setConfigId(new Artifact(id.getGroupId(), id.getArtifactId() + "-DEPLOYMENT", id.getVersion(), id.getType()));
        env.addToBundleClassPath(bundleClassPath);
        env.setBundleActivator(null);
        env.addDynamicImportPackage("*");

        OSGiMetaDataBuilder osgiMetaDataBuilder = new OSGiMetaDataBuilder(bundleContext, new DummyExportPackagesSelector());
        try {
            osgiMetaDataBuilder.build(env);
        } catch (IllegalConfigurationException e) {
            throw new DeploymentException(e);
        }
        Manifest manifest;
        try {
            manifest = env.getManifest();
        } catch (ManifestException e) {
            throw new DeploymentException(e);
        }

        File metaInf = new File(getConfigurationDir(), "META-INF");
        metaInf.mkdirs();
        FileWriter fw = new FileWriter(new File(metaInf, "MANIFEST.MF"));
        PrintWriter pw = new PrintWriter(fw);
        try {
            manifest.write(pw);
        } finally {
            pw.close();
            fw.close();
        }
    }

    private File getConfigurationDir() {
        return (inPlaceConfigurationDir == null) ? baseDir : inPlaceConfigurationDir;
    }

    public ConfigurationManager getConfigurationManager() {
        return configurationManager;
    }

    public Artifact getConfigID() {
        return environment.getConfigId();
    }

    public File getBaseDir() {
        return baseDir;
    }

    public File getInPlaceConfigurationDir() {
        return inPlaceConfigurationDir;
    }

    public LinkedHashSet<String> getBundleClassPath() {
        return new LinkedHashSet<String>(bundleClassPath);
    }

    public Naming getNaming() {
        return naming;
    }

    public GBeanData addGBean(String name, GBeanInfo gbeanInfo) throws GBeanAlreadyExistsException {
        if (name == null) throw new NullPointerException("name is null");
        if (gbeanInfo == null) throw new NullPointerException("gbean is null");
        GBeanData gbean = new GBeanData(gbeanInfo);
        configuration.addGBean(name, gbean);
        return gbean;
    }

    public void addGBean(GBeanData gbean) throws GBeanAlreadyExistsException {
        if (gbean == null) throw new NullPointerException("gbean is null");
        if (gbean.getAbstractName() == null) throw new NullPointerException("gbean.getAbstractName() is null");
        configuration.addGBean(gbean);
    }

    public void removeGBean(AbstractName name) throws GBeanNotFoundException {
        if (name == null) throw new NullPointerException("name is null");
        configuration.removeGBean(name);
    }

    public Set<AbstractName> getGBeanNames() {
        return new HashSet<AbstractName>(configuration.getGBeans().keySet());
    }

    /**
     * @param pattern Search for gbeans whose name matches pattern.
     * @return the set of gbeans whose name matches the pattern.
     * @deprecated use findGBeans(pattern)
     */
    public Set<AbstractName> listGBeans(AbstractNameQuery pattern) {
        return findGBeans(pattern);
    }

    public AbstractName findGBean(AbstractNameQuery pattern) throws GBeanNotFoundException {
        return configuration.findGBean(pattern);
    }

    public AbstractName findGBean(Set<AbstractNameQuery> patterns) throws GBeanNotFoundException {
        return configuration.findGBean(patterns);
    }

    public LinkedHashSet<AbstractName> findGBeans(AbstractNameQuery pattern) {
        return configuration.findGBeans(pattern);
    }

    public LinkedHashSet<GBeanData> findGBeanDatas(Set<AbstractNameQuery> patterns) {
        return configuration.findGBeanDatas(patterns);
    }

    public LinkedHashSet<GBeanData> findGBeanDatas(Configuration configuration, AbstractNameQuery pattern) {
        return configuration.findGBeanDatas(configuration, Collections.singleton(pattern));
    }

    public LinkedHashSet<AbstractName> findGBeans(Set<AbstractNameQuery> patterns) {
        return configuration.findGBeans(patterns);
    }

    public GBeanData getGBeanInstance(AbstractName name) throws GBeanNotFoundException {
        Map<AbstractName, GBeanData> gbeans = configuration.getGBeans();
        GBeanData gbeanData = gbeans.get(name);
        if (gbeanData == null) {
            throw new GBeanNotFoundException(name);
        }
        return gbeanData;
    }

    /**
     * Add a packed jar file into the deployment context and place it into the
     * path specified in the target path.  The newly added packed jar is added
     * to the classpath of the configuration.
     *
     * @param targetPath where the packed jar file should be placed
     * @param jarFile    the jar file to copy
     * @throws IOException if there's a problem copying the jar file
     */
    public void addIncludeAsPackedJar(URI targetPath, JarFile jarFile) throws IOException {
        resourceContext.addIncludeAsPackedJar(targetPath, jarFile);
    }

    /**
     * Add a ZIP file entry into the deployment context and place it into the
     * path specified in the target path.  The newly added entry is added
     * to the classpath of the configuration.
     *
     * @param targetPath where the ZIP file entry should be placed
     * @param zipFile    the ZIP file
     * @param zipEntry   the ZIP file entry
     * @throws IOException if there's a problem copying the ZIP entry
     */
    public void addInclude(URI targetPath, ZipFile zipFile, ZipEntry zipEntry) throws IOException {
        resourceContext.addInclude(targetPath, zipFile, zipEntry);
    }

    /**
     * Add a file into the deployment context and place it into the
     * path specified in the target path.  The newly added file is added
     * to the classpath of the configuration.
     *
     * @param targetPath where the file should be placed
     * @param source     the URL of file to be copied
     * @throws IOException if there's a problem copying the ZIP entry
     */
    public void addInclude(URI targetPath, URL source) throws IOException {
        resourceContext.addInclude(targetPath, source);
    }

    /**
     * Add a file into the deployment context and place it into the
     * path specified in the target path.  The newly added file is added
     * to the classpath of the configuration.
     *
     * @param targetPath where the file should be placed
     * @param source     the file to be copied
     * @throws IOException if there's a problem copying the ZIP entry
     */
    public void addInclude(URI targetPath, File source) throws IOException {
        resourceContext.addInclude(targetPath, source);
    }

    private class DefaultJarFileFactory implements ClassPathUtils.JarFileFactory {

        public JarFile newJarFile(URI relativeURI) throws IOException {
            File targetFile = getTargetFile(relativeURI);
            try {
                return new JarFile(targetFile);
            } catch (IOException e) {
                throw (IOException) new IOException("Could not create JarFile for file: " + targetFile).initCause(e);
            }
        }

        public String getManifestClassPath(JarFile jarFile) throws IOException {
            java.util.jar.Manifest manifest = jarFile.getManifest();
            if (manifest == null) {
                return null;
            }
            return manifest.getMainAttributes().getValue(Attributes.Name.CLASS_PATH);
        }

        public boolean isDirectory(URI relativeURI) {
            File targetFile = getTargetFile(relativeURI);
            return targetFile.isDirectory();
        }

        public File[] listFiles(URI relativeURI) throws IOException {
            File targetFile = getTargetFile(relativeURI);
            if (targetFile.isDirectory()) {
                File[] files = targetFile.listFiles();
                return (files == null) ? new File[0] : files;
            } else {
                throw new IOException(targetFile + " is not a directory");
            }
        }
    }

    public void getCompleteManifestClassPath(Deployable deployable, URI moduleBaseUri, URI resolutionUri, Collection<String> classpath, Collection<String> exclusions) throws DeploymentException {
        if (!(deployable instanceof DeployableJarFile)) {
            throw new IllegalArgumentException("Expected DeployableJarFile");
        }
        JarFile moduleFile = ((DeployableJarFile) deployable).getJarFile();
        ClassPathUtils.getCompleteManifestClassPath(moduleFile, moduleBaseUri, resolutionUri, classpath, exclusions, new DefaultJarFileFactory());
    }

    public void addManifestClassPath(JarFile moduleFile, URI moduleBaseUri, Collection<String> manifestClasspath) throws DeploymentException {
        ClassPathUtils.addManifestClassPath(moduleFile, moduleBaseUri, manifestClasspath, new DefaultJarFileFactory());
    }

    public void addToClassPath(String target) {
        bundleClassPath.add(target);
    }

    public void addFile(URI targetPath, ZipFile zipFile, ZipEntry zipEntry) throws IOException {
        resourceContext.addFile(targetPath, zipFile, zipEntry);
    }

    public void addFile(URI targetPath, URL source) throws IOException {
        resourceContext.addFile(targetPath, source);
    }

    public void addFile(URI targetPath, File source) throws IOException {
        resourceContext.addFile(targetPath, source);
    }

    public void addFile(URI targetPath, String source) throws IOException {
        resourceContext.addFile(targetPath, source);
    }

    public File getTargetFile(URI targetPath) {
        return resourceContext.getTargetFile(targetPath);
    }

    public URL getTargetURL(URI targetPath) {
        return resourceContext.getTargetURL(targetPath);
    }

    public Bundle getDeploymentBundle() throws DeploymentException {
        return configuration.getBundle();
    }

    public ConfigurationModuleType getModuleType() {
        return moduleType;
    }

    public Environment getEnvironment() {
        return environment;
    }

    protected BundleContext getBundleContext() {
        return bundleContext;
    }

    public Configuration getConfiguration() {
        if (configuration == null) throw new IllegalStateException("configuration not initialized");
        return configuration;
    }

    public void flush() throws IOException {
        resourceContext.flush();
    }

    public void close() throws IOException, DeploymentException {
        if (configurationManager != null && configuration != null) {
            try {
                configurationManager.unloadConfiguration(configuration.getId());
            } catch (Exception ignored) {
            }
        }
        if (tempBundle != null) {
            try {
                tempBundle.uninstall();
            } catch (BundleException e) {
            }
        }
    }

    public void addChildConfiguration(String moduleName, ConfigurationData configurationData) {
        childConfigurationDatas.put(moduleName, configurationData);
    }

    /**
     * Extract the completed ConfigurationData ready for serialization
     * @return final ConfigurationData
     * @throws DeploymentException if configuration is invalid
     */
    public ConfigurationData getConfigurationData() throws DeploymentException {
        List<String> failures = verify(configuration);
        if (!failures.isEmpty()) {
            StringBuilder message = new StringBuilder();
            for (String failure : failures) {
                if (message.length() > 0) message.append("\n");
                message.append(failure);
            }
            throw new DeploymentException(message.toString());
        }

        // TODO OSGI figure out exports
        environment.addToBundleClassPath(bundleClassPath);

        List<GBeanData> gbeans = new ArrayList<GBeanData>(configuration.getGBeans().values());
        Collections.sort(gbeans, new GBeanData.PriorityComparator());

        OSGiMetaDataBuilder osgiMetaDataBuilder = null;
        //TODO Import package calculation is only used for deployed applications, should be use the same way for car package later
        if (System.getProperty("geronimo.build.car") == null) {
            osgiMetaDataBuilder = new OSGiMetaDataBuilder(bundleContext);
            //Hack Codes Here For RAR module, will remove while the connector refactoring is done
            if (configuration.getModuleType() == ConfigurationModuleType.RAR) {
                environment.addDynamicImportPackage("*");
            }
        } else {
            LinkedHashSet<String> imports = getImports(gbeans);
            if (environment.getBundleActivator() != null) {
                addImport(imports, environment.getBundleActivator());
            }
            environment.addImportPackages(imports);
            environment.addDynamicImportPackage("*");
            osgiMetaDataBuilder = new OSGiMetaDataBuilder(bundleContext, new DummyExportPackagesSelector());
        }

        try {
            osgiMetaDataBuilder.build(environment, configuration.getModuleType() == ConfigurationModuleType.CAR);
        } catch (IllegalConfigurationException e) {
            throw new DeploymentException(e);
        }

        if (tempBundle != null) {
            try {
                createPluginMetadata();
            } catch (Exception e) {
                throw new DeploymentException("Failed to update geronimo-plugin.xml", e);
            }
        }

        ConfigurationData configurationData = new ConfigurationData(configuration.getModuleType(),
                gbeans,
                childConfigurationDatas,
                configuration.getEnvironment(),
                baseDir,
                inPlaceConfigurationDir,
                naming
        );

        for (ConfigurationData ownedConfiguration : additionalDeployment) {
            configurationData.addOwnedConfigurations(ownedConfiguration.getId());
        }

        return configurationData;
    }

    public static LinkedHashSet<String> getImports(List<GBeanData> gbeans) {
        LinkedHashSet<String> imports = new LinkedHashSet<String>();
        for (GBeanData data: gbeans) {
            GBeanInfo info = data.getGBeanInfo();
            addImport(imports, info.getClassName());
            for (GAttributeInfo attInfo: info.getAttributes()) {
                addImport(imports, attInfo.getType());
            }
            for (GReferenceInfo refInfo: info.getReferences()) {
                addImport(imports, refInfo.getReferenceType());
            }
            for (GOperationInfo opInfo: info.getOperations()) {
                addImport(imports, opInfo.getReturnType());
                for (String paramType : opInfo.getParameterList()) {
                    addImport(imports, paramType);
                }
            }
        }
        return imports;
    }

    private static void addImport(LinkedHashSet<String> imports, String className) {
        String packageName = getImportPackageName(className);
        if (packageName == null || packageName.startsWith("java.")) {
            return;
        }
        imports.add(packageName);
    }

    private static String getImportPackageName(String className) {
        int pos = className.lastIndexOf('.');
        if (pos < 0) {
            return null;
        }
        int count = 0;
        while (className.charAt(count) == '[') {
            count++;
        }
        if (className.charAt(count) == 'L') {
            count++;
        }
        className = className.substring(count, pos);
        return className;
    }

    public void addAdditionalDeployment(ConfigurationData configurationData) {
        additionalDeployment.add(configurationData);
    }

    public List<ConfigurationData> getAdditionalDeployment() {
        return additionalDeployment;
    }

    public AbstractName getModuleName() {
        return moduleName;
    }

    public List<String> verify(Configuration configuration) throws DeploymentException {
        List<String> failures = new ArrayList<String>();
        for (Map.Entry<AbstractName, GBeanData> entry : this.configuration.getGBeans().entrySet()) {
            AbstractName name = entry.getKey();
            GBeanData gbean = entry.getValue();

            for (Map.Entry<String, ReferencePatterns> referenceEntry : gbean.getReferences().entrySet()) {
                String referenceName = referenceEntry.getKey();
                ReferencePatterns referencePatterns = referenceEntry.getValue();

                String failure = verifyReference(gbean, referenceName, referencePatterns, configuration);
                if (failure != null) {
                    failures.add(failure);
                }
            }

            for (ReferencePatterns referencePatterns : gbean.getDependencies()) {
                String failure = verifyDependency(name, referencePatterns, configuration);
                if (failure != null) {
                    failures.add(failure);
                }
            }
        }
        return failures;
    }

    private String verifyReference(GBeanData gbean, String referenceName, ReferencePatterns referencePatterns, Configuration configuration) {
        GReferenceInfo referenceInfo = gbean.getGBeanInfo().getReference(referenceName);

        // if there is no reference info we can't verify
        if (referenceInfo == null) return null;

        // A collection valued reference doesn't need to be verified
        if (referenceInfo.getProxyType().equals(Collection.class.getName())) return null;

        String message = isVerifyReference(referencePatterns, configuration);
        if (message != null) {
            return "Unable to resolve reference \"" + referenceName + "\"\n" +
                    "    in gbean " + gbean.getAbstractName() + "\n    to a gbean matching the pattern " + referencePatterns.getPatterns() + "\n    due to: " + message;
        }
        return null;
    }

    private String verifyDependency(AbstractName name, ReferencePatterns referencePatterns, Configuration configuration) {
        String message = isVerifyReference(referencePatterns, configuration);
        if (message != null) {
            return "Unable to resolve dependency in gbean " + name +
                    "\n    to a gbean matching the pattern " + referencePatterns.getPatterns() + "\n    due to: " + message;
        }

        return null;
    }

    private String isVerifyReference(ReferencePatterns referencePatterns, Configuration configuration) {
        // we can't verify a resolved reference since it will have a specific artifact already set...
        // hopefully the deployer won't generate bad resolved references
        if (referencePatterns.isResolved()) return null;

        // Do not verify the reference if it has an explicit depenency on another artifact, because it it likely
        // that the other artifact is not in the "environment" (if it were you wouldn't use the long form)
        Set<AbstractNameQuery> patterns = referencePatterns.getPatterns();
        for (AbstractNameQuery query : patterns) {
            if (query.getArtifact() != null) return null;
        }

        // attempt to find the bean
        try {
            configuration.findGBean(patterns);
            return null;
        } catch (GBeanNotFoundException e) {
            //TODO bug!! GERONIMO-3140 Multiple matches may be caused by using an already-loaded configuration rather than reloading one
            // using the client_artifact_aliases.properties which e.g. remap the server tm to the client tm.
            if (e.hasMatches()) {
                return null;
            }
            return e.getMessage();
        }
    }
}