/**

 * Copyright (c) 2010 Symbian Foundation and/or its subsidiary(-ies).

 * All rights reserved.

 * This component and the accompanying materials are made available

 * under the terms of the License "Eclipse Public License v1.0"

 * which accompanies this distribution, and is available

 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

 *

 * Initial Contributors:

 * Symbian Foundation - initial contribution.

 * Contributors:

 * Description:

 * Overview:

 * Details:

 * Platforms/Drives/Compatibility:

 * Assumptions/Requirement/Pre-requisites:

 * Failures and causes:

 */

package org.symbian.tools.tmw.core.internal.runtimes;

import java.util.Arrays;

import java.util.Collection;

import java.util.Collections;

import java.util.HashMap;

import java.util.HashSet;

import java.util.LinkedList;

import java.util.Map;

import java.util.Set;

import org.eclipse.core.runtime.CoreException;

import org.eclipse.core.runtime.IConfigurationElement;

import org.eclipse.core.runtime.Platform;

import org.eclipse.wst.common.project.facet.core.IFacetedProject;

import org.eclipse.wst.common.project.facet.core.IProjectFacetVersion;

import org.eclipse.wst.common.project.facet.core.IVersion;

import org.eclipse.wst.common.project.facet.core.IVersionExpr;

import org.eclipse.wst.common.project.facet.core.util.internal.VersionExpr;

import org.eclipse.wst.common.project.facet.core.util.internal.Versionable;

import org.eclipse.wst.jsdt.core.IIncludePathEntry;

import org.symbian.tools.tmw.core.TMWCore;

import org.symbian.tools.tmw.core.internal.projects.LazyIncludePathProvider;

import org.symbian.tools.tmw.core.internal.projects.StaticIncludePathProvider;

import org.symbian.tools.tmw.core.projects.IFacetIncludePathProvider;

import org.symbian.tools.tmw.core.projects.ITMWProject;

import org.symbian.tools.tmw.core.runtimes.IMobileWebRuntime;

@SuppressWarnings("restriction")

public class RuntimeClasspathManager {

    private static final class VersionedEntry<T> {

        protected final IVersionExpr versionExpression;

        protected final T entry;

        public VersionedEntry(String versionExpression, T entry) {

            if (versionExpression == null) {

                this.versionExpression = null;

            } else {

                IVersionExpr expr;

                try {

                    expr = new VersionExpr<Version>(new VersionableObject(), versionExpression, null);

                } catch (CoreException e) {

                    expr = null;

                    TMWCore.log(null, e);

                }

                this.versionExpression = expr;

            }

            this.entry = entry;

        }

        public boolean matches(String version) {

            if (versionExpression == null) { // Any version

                return true;

            }

            if (version == null) { // Unspecified

                return false;

            }

            return versionExpression.check(new Version(version));

        }

    }

    private static final class VersionableObject extends Versionable<Version> {

        @Override

        public String getPluginId() {

            return TMWCore.PLUGIN_ID;

        }

        @Override

        public String createVersionNotFoundErrMsg(String verstr) {

            return "Version not found";

        }

    }

    private static final class Version implements IVersion {

        private final String version;

        public Version(String version) {

            this.version = version;

        }

        public int compareTo(Object o) {

            return version.compareTo(((IVersion) o).getVersionString());

        }

        public String getVersionString() {

            return version;

        }

    }

    private final Map<String, Collection<VersionedEntry<Map<String, Collection<VersionedEntry<IFacetIncludePathProvider[]>>>>>> providers = new HashMap<String, Collection<VersionedEntry<Map<String, Collection<VersionedEntry<IFacetIncludePathProvider[]>>>>>>();

    private final boolean ready = false;

    public IIncludePathEntry[] getProjectClasspathEntries(IFacetedProject project) {

        collectProviders();

        final ITMWProject p = TMWCore.create(project.getProject());

        if (p != null) {

            final IMobileWebRuntime runtime = p.getTargetRuntime();

            final Map<String, Collection<VersionedEntry<IFacetIncludePathProvider[]>>> facetToEntry;

            if (runtime != null) {

                facetToEntry = join(getMatchingEntries(runtime.getId(), runtime.getVersion(), providers));

            } else {

                facetToEntry = join(getMatchingEntries(null, null, providers));

            }

            final Collection<IFacetIncludePathProvider[]> entries = getMatchingEntries(null, null, facetToEntry);

            final Set<IProjectFacetVersion> facets = project.getProjectFacets();

            for (IProjectFacetVersion facet : facets) {

                entries.addAll(getMatchingEntries(facet.getProjectFacet().getId(), facet.getVersionString(),

                        facetToEntry));

            }

            final Collection<IIncludePathEntry> pathEntries = new HashSet<IIncludePathEntry>();

            for (IFacetIncludePathProvider[] providers : entries) {

                for (IFacetIncludePathProvider provider : providers) {

                    pathEntries.addAll(Arrays.asList(provider.getEntries(p)));

                }

            }

            return pathEntries.toArray(new IIncludePathEntry[pathEntries.size()]);

        }

        return new IIncludePathEntry[0];

    }

    @SuppressWarnings({ "rawtypes", "unchecked" })

