/*
 * 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.features.command;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

import org.apache.karaf.features.BundleInfo;
import org.apache.karaf.features.Dependency;
import org.apache.karaf.features.Feature;
import org.apache.karaf.features.FeaturesService;
import org.apache.karaf.features.command.completers.AvailableFeatureCompleter;
import org.apache.karaf.shell.api.action.Argument;
import org.apache.karaf.shell.api.action.Command;
import org.apache.karaf.shell.api.action.Completion;
import org.apache.karaf.shell.api.action.Option;
import org.apache.karaf.shell.api.action.lifecycle.Reference;
import org.apache.karaf.shell.api.action.lifecycle.Service;
import org.apache.karaf.shell.support.completers.FileCompleter;
import org.ops4j.pax.url.mvn.MavenResolver;

/**
 * Simple {@link FeaturesCommandSupport} implementation that allows a user in
 * the karaf shell to export the bundles associated with a given feature to the
 * file system. This is useful for several use cases, such as in the event you
 * need to deploy the functionality offered by a particular feature to an OBR
 * repository.
 * 
 */
@Service
@Command(scope = "feature", name = "export-bundles", description = "Export all of the bundles that make up a specified feature to a directory on the file system.")
public class FeatureExport extends FeaturesCommandSupport {

    /**
     * Inject a {@link MavenResolver} so we can translate from a
     * {@link BundleInfo} in a {@link Feature} into the raw bundle from maven.
     */
    @Reference
    private MavenResolver resolver;

    /**
     * The name of the feature you want to export.
     */
    @Argument(index = 0, name = "featureName", description = "The name of the feature you want to export bundles for", required = true, multiValued = false)
    @Completion(value = AvailableFeatureCompleter.class)
    private String featureName = null;

    /**
     * The location we'll export the bundles to.
     */
    @Argument(index = 1, name = "exportLocation", description = "Where you want to export the bundles", multiValued = false, required = true)
    @Completion(value = FileCompleter.class)
    private String exportLocation;

    /**
     * The version of the feature you want to export.
     */
    @Option(name = "-v", multiValued = false, aliases = {
            "--version" }, description = "The version of the feature you want to export bundles for.  Default is latest", required = false)
    private String featureVersion = null;

    /**
     * Option indicating that only bundles marked as a dependency should be
     * exported.
     */
    @Option(name = "-d", multiValued = false, aliases = {
            "--dependencies-only" }, description = "This flag indicates that only bundles marked as a dependency will be exported.", required = false)
    private boolean onlyDependencies = false;

    /**
     * {@inheritDoc}
     */
    @Override
    public void doExecute(final FeaturesService featuresService) throws Exception {
        if (resolver == null) {
            throw new IllegalStateException("No maven resolver implementation found.");
        } else {
            final File destination = new File(exportLocation);
            if (!prepareDestination(destination)) {
                System.err.println("Invalid exportLocation specified: " + exportLocation);
            } else {
                final Feature feature = featureVersion != null ? featuresService.getFeature(featureName, featureVersion)
                        : featuresService.getFeature(featureName);
                if (feature == null) {
                    System.err.println("Could not find specified feature: '" + featureName + "' version '" + featureVersion + "'");
                } else {
                    // Save feature content bundles.
                    saveBundles(destination, feature, featuresService);
                }
            }
        }

    }

    /**
     * Prepare the target destination directory.
     * 
     * @param destination
     *            Where we'll save the bundles
     * @return true if it is valid, false otherwise
     */
    private boolean prepareDestination(final File destination) {
        return (destination.isDirectory() || destination.mkdirs());
    }

    /**
     * Save the feature bundles, and all of its transitive dependency bundles.
     * 
     * @param dest
     *            The target directory where we'll save the feature bundles
     * @param feature
     *            The {@link Feature} we're saving
     * @throws Exception
     *             If there is an issue saving the bundles or resolving the
     *             feature
     */
    private void saveBundles(final File dest, final Feature feature, final FeaturesService featuresService) throws Exception {
        // Save this feature's bundles.
        for (final BundleInfo info : feature.getBundles()) {
            if (!onlyDependencies || (onlyDependencies && info.isDependency())) {
                final File resolvedLocation = resolver.resolve(info.getLocation());
                if (copyFileToDirectory(resolvedLocation, dest)) {
                    System.out.println("Exported '" + feature.getName() + "/" + feature.getVersion() + "' bundle: " + info.getLocation());
                } else {
                    System.out.println("Already exported bundle: " + info.getLocation());
                }
            }
        }
        // Save feature's dependency bundles.
        for (final Dependency dependency : feature.getDependencies()) {
            final Feature dFeature = featuresService.getFeature(dependency.getName(), dependency.getVersion());
            if (dFeature != null) {
                saveBundles(dest, dFeature, featuresService);
            } else {
                System.err.println("Unable to resolve dependency feature! '" + dependency.getName() + "' '" + dependency.getVersion() + "'");
                throw new Exception("Unable to resolve dependency feature '" + dependency.getName() + "/" + dependency.getVersion() + "' while exporting '"
                        + featureName + "/" + featureVersion + "'");
            }
        }
    }

    /**
     * Simple method to copy a file to a target destination directory.
     * 
     * @param file
     *            The file to copy
     * @param directory
     *            The directory to copy it to
     * @return true if successful, false if it wasn't
     * @throws FileNotFoundException
     *             If the file specified doesn't exist
     * @throws IOException
     *             If there is an issue performing the copy
     */
    private static boolean copyFileToDirectory(final File file, final File directory) throws FileNotFoundException, IOException {
        if (!directory.isDirectory()) {
            throw new IOException("Can't copy to non-directory specified: " + directory.getAbsolutePath());
        } else {
            boolean copied = false;
            final File newFile = new File(directory.getAbsolutePath() + "/" + file.getName());
            if (!newFile.isFile()) {
                try (final FileInputStream fis = new FileInputStream(file)) {
                    try (final FileOutputStream fos = new FileOutputStream(newFile)) {
                        byte[] buffer = new byte[1024 * 8];
                        int read = -1;
                        while ((read = fis.read(buffer)) >= 0) {
                            fos.write(buffer, 0, read);
                        }
                    }
                }
                copied = true;
            }
            return copied;
        }
    }

}