/*
 * 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.tuscany.sca.provision;

import java.lang.reflect.Field;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

import javax.xml.namespace.QName;

import org.apache.maven.artifact.Artifact;
import org.apache.maven.artifact.metadata.ArtifactMetadataSource;
import org.apache.maven.artifact.repository.ArtifactRepository;
import org.apache.maven.artifact.resolver.ArtifactNotFoundException;
import org.apache.maven.artifact.resolver.ArtifactResolutionException;
import org.apache.maven.artifact.resolver.ArtifactResolutionResult;
import org.apache.maven.artifact.resolver.ArtifactResolver;
import org.apache.maven.embedder.MavenEmbedder;
import org.apache.maven.project.MavenProject;
import org.apache.maven.shared.runtime.DefaultMavenRuntime;
import org.apache.maven.shared.runtime.MavenRuntime;
import org.apache.maven.shared.runtime.MavenRuntimeException;
import org.apache.tuscany.sca.core.DefaultExtensionPointRegistry;
import org.apache.tuscany.sca.core.ExtensionPointRegistry;
import org.apache.tuscany.sca.extensibility.ServiceDeclaration;
import org.apache.tuscany.sca.extensibility.ServiceDeclarationParser;
import org.apache.tuscany.sca.extensibility.ServiceDiscovery;
import org.codehaus.plexus.embed.Embedder;

/**
 * 
 */
public class ExtensionIntrospector {
    private ExtensionPointRegistry registry;
    private boolean loaded;
    private boolean offline;
    private MavenRuntime mavenRuntime = new DefaultMavenRuntime();

    private MavenEmbedder embedder;
    private ArtifactResolver resolver;
    private Embedder internalEmbedder;
    ArtifactMetadataSource artifactMetadataSource;
    private ArtifactRepository remoteRepo;

    // Key: java model type
    private Map<String, MavenProject> modules = new HashMap<String, MavenProject>();

    // Key: extension categories
    private Map<String, Collection<String>> types = new HashMap<String, Collection<String>>();

    // Key: java model type
    private Map<String, QName> qnames = new HashMap<String, QName>();

    /**
     * @param registry
     */
    public ExtensionIntrospector(ExtensionPointRegistry registry) {
        super();
        this.registry = (registry == null) ? new DefaultExtensionPointRegistry() : registry;
    }

    public MavenProject findModule(String extensionType) {
        return getModules().get(extensionType);
    }

    public Map<String, MavenProject> getModules() {
        loadProviderFactories();
        return modules;
    }

    public Map<String, QName> getExtensionTypes() {
        return qnames;
    }

    /**
     * Load provider factories declared under META-INF/services.
     * @param registry
     */
    private synchronized void loadProviderFactories() {
        if (loaded)
            return;

        this.qnames.putAll(mapJavaTypeToQName());

        addExtensions("Bindings", "org.apache.tuscany.sca.provider.BindingProviderFactory");
        addExtensions("Implementations", "org.apache.tuscany.sca.provider.ImplementationProviderFactory");
        addExtensions("Policies", "org.apache.tuscany.sca.provider.PolicyProviderFactory");
        addExtensions("Wire Formats", "org.apache.tuscany.sca.provider.WireFormatProviderFactory");
        addExtensions("Operation Selectors", "org.apache.tuscany.sca.provider.OperationSelectorProviderFactory");

        loaded = true;
    }

    private void addExtensions(String label, String name) {
        Set<String> models = new HashSet<String>();
        for (ServiceDeclaration sd : discover(name)) {
            MavenProject project = null;
            try {
                project = mavenRuntime.getProject(sd.getLocation());
            } catch (MavenRuntimeException e) {
                e.printStackTrace();
            }
            if (project != null) {
                String model = sd.getAttributes().get("model");
                models.add(model);
                modules.put(model, project);
            }
        }
        types.put(label, models);
    }

    public Map<String, QName> mapJavaTypeToQName() {
        Collection<ServiceDeclaration> processors =
            discover("org.apache.tuscany.sca.contribution.processor.StAXArtifactProcessor");
        Map<String, QName> qnames = new HashMap<String, QName>();
        for (ServiceDeclaration sd : processors) {
            String qname = sd.getAttributes().get("qname");
            String model = sd.getAttributes().get("model");
            qnames.put(model, ServiceDeclarationParser.getQName(qname));
        }
        return qnames;
    }

    /**
     * Load provider factories declared under META-INF/services.
     * @param registry
     * @param factoryClass
     * @return
     */
    private Collection<ServiceDeclaration> discover(String name) {

        // Get the provider factory service declarations
        Collection<ServiceDeclaration> factoryDeclarations;
        ServiceDiscovery serviceDiscovery = registry.getServiceDiscovery();
        try {
            factoryDeclarations = serviceDiscovery.getServiceDeclarations(name, false);
        } catch (Exception e) {
            throw new IllegalStateException(e);
        }

        return factoryDeclarations;
    }

