/*
 * 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.karaf.eik.felix;

import org.apache.karaf.eik.felix.internal.BundleEntry;
import org.apache.karaf.eik.felix.internal.FelixLaunchHelper;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
import java.util.StringTokenizer;

import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.FileLocator;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.variables.IStringVariableManager;
import org.eclipse.core.variables.VariablesPlugin;
import org.eclipse.debug.core.ILaunch;
import org.eclipse.debug.core.ILaunchConfiguration;
import org.eclipse.jdt.core.IClasspathEntry;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.IPackageFragmentRoot;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.launching.ExecutionArguments;
import org.eclipse.jdt.launching.IJavaLaunchConfigurationConstants;
import org.eclipse.pde.core.plugin.IPluginModelBase;
import org.eclipse.pde.core.plugin.PluginRegistry;
import org.eclipse.pde.ui.launcher.AbstractPDELaunchConfiguration;
import org.eclipse.pde.ui.launcher.IPDELauncherConstants;
import org.osgi.framework.Bundle;

public class FelixLaunchConfiguration extends AbstractPDELaunchConfiguration {

    public static final String FELIX_FRAMEWORK_LAUNCHER = "org.apache.felix.main";

    public static final String FELIX_FRAMEWORK = "org.apache.felix.framework";

    public static final String FELIX_SYSTEM_PROPERTIES_KEY = "felix.system.properties";

    public static final String FELIX_CONFIG_PROPERTIES_KEY = "felix.config.properties";

    public static final String FELIX_AUTO_START_PREFIX = "felix.auto.start.";

    public static final String FELIX_AUTO_INSTALL_PREFIX = "felix.auto.install.";

    public static final String FELIX_CONFIG_PROPERTIES_FILE = "config.properties";

    public static final String FELIX_SYSTEM_PROPERTIES_FILE = "system.properties";

    public static final int DEFAULT_START_LEVEL = 4;

    public static final boolean DEFAULT_AUTOSTART = true;

    /**
     * Implementation of join using a {@link StringBuffer}
     *
     * @param items
     *            the {@link Collection} of items that will be joined together
     * @param glue
     *            the string to act as glue in the concatenation
     * @return the concatenation of the specified items
     */
    public static String join(Collection<String> items, String glue) {
        final StringBuffer buffer = new StringBuffer();
        for (String s : items) {
            if (buffer.length() > 0) {
                buffer.append(glue);
            }

            buffer.append(s);
        }

        return buffer.toString();
    }

    /**
     * Gets the path to the specified bundle in the following manner:<br>
     * <br>
     * <ol>
     * <li>If the bundle is found in the Plug-in Registry and is not a workspace
     * resource, return the path to the bundle</li>
     * <li>If the bundle is in the Plug-in Registry but is a workspace resource,
     * return the path to the path to the output location that contains the
     * package specified ({@code project/output folder})</li>
     * <li>If the bundle is not found in the Plug-in Registry then look for it
     * in the OSGi platform</li>
     * </ol>
     *
     * @param bundleName
     *            the symbolic name of the bundle
     * @param packageName
     *            the name of the package used to locate the output folder
     * @return a fully qualified path to the requested bundle or null if it does
     *         not exist
     * @throws CoreException
     */
    private static String getBundlePath(String bundleName, String packageName) throws CoreException {
        final IPluginModelBase model = PluginRegistry.findModel(bundleName);
        if (model != null) {
            final IResource resource = model.getUnderlyingResource();

            if (!isWorkspaceModel(model)) {
                return model.getInstallLocation();
            }

            final IProject project = resource.getProject();
            if (project.hasNature(JavaCore.NATURE_ID)) {
                final IJavaProject jProject = JavaCore.create(project);
                final IClasspathEntry[] entries = jProject.getRawClasspath();

                for (int i = 0; i < entries.length; i++) {
                    final int kind = entries[i].getEntryKind();
                    if (kind == IClasspathEntry.CPE_SOURCE || kind == IClasspathEntry.CPE_LIBRARY) {
                        final IPackageFragmentRoot[] roots = jProject.findPackageFragmentRoots(entries[i]);

                        for (int j = 0; j < roots.length; j++) {
                            if (roots[j].getPackageFragment(packageName).exists()) {
                                // if source folder, find the output folder
                                if (kind == IClasspathEntry.CPE_SOURCE) {
                                    IPath path = entries[i].getOutputLocation();
                                    if (path == null) {
                                        path = jProject.getOutputLocation();
                                    }

                                    path = path.removeFirstSegments(1);

                                    return project.getLocation().append(path).toOSString();
                                }
                                // else if is a library jar, then get the
                                // location of the jar itself
                                final IResource jar = roots[j].getResource();
                                if (jar != null) {
                                    return jar.getLocation().toOSString();
                                }
                            }
                        }
                    }
                }
            }
        }

        final Bundle bundle = Platform.getBundle(bundleName);
        if (bundle != null) {
            try {
                URL url = FileLocator.resolve(bundle.getEntry("/")); //$NON-NLS-1$
                url = FileLocator.toFileURL(url);
                String path = url.getFile();
                if (path.startsWith("file:")) { //$NON-NLS-1$
                    path = path.substring(5);
                }

                path = new File(path).getAbsolutePath();

                if (path.endsWith("!")) { //$NON-NLS-1$
                    path = path.substring(0, path.length() - 1);
                }

                return path;
            } catch (IOException e) {
            }
        }

        return null;
    }

    /**
     * Uses the Eclipse Variables plugin to perform string substitution on the
     * input string
     *
     * @param text
     *            the input string that potentially contains variables that need
     *            to be resolved
     * @return the fully interpolated string
     * @throws CoreException
     */
    private static String getSubstitutedString(String text) throws CoreException {
        if (text == null) {
            return ""; //$NON-NLS-1$
        }

        final IStringVariableManager mgr = VariablesPlugin.getDefault().getStringVariableManager();
        return mgr.performStringSubstitution(text);
    }

    /**
     * Determines if the {@link IPluginModelBase} is a workspace resource
     *
     * @param model
     *            the {@code IPluginModelBase} to test
     * @return true if it is a workspace resource, false otherwise
     */
    private static boolean isWorkspaceModel(IPluginModelBase model) {
        return (model.getUnderlyingResource() != null);
    }

    /**
     * Helper method to write a properties file to the specified filename
     *
     * @param filename
     *            the fully qualfied filename
     * @param props
     *            the {@link Properties} to be stored
     * @throws CoreException
     */
    private static void writeProperties(String filename, Properties props) throws CoreException {
        try {
            final OutputStream out = new FileOutputStream(new File(filename));
            props.store(out, FelixLaunchConfiguration.class.getName());
            out.close();
        } catch (IOException e) {

        }
    }

    // used to generate the dev classpath entries
    // key is bundle ID, value is a model
    protected Map<String, IPluginModelBase> fAllBundles;

    // key is a model, value is startLevel:autoStart
    private Map<IPluginModelBase, String> fModels;

    /*
     * Apache Felix requires that the launcher and the Felix Framework be on the
     * initial classpath.
     *
     * @see
     * org.eclipse.pde.ui.launcher.AbstractPDELaunchConfiguration#getClasspath
     * (org.eclipse.debug.core.ILaunchConfiguration)
     */
    @Override
    public String[] getClasspath(ILaunchConfiguration configuration) throws CoreException {
        final String felixLauncherPath = getBundlePath(FELIX_FRAMEWORK_LAUNCHER, FELIX_FRAMEWORK_LAUNCHER);
        if (felixLauncherPath == null) {

        }

        final String felixFrameworkPath = getBundlePath(FELIX_FRAMEWORK, FELIX_FRAMEWORK);
        if (felixFrameworkPath == null) {

        }

        final List<String> entries = new ArrayList<String>();
        entries.add(felixLauncherPath);
        entries.add(felixFrameworkPath);

        /*
         * Add any boostrap entries provided by the user
         */
        final String bootstrap = configuration.getAttribute(IPDELauncherConstants.BOOTSTRAP_ENTRIES, ""); //$NON-NLS-1$
        final StringTokenizer tok = new StringTokenizer(getSubstitutedString(bootstrap), ","); //$NON-NLS-1$
        while (tok.hasMoreTokens()) {
            entries.add(tok.nextToken().trim());
        }

        return entries.toArray(new String[entries.size()]);
    }

    @Override
    public String getMainClass() {
        return "org.apache.felix.main.Main"; //$NON-NLS-1$
    }

    /*
     * Gets any additional program arguments from the user and writes all Felix
     * configuration files
     *
     * @seeorg.eclipse.pde.ui.launcher.AbstractPDELaunchConfiguration#
     * getProgramArguments(org.eclipse.debug.core.ILaunchConfiguration)
     */
    @Override
    public String[] getProgramArguments(ILaunchConfiguration configuration) throws CoreException {
        String args = configuration.getAttribute(IJavaLaunchConfigurationConstants.ATTR_PROGRAM_ARGUMENTS, (String) null);

        args = args == null ? "" : getSubstitutedString(args); //$NON-NLS-1$

        writeConfigProperties(configuration);
        writeSystemProperties(configuration);
        writeStartupProperties(configuration);

        return new ExecutionArguments("", args).getProgramArgumentsArray(); //$NON-NLS-1$
    }

    /*
     * Adds the base VM arguments and root system properties used to load the
     * Felix configuration files.
     *
     * @see
     * org.eclipse.pde.ui.launcher.AbstractPDELaunchConfiguration#getVMArguments
     * (org.eclipse.debug.core.ILaunchConfiguration)
     */
    @Override
    public String[] getVMArguments(ILaunchConfiguration configuration) throws CoreException {
        String args = configuration.getAttribute(IJavaLaunchConfigurationConstants.ATTR_VM_ARGUMENTS, (String) null);
        args = args == null ? "" : getSubstitutedString(args); //$NON-NLS-1$

        final IPath configProperties = new Path(new File(getConfigDir(configuration), FELIX_CONFIG_PROPERTIES_FILE).getAbsolutePath());
        final IPath systemProperties = new Path(new File(getConfigDir(configuration), FELIX_SYSTEM_PROPERTIES_FILE).getAbsolutePath());

        final String[] vmArgs = new ExecutionArguments("", args).getVMArgumentsArray(); //$NON-NLS-1$
        
        // arraycopy works for JDK 5 & 6
        final String[] newVmArgs = new String[vmArgs.length + 2];
        System.arraycopy(vmArgs, 0, newVmArgs, 0, vmArgs.length);
        
        try {
            // TODO: Properly merge arguments in
            newVmArgs[vmArgs.length] = "-D" + FELIX_CONFIG_PROPERTIES_KEY + "=" + configProperties.toFile().toURI().toURL();
            newVmArgs[vmArgs.length + 1] = "-D" + FELIX_SYSTEM_PROPERTIES_KEY + "=" + systemProperties.toFile().toURI().toURL();
        } catch (MalformedURLException e) {

        }

        return newVmArgs;
    }

    /**
     * Writes out the configuration properties including bundle start and
     * install values
     *
     * @param configuration
     *            the launch configuration
     * @throws CoreException
     */
    private void writeConfigProperties(ILaunchConfiguration configuration) throws CoreException {
        final File f = new File(getConfigDir(configuration), FELIX_CONFIG_PROPERTIES_FILE);

        final boolean defaultAutostart = configuration.getAttribute(IPDELauncherConstants.DEFAULT_AUTO_START, DEFAULT_AUTOSTART);
        final int defaultStart = configuration.getAttribute(IPDELauncherConstants.DEFAULT_START_LEVEL, DEFAULT_START_LEVEL);

        final Properties properties = new Properties();

        properties.put("osgi.bundles.defaultStartLevel", Integer.toString(defaultStart)); //$NON-NLS-1$
        properties.put("org.osgi.framework.startlevel.beginning", Integer.toString(defaultStart)); //$NON-NLS-1$

        final Map<String, List<String>> startEntries = new HashMap<String, List<String>>();
        final Map<String, List<String>> installEntries = new HashMap<String, List<String>>();

        for (IPluginModelBase model : fModels.keySet()) {
            final String startString = fModels.get(model);

            final int colonPos = startString.indexOf(":");

            Integer startLevel;
            String s = startString.substring(0, colonPos);
            if ("default".equals(s)) {
                startLevel = defaultStart;
            } else {
                startLevel = new Integer(s);
            }

            boolean autostart;
            s = startString.substring(colonPos + 1);
            if ("default".equals(s)) {
                autostart = defaultAutostart;
            } else {
                autostart = new Boolean(s);
            }

            List<String> entries;
            if (autostart) {
                entries = startEntries.get(FELIX_AUTO_START_PREFIX + startLevel.toString());
                if (entries == null) {
                    entries = new ArrayList<String>();
                    startEntries.put(FELIX_AUTO_START_PREFIX + startLevel.toString(), entries);
                }
            } else {
                entries = startEntries.get(FELIX_AUTO_INSTALL_PREFIX + startLevel.toString());
                if (entries == null) {
                    entries = new ArrayList<String>();
                    installEntries.put(FELIX_AUTO_INSTALL_PREFIX + startLevel.toString(), entries);
                }
            }

            try {
                final File bundle = new File(model.getBundleDescription().getLocation());
                entries.add(bundle.toURI().toURL().toString());
            } catch (MalformedURLException e) {
            }
        }

        for (Map.Entry<String, List<String>> e : startEntries.entrySet()) {
            properties.put(e.getKey(), join(e.getValue(), " "));
        }

        for (Map.Entry<String, List<String>> e : installEntries.entrySet()) {
            properties.put(e.getKey(), join(e.getValue(), " "));
        }

        writeProperties(f.getAbsolutePath(), properties);
    }

    private void writeStartupProperties(ILaunchConfiguration configuration) throws CoreException {
        final File f = new File(getConfigDir(configuration), "startup.properties"); //$NON-NLS-1$

        final Properties properties = new Properties();

        writeProperties(f.getAbsolutePath(), properties);
    }

    private void writeSystemProperties(ILaunchConfiguration configuration) throws CoreException {
        final File f = new File(getConfigDir(configuration), FELIX_SYSTEM_PROPERTIES_FILE);

        final Properties properties = new Properties();

        writeProperties(f.getAbsolutePath(), properties);
    }

    /*
     * Sets up the initial map of bundles.
     *
     * @see
     * org.eclipse.pde.ui.launcher.AbstractPDELaunchConfiguration#preLaunchCheck
     * (org.eclipse.debug.core.ILaunchConfiguration,
     * org.eclipse.debug.core.ILaunch,
     * org.eclipse.core.runtime.IProgressMonitor)
     */
    @Override
    protected void preLaunchCheck(ILaunchConfiguration configuration, ILaunch launch, IProgressMonitor monitor) throws CoreException {
        final String workspace = configuration.getAttribute(IPDELauncherConstants.WORKSPACE_BUNDLES, ""); //$NON-NLS-1$
        final String target = configuration.getAttribute(IPDELauncherConstants.TARGET_BUNDLES, ""); //$NON-NLS-1$

        final List<BundleEntry> workspaceBundles = FelixLaunchHelper.getBundles(workspace);
        final List<BundleEntry> targetBundles = FelixLaunchHelper.getBundles(target);

        fModels = new HashMap<IPluginModelBase, String>();
        for(BundleEntry e : workspaceBundles) {
            final IPluginModelBase model = FelixLaunchHelper.resolveWorkspaceBundleEntry(e);
            if(model == null) {
                continue;
            }

            fModels.put(model, e.getAutostart() + ":" + e.getStartLevel()); //$NON-NLS-1$
        }

        if (configuration.getAttribute(IPDELauncherConstants.AUTOMATIC_ADD, true)) {
            automaticallyAddWorkspaceBundles(configuration);
        }

        for(BundleEntry e : targetBundles) {
            final IPluginModelBase model = FelixLaunchHelper.resolveTargetBundleEntry(e);
            if(model == null) {
                continue;
            }

            fModels.put(model, e.getAutostart() + ":" + e.getStartLevel()); //$NON-NLS-1$
        }

        fAllBundles = new HashMap<String, IPluginModelBase>(fModels.size());

        final Iterator<IPluginModelBase> iter = fModels.keySet().iterator();
        while (iter.hasNext()) {
            final IPluginModelBase model = iter.next();
            fAllBundles.put(model.getPluginBase().getId(), model);
        }

        super.preLaunchCheck(configuration, launch, monitor);
    }

    private void automaticallyAddWorkspaceBundles(ILaunchConfiguration configuration) throws CoreException {
        final Set<IPluginModelBase> deselectedPlugins = FelixLaunchHelper.getDeselectedPluginSet(configuration);

        final IPluginModelBase[] models = PluginRegistry.getWorkspaceModels();
        for (int i = 0; i < models.length; i++) {
            final String id = models[i].getPluginBase().getId();
            if (id == null) {
                continue;
            }

            if (!deselectedPlugins.contains(models[i])) {
                if (!fModels.containsKey(models[i])) {
                    fModels.put(models[i], "default:default"); //$NON-NLS-1$
                }
            }
        }
    }

}