    private synchronized void collectProviders() {

        if (!ready) {

            final IConfigurationElement[] elements = Platform.getExtensionRegistry().getConfigurationElementsFor(

                    TMWCore.PLUGIN_ID, "runtimeIncludePath");

            final Map<String, Collection<VersionedEntry<IFacetIncludePathProvider[]>>> entries = collectFaceletEntries(elements);

            final VersionedEntry<Map<String, Collection<VersionedEntry<IFacetIncludePathProvider[]>>>> entry = new VersionedEntry(

                    null, entries);

            providers.put(null, Collections.singleton(entry));

            for (IConfigurationElement element : elements) {

                if ("runtime-include-path".equals(element.getName())) {

                    final String id = element.getAttribute("id");

                    Collection<VersionedEntry<Map<String, Collection<VersionedEntry<IFacetIncludePathProvider[]>>>>> versions = providers

                            .get(id);

                    if (versions == null) {

                        versions = new LinkedList<RuntimeClasspathManager.VersionedEntry<Map<String, Collection<VersionedEntry<IFacetIncludePathProvider[]>>>>>();

                        providers.put(id, versions);

                    }

                    final Map<String, Collection<VersionedEntry<IFacetIncludePathProvider[]>>> facetProviders = new HashMap<String, Collection<VersionedEntry<IFacetIncludePathProvider[]>>>();

                    final IFacetIncludePathProvider[] collection = collectProviders(element.getChildren());

                    final VersionedEntry<IFacetIncludePathProvider[]> ent = new VersionedEntry(null, collection);

                    facetProviders.put(null, Collections.singleton(ent));

                    facetProviders.putAll(collectFaceletEntries(element.getChildren()));

                    final VersionedEntry<Map<String, Collection<VersionedEntry<IFacetIncludePathProvider[]>>>> ver = new VersionedEntry<Map<String, Collection<VersionedEntry<IFacetIncludePathProvider[]>>>>(

                            element.getAttribute("version"), facetProviders);

                    versions.add(ver);

                }

            }

        }

    }

    private IFacetIncludePathProvider[] collectProviders(IConfigurationElement[] children) {

        final Collection<IFacetIncludePathProvider> providers = new LinkedList<IFacetIncludePathProvider>();

        for (IConfigurationElement element : children) {

            if ("include-path-entry".equals(element.getName())) {

                providers.add(new StaticIncludePathProvider(element));

            } else if ("include-path-provider".equals(element.getName())) {

                providers.add(new LazyIncludePathProvider(element));

            }

        }

        return providers.toArray(new IFacetIncludePathProvider[providers.size()]);

    }

    public Map<String, Collection<VersionedEntry<IFacetIncludePathProvider[]>>> collectFaceletEntries(

            IConfigurationElement[] elements) {

        final Map<String, Collection<VersionedEntry<IFacetIncludePathProvider[]>>> faceletsToProviders = new HashMap<String, Collection<VersionedEntry<IFacetIncludePathProvider[]>>>();

        for (IConfigurationElement element : elements) {

            if ("facet-include-path".equals(element.getName())) {

                final IFacetIncludePathProvider[] providers = collectProviders(element.getChildren());

                final VersionedEntry<IFacetIncludePathProvider[]> versionedEntry = new VersionedEntry<IFacetIncludePathProvider[]>(

                        element.getAttribute("version"), providers);

                final String id = element.getAttribute("facelet-id");

                Collection<VersionedEntry<IFacetIncludePathProvider[]>> provs = faceletsToProviders.get(id);

                if (provs == null) {

                    provs = new LinkedList<RuntimeClasspathManager.VersionedEntry<IFacetIncludePathProvider[]>>();

                    faceletsToProviders.put(id, provs);

                }

                provs.add(versionedEntry);

            }

        }

        return faceletsToProviders;

    }

    private <T, V> Map<T, Collection<V>> join(Collection<Map<T, Collection<V>>> maps) {

        final Map<T, Collection<V>> res = new HashMap<T, Collection<V>>();

        for (Map<T, Collection<V>> map : maps) {

            for (Map.Entry<T, Collection<V>> entry : map.entrySet()) {

                if (res.containsKey(entry.getKey())) {

                    res.get(entry.getKey()).addAll(entry.getValue());

                } else {

                    res.put(entry.getKey(), new LinkedList<V>(entry.getValue()));

                }

            }

        }

        return res;

    }

    private <T> Collection<T> getMatchingEntries(String id, String version,

            Map<String, Collection<VersionedEntry<T>>> map) {

        final Collection<VersionedEntry<T>> entries = new LinkedList<VersionedEntry<T>>();

        Collection<VersionedEntry<T>> versionedEntries = map.get(null);

        if (versionedEntries != null) {

            entries.addAll(versionedEntries);

        }

        if (id != null) {

            versionedEntries = map.get(id);

            if (versionedEntries != null) {

                entries.addAll(versionedEntries);

            }

        }

        final Collection<T> res = new LinkedList<T>();

        for (VersionedEntry<T> versionedEntry : entries) {

            if (versionedEntry.matches(version)) {

                res.add(versionedEntry.entry);

            }

        }

        return res;

    }

}