    public void start() {
        try {
            embedder = new MavenEmbedder();
            embedder.setOffline(offline);
            embedder.setClassLoader(Thread.currentThread().getContextClassLoader());
            embedder.start();

            resolver = getField(embedder, "artifactResolver");
            internalEmbedder = getField(embedder, "embedder");

            artifactMetadataSource =
                (ArtifactMetadataSource)internalEmbedder
                    .lookup("org.apache.maven.artifact.metadata.ArtifactMetadataSource");

            remoteRepo = embedder.createRepository("http://repo2.maven.org/maven2/", "maven");
        } catch (Throwable e) {
            throw new IllegalStateException(e);
        }
    }

    public void stop() {
        try {
            if (embedder != null) {
                internalEmbedder.release(resolver);
                internalEmbedder.release(artifactMetadataSource);
                embedder.stop();
                embedder = null;
            }
        } catch (Throwable e) {
            throw new IllegalStateException(e);
        }

    }

    public Map<String, Collection<Artifact>> getDependencies(String args[]) throws ArtifactResolutionException,
        ArtifactNotFoundException {
        Map<String, Collection<Artifact>> artifacts = new HashMap<String, Collection<Artifact>>();

        Artifact originatingArtifact = embedder.createArtifact("dummy", "dummy", "1.0", Artifact.SCOPE_RUNTIME, "jar");

        for (Map.Entry<String, MavenProject> e : getModules().entrySet()) {
            String type = e.getKey();
            type = getType(type);
            boolean matched = (args.length == 0);
            for (String arg : args) {
                if (type.contains(arg)) {
                    matched = true;
                    break;
                }
            }
            if (!matched) {
                continue;
            }
            // System.out.println(type + ": " + e.getValue());

            MavenProject project = e.getValue();
            Artifact artifact =
                embedder.createArtifact(project.getGroupId(),
                                        project.getArtifactId(),
                                        project.getVersion(),
                                        Artifact.SCOPE_COMPILE,
                                        project.getPackaging());

            ArtifactResolutionResult result =
                resolver.resolveTransitively(Collections.singleton(artifact), originatingArtifact, embedder
                    .getLocalRepository(), Arrays.asList(remoteRepo), artifactMetadataSource, null);

            // System.out.println("*** " + artifact);
            artifacts.put(type, result.getArtifacts());
        }
        return artifacts;
    }

    private String getType(String type) {
        QName qname = qnames.get(type);
        if (qname != null) {
            type = qname.toString();
        }
        return type;
    }

    private static <T> T getField(Object object, String name) throws Exception {
        Field field = object.getClass().getDeclaredField(name);
        field.setAccessible(true);
        return (T)field.get(object);
    }

    public String toJSON(Map<String, Collection<Artifact>> map) {
        StringBuffer json = new StringBuffer("{\n");
        json.append("  label: \"name\",\n");
        json.append("  items: [\n");
        int i = 0;
        for (Map.Entry<String, Collection<String>> category : types.entrySet()) {
            json.append("{"); // {
            json.append("name: ").append("\"").append(category.getKey()).append("\", \n"); // name: "category",

            json.append("  types: [\n");
            int j = 0;
            for (String model : category.getValue()) {
                String key = getType(model);
                Collection<Artifact> artifacts = map.get(key);
                json.append("    {"); // {
                json.append("name: ").append("\"").append(key).append("\", \n"); // type: "type",
                json.append("     artifacts: [\n");
                int k = 0;
                for (Artifact a : artifacts) {
                    json.append("      {");
                    json.append("name: \"").append(a.toString()).append("\", ");
                    json.append("groupId: \"").append(a.getGroupId()).append("\", ");
                    json.append("artifactId: \"").append(a.getArtifactId()).append("\", ");
                    json.append("version: \"").append(a.getVersion()).append("\", ");
                    json.append("scope: \"").append(a.getScope()).append("\"");
                    if (k == artifacts.size() - 1) {
                        json.append("}\n");
                    } else {
                        json.append("}, \n");
                    }
                    k++;
                }
                json.append("    ]\n"); // ]

                if (j == map.size() - 1) {
                    json.append("  }\n");
                } else {
                    json.append("  }, \n"); // },
                }
                j++;
            }
            json.append("]\n");
            if (i == types.size() - 1) {
                json.append("}");
            } else {
                json.append("},");
            }
            i++;
        }
        json.append("]\n");
        json.append("}\n");
        return json.toString();
    }

    public boolean isOffline() {
        return offline;
    }

    public void setOffline(boolean offline) {
        this.offline = offline;
    }

    public static void main(String args[]) throws Exception {
        String json = generateDojoData(args);
        System.out.println(json);
    }

    public static String generateDojoData(String[] args) throws Exception {
        ExtensionIntrospector introspector = new ExtensionIntrospector(null);
        introspector.setOffline("true".equalsIgnoreCase(System.getProperty("offline")));
        introspector.start();
        Map<String, Collection<Artifact>> map = introspector.getDependencies(args);
        /*
        for (Map.Entry<String, Collection<Artifact>> entry : map.entrySet()) {
            System.out.println("\n------------------------------------------------------------------------");
            System.out.println(entry.getKey());
            System.out.println("------------------------------------------------------------------------");
            for (Artifact a : entry.getValue()) {
                System.out.println(a);
            }
            System.out.println("------------------------------------------------------------------------");
        }
        */
        String json = introspector.toJSON(map);
        introspector.stop();
        return json;
    }

}