import java.util.Collections;

import java.util.Set;

    private String moduleDependencies;

    public static final String OPENIDE_MODULE_MODULE_DEPENDENCIES = "OpenIDE-Module-Module-Dependencies"; // NOI18N

        this.moduleDependencies = moduleDependencies;

    }

    public Set/*<Dependency>*/ getModuleDependencies() {

        if (moduleDependencies != null) {

            return Dependency.create(Dependency.TYPE_MODULE, moduleDependencies);

        } else {

            return Collections.EMPTY_SET;

        }

import java.awt.EventQueue;

import java.io.IOException;

import java.util.Iterator;

import java.util.LinkedHashSet;

import org.netbeans.api.project.ProjectUtils;

import org.netbeans.modules.apisupport.project.ManifestManager;

import org.netbeans.modules.apisupport.project.NbModuleProjectType;

import org.netbeans.modules.apisupport.project.Util;

import org.openide.ErrorManager;

import org.openide.modules.Dependency;

import org.openide.modules.SpecificationVersion;

import org.openide.util.RequestProcessor;

import org.w3c.dom.Element;

    private ModuleEntry[] platformModules;

        universe = null;

        updateDependencyWarnings();

            updateDependencyWarnings();

    }

    // #65924: show warnings if some dependencies cannot be satisfied

    interface UniverseModule {

        String getCodeNameBase();

        int getReleaseVersion();

        SpecificationVersion getSpecificationVersion();

        String getImplementationVersion();

        Set/*<String>*/ getProvidedTokens();

        Set/*<String>*/ getRequiredTokens();

        Set/*<Dependency>*/ getModuleDependencies();

        String getCluster();

        String getDisplayName();

    }

    private static abstract class AbstractUniverseModule implements UniverseModule {

        protected final ManifestManager mm;

        protected AbstractUniverseModule(ManifestManager mm) {

            this.mm = mm;

        }

        public int getReleaseVersion() {

            String s = mm.getReleaseVersion();

            return s != null ? Integer.parseInt(s) : -1;

        }

        public String getImplementationVersion() {

            return mm.getImplementationVersion();

        }

        public Set/*<String>*/ getProvidedTokens() {

            return new HashSet(Arrays.asList(mm.getProvidedTokens()));

        }

        public Set/*<String>*/ getRequiredTokens() {

            return new HashSet(Arrays.asList(mm.getRequiredTokens()));

        }

    }

    private static final class PlatformModule extends AbstractUniverseModule {

        private final ModuleEntry entry;

        public PlatformModule(ModuleEntry entry) throws IOException {

            super(ManifestManager.getInstanceFromJAR(entry.getJarLocation()));

            this.entry = entry;

        }

        public String getCodeNameBase() {

            return entry.getCodeNameBase();

        }

        public SpecificationVersion getSpecificationVersion() {

            String s = entry.getSpecificationVersion();

            return s != null ? new SpecificationVersion(s) : null;

        }

        public Set/*<Dependency>*/ getModuleDependencies() {

            return mm.getModuleDependencies();

        }

        public String getCluster() {

            return entry.getClusterDirectory().getName();

        }

        public String getDisplayName() {

            return entry.getLocalizedName();

        }

    }

    private static final class SuiteModule extends AbstractUniverseModule {

        private final NbModuleProject project;

        private final Set/*<Dependency>*/ dependencies;

        public SuiteModule(NbModuleProject project) {

            super(ManifestManager.getInstance(project.getManifest(), false));

            this.project = project;

            dependencies = new HashSet();

            // Cannot use ProjectXMLManager since we need to report also deps on nonexistent modules.

            Element dataE = project.getHelper().getPrimaryConfigurationData(true);

            Element depsE = Util.findElement(dataE, "module-dependencies", NbModuleProjectType.NAMESPACE_SHARED); // NOI18N

            Iterator/*<Element>*/ deps = Util.findSubElements(depsE).iterator();

            while (deps.hasNext()) {

                Element dep = (Element) deps.next();

                Element run = Util.findElement(dep, "run-dependency", NbModuleProjectType.NAMESPACE_SHARED); // NOI18N

                if (run == null) {

                    continue;

                }

                String text = Util.findText(Util.findElement(dep, "code-name-base", NbModuleProjectType.NAMESPACE_SHARED)); // NOI18N

                Element relverE = Util.findElement(run, "release-version", NbModuleProjectType.NAMESPACE_SHARED); // NOI18N

                if (relverE != null) {

                    text += '/' + Util.findText(relverE);

                }

                Element specverE = Util.findElement(run, "specification-version", NbModuleProjectType.NAMESPACE_SHARED); // NOI18N

                if (specverE != null) {

                    text += '>' + Util.findText(specverE);

                } else {

                    Element implver = Util.findElement(run, "implementation-version", NbModuleProjectType.NAMESPACE_SHARED); // NOI18N

                    if (implver != null) {

                        // Will special-case '*' as an impl version to mean "match anything".

                        text += "=*"; // NOI18N

                    }

                }

                dependencies.addAll(Dependency.create(Dependency.TYPE_MODULE, text));

            }

        }

        public String getCodeNameBase() {

            return project.getCodeNameBase();

        }

        public SpecificationVersion getSpecificationVersion() {

            String s = project.getSpecVersion();

            return s != null ? new SpecificationVersion(s) : null;

        }

        public Set/*<Dependency>*/ getModuleDependencies() {

            return dependencies;

        }

        public String getCluster() {

            return null;

        }

        public String getDisplayName() {

            return ProjectUtils.getInformation(project).getDisplayName();

        }

    }

    private RequestProcessor.Task updateDependencyWarningsTask;

    private void updateDependencyWarnings() {

        if (updateDependencyWarningsTask == null) {

            updateDependencyWarningsTask = RequestProcessor.getDefault().create(new Runnable() {

                public void run() {

                    doUpdateDependencyWarnings();

                }

            });

        }

        updateDependencyWarningsTask.schedule(0);

    }

    static Set/*<UniverseModule>*/ loadUniverseModules(ModuleEntry[] platformModules, Set/*<NbModuleProject>*/ suiteModules) throws IOException {

        Set universe = new LinkedHashSet();

        Iterator/*<Project>*/ it = suiteModules.iterator();

        while (it.hasNext()) {

            universe.add(new SuiteModule((NbModuleProject) it.next()));

        }

        for (int i = 0; i < platformModules.length; i++) {

            universe.add(new PlatformModule(platformModules[i]));

        }

        return universe;

    }

    static String[] findWarning(Set/*<UniverseModule>*/ universeModules, Set/*<String>*/ disabledClusters, Set/*<String>*/ disabledModules) {

        // XXX

        return null;

    }

    private Set/*<UniverseModule>*/ universe;

    private void doUpdateDependencyWarnings() {

        // XXX consider using a PorgressHandle

        if (universe == null) {

            try {

                universe = loadUniverseModules(platformModules, getProperties().getSubModules());

            } catch (IOException e) {

                Util.err.notify(ErrorManager.INFORMATIONAL, e);

                return; // any warnings would probably be wrong anyway

            }

        }

        Set disabledClusters = new TreeSet();

        Set disabledModules = new TreeSet();

        Node[] clusters = getExplorerManager().getRootContext().getChildren().getNodes();

        for (int i = 0; i < clusters.length; i++) {

            if (clusters[i] instanceof Enabled) {

                Enabled e = (Enabled) clusters[i];

                if (!e.isEnabled()) {

                    disabledClusters.add(e.getName());

                } else {

                    Node[] modules = e.getChildren().getNodes();

                    for (int j = 0; j < modules.length; j++) {

                        if (modules[j] instanceof Enabled) {

                            Enabled m = (Enabled) modules[j];

                            if (!m.isEnabled()) {

                                disabledModules.add(m.getName());

                            }

                        }

                    }

                }

            }

        }

        final String[] warning = findWarning(universe, disabledClusters, disabledModules);

        EventQueue.invokeLater(new Runnable() {

            public void run() {

                if (warning != null) {

                    String key = warning[0];

                    String[] args = new String[warning.length - 1];

                    System.arraycopy(warning, 1, args, 0, args.length);

                    setWarning(NbBundle.getMessage(SuiteCustomizerLibraries.class, key, args));

                } else {

                    setWarning(null);

                }

            }

        });

/*

 *                 Sun Public License Notice

 *

 * The contents of this file are subject to the Sun Public License

 * Version 1.0 (the "License"). You may not use this file except in

 * compliance with the License. A copy of the License is available at

 * http://www.sun.com/

 *

 * The Original Code is NetBeans. The Initial Developer of the Original

 * Code is Sun Microsystems, Inc. Portions Copyright 1997-2006 Sun

 * Microsystems, Inc. All Rights Reserved.

 */

package org.netbeans.modules.apisupport.project.ui.customizer;

import java.io.File;

import java.util.Arrays;

import java.util.Collections;

import java.util.HashMap;

import java.util.HashSet;

import java.util.Iterator;

import java.util.Map;

import java.util.Set;

import java.util.jar.Manifest;

import org.netbeans.api.project.ProjectManager;

import org.netbeans.junit.NbTestCase;

import org.netbeans.modules.apisupport.project.EditableManifest;

import org.netbeans.modules.apisupport.project.ManifestManager;

import org.netbeans.modules.apisupport.project.NbModuleProject;

import org.netbeans.modules.apisupport.project.ProjectXMLManager;

import org.netbeans.modules.apisupport.project.TestBase;

import org.netbeans.modules.apisupport.project.Util;

import org.netbeans.modules.apisupport.project.suite.SuiteProject;

import org.netbeans.modules.apisupport.project.universe.LocalizedBundleInfo;

import org.netbeans.modules.apisupport.project.universe.NbPlatform;

import org.openide.modules.Dependency;

import org.openide.modules.SpecificationVersion;

/**

 * Tests module dependencies in a suite.

 * @author Jesse Glick

 */

public class SuiteCustomizerLibrariesTest extends NbTestCase {

    public SuiteCustomizerLibrariesTest(String name) {

        super(name);

    }

    private NbPlatform platform;

    private SuiteProject suite;

    protected void setUp() throws Exception {

        super.setUp();

        clearWorkDir();

        // PLATFORM SETUP

        TestBase.initializeBuildProperties(getWorkDir());

        File install = new File(getWorkDir(), "install");

        TestBase.makePlatform(install);

        // MODULE foo

        Manifest mani = new Manifest();

        mani.getMainAttributes().putValue(ManifestManager.OPENIDE_MODULE, "foo/1");

        mani.getMainAttributes().putValue(ManifestManager.OPENIDE_MODULE_SPECIFICATION_VERSION, "1.0");

        mani.getMainAttributes().putValue(ManifestManager.OPENIDE_MODULE_IMPLEMENTATION_VERSION, "foo-1");

        mani.getMainAttributes().putValue(ManifestManager.OPENIDE_MODULE_LOCALIZING_BUNDLE, "foo/Bundle.properties");

        mani.getMainAttributes().putValue(ManifestManager.OPENIDE_MODULE_PROVIDES, "tok1, tok1a");

        Map/*<String,String>*/ contents = new HashMap();

        contents.put("foo/Bundle.properties", "OpenIDE-Module-Name=Foo Module");

        TestBase.createJar(new File(new File(new File(install, "somecluster"), "modules"), "foo.jar"), contents, mani);

        // MODULE bar

        mani = new Manifest();

        mani.getMainAttributes().putValue(ManifestManager.OPENIDE_MODULE, "bar");

        mani.getMainAttributes().putValue(ManifestManager.OPENIDE_MODULE_REQUIRES, "tok1");

        TestBase.createJar(new File(new File(new File(install, "somecluster"), "modules"), "bar.jar"), Collections.EMPTY_MAP, mani);

        // MODULE baz

        mani = new Manifest();

        mani.getMainAttributes().putValue(ManifestManager.OPENIDE_MODULE, "baz");

        mani.getMainAttributes().putValue("OpenIDE-Module-Module-Dependencies", "foo/1 > 1.0");

        TestBase.createJar(new File(new File(new File(install, "anothercluster"), "modules"), "baz.jar"), Collections.EMPTY_MAP, mani);

        platform = NbPlatform.addPlatform("custom", install, "custom");

        // SUITE setup

        suite = TestBase.generateSuite(getWorkDir(), "suite", "custom");

        // MODULE org.example.module1

        NbModuleProject module = TestBase.generateSuiteComponent(suite, "module1");

        EditableManifest em = Util.loadManifest(module.getManifestFile());

        em.setAttribute(ManifestManager.OPENIDE_MODULE, "org.example.module1/2", null);

        em.setAttribute(ManifestManager.OPENIDE_MODULE_SPECIFICATION_VERSION, "2.0", null);

        em.setAttribute(ManifestManager.OPENIDE_MODULE_PROVIDES, "tok2", null);

        Util.storeManifest(module.getManifestFile(), em);

        LocalizedBundleInfo lbinfo = ((LocalizedBundleInfo.Provider) module.getLookup().lookup(LocalizedBundleInfo.Provider.class)).getLocalizedBundleInfo();

        lbinfo.setDisplayName("Module One");

        lbinfo.store();

        // MODULE org.example.module2

        module = TestBase.generateSuiteComponent(suite, "module2");

        em = Util.loadManifest(module.getManifestFile());

        em.removeAttribute(ManifestManager.OPENIDE_MODULE_SPECIFICATION_VERSION, null);

        em.setAttribute(ManifestManager.OPENIDE_MODULE_REQUIRES, "tok2", null);

        Util.storeManifest(module.getManifestFile(), em);

        lbinfo = ((LocalizedBundleInfo.Provider) module.getLookup().lookup(LocalizedBundleInfo.Provider.class)).getLocalizedBundleInfo();

        lbinfo.setDisplayName("Module Two");

        lbinfo.store();

        // MODULE org.example.module3

        module = TestBase.generateSuiteComponent(suite, "module3");

        ProjectXMLManager xml = new ProjectXMLManager(module.getHelper());

        xml.addDependency(new ModuleDependency(module.getModuleList().getEntry("org.example.module2")));

        xml.addDependency(new ModuleDependency(module.getModuleList().getEntry("bar")));

        // XXX need richer deps

        ProjectManager.getDefault().saveAllProjects();

    }

    public void testUniverseModules() throws Exception { // #65924

        Set/*<UniverseModule>*/ modules = SuiteCustomizerLibraries.loadUniverseModules(platform.getModules(), SuiteUtils.getSubProjects(suite));

        Map/*<String,UniverseModule>*/ modulesByName = new HashMap();

        for (Iterator it = modules.iterator(); it.hasNext(); ) {

            SuiteCustomizerLibraries.UniverseModule m = (SuiteCustomizerLibraries.UniverseModule) it.next();

            modulesByName.put(m.getCodeNameBase(), m);

        }

        assertEquals(modules.size(), modulesByName.size());

        SuiteCustomizerLibraries.UniverseModule m = (SuiteCustomizerLibraries.UniverseModule) modulesByName.get("core");

        assertNotNull(m);

        // core.jar is just a dummy JAR, nothing interesting to test

        m = (SuiteCustomizerLibraries.UniverseModule) modulesByName.get("foo");

        assertNotNull(m);

        assertEquals("somecluster", m.getCluster());

        assertEquals("Foo Module", m.getDisplayName());

        assertEquals(1, m.getReleaseVersion());

        assertEquals(new SpecificationVersion("1.0"), m.getSpecificationVersion());

        assertEquals("foo-1", m.getImplementationVersion());

        assertEquals(new HashSet(Arrays.asList(new String[] {"tok1", "tok1a"})), m.getProvidedTokens());

        assertEquals(Collections.EMPTY_SET, m.getRequiredTokens());

        assertEquals(Collections.EMPTY_SET, m.getModuleDependencies());

        m = (SuiteCustomizerLibraries.UniverseModule) modulesByName.get("bar");

        assertNotNull(m);

        assertEquals(Collections.EMPTY_SET, m.getProvidedTokens());

        assertEquals(Collections.singleton("tok1"), m.getRequiredTokens());

        m = (SuiteCustomizerLibraries.UniverseModule) modulesByName.get("baz");

        assertNotNull(m);

        assertEquals(Dependency.create(Dependency.TYPE_MODULE, "foo/1 > 1.0"), m.getModuleDependencies());

        m = (SuiteCustomizerLibraries.UniverseModule) modulesByName.get("org.example.module1");

        assertNotNull(m);

        assertNull(m.getCluster());

        assertEquals("Module One", m.getDisplayName());

        assertEquals(2, m.getReleaseVersion());

        assertEquals(new SpecificationVersion("2.0"), m.getSpecificationVersion());

        assertNull(m.getImplementationVersion());

        assertEquals(Collections.singleton("tok2"), m.getProvidedTokens());

        assertEquals(Collections.EMPTY_SET, m.getRequiredTokens());

        assertEquals(Collections.EMPTY_SET, m.getModuleDependencies());

        m = (SuiteCustomizerLibraries.UniverseModule) modulesByName.get("org.example.module2");

        assertNotNull(m);

        assertEquals(-1, m.getReleaseVersion());

        assertNull(m.getSpecificationVersion());

        assertNull(m.getImplementationVersion());

        assertEquals(Collections.EMPTY_SET, m.getProvidedTokens());

        assertEquals(Collections.singleton("tok2"), m.getRequiredTokens());

        m = (SuiteCustomizerLibraries.UniverseModule) modulesByName.get("org.example.module3");

        assertNotNull(m);

        assertEquals(Dependency.create(Dependency.TYPE_MODULE, "org.example.module2, bar"), m.getModuleDependencies());

    }

    public void testDependencyWarnings() throws Exception { // #65924

        // XXX

    }

}