/*
    * 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.
   * 
   * Author: Siamak Haschemi
   * Contact: haschemi@informatik.hu-berlin.de
   */
  package net.sourceforge.osgi.deployment.maven;
  
  import java.io.File;
  import java.io.FileInputStream;
  import java.io.FileOutputStream;
  import java.io.IOException;
  import java.io.OutputStream;
  import java.util.jar.JarEntry;
  import java.util.jar.JarOutputStream;
  
  import net.sourceforge.osgi.deployment.maven.container.BundleResource;
  import net.sourceforge.osgi.deployment.maven.container.DeploymentPackageInfo;
  import net.sourceforge.osgi.deployment.maven.container.ProcessedResource;
  import net.sourceforge.osgi.deployment.maven.manifest.DeploymentPackageManifest;
  import net.sourceforge.osgi.deployment.maven.manifest.OrderedManifest;
  
  import org.apache.maven.artifact.Artifact;
  
  
  /**
   * 
   * @author Siamak Haschemi, haschemi@informatik.hu-berlin.de
   * 
   */
  public final class DeploymentPlugin {
  
    private static final String DP_FILE_EXTENSION = ".dp";
    private static final String MANIFEST_MF_PATH = "META-INF/MANIFEST.MF";
  
    private final IDeploymentPluginContext m_ctx;
  
    /**
     * Default constructor to inject the context.
     * 
     * @param p_ctx
     *          the {@link IDeploymentPluginContext} for the {@link DeploymentPlugin}
     */
    public DeploymentPlugin(final IDeploymentPluginContext p_ctx) {
      m_ctx = p_ctx;
    }
  
    /**
     * Starts the execution of the Deployment-Package generation.
     */
    public void execute() {
      // ignore project types not supported, useful when the plugin is configured in the parent pom
      final Artifact artifact = m_ctx.getProject().getArtifact();
      if (!m_ctx.getSupportedProjectTypes().contains(artifact.getType())) {
        m_ctx.getLogger().debug(
            "Ignoring project " + artifact + " : type " + artifact.getType() + " is not supported by bundle plugin, supported types are "
                + m_ctx.getSupportedProjectTypes());
        return;
      }
  
      final DeploymentPackageManifest deploymentPackageManifest = new DeploymentPackageManifest(m_ctx);
  
      buildJar(deploymentPackageManifest);
  
      if (m_ctx.getManifestLocation() != null) {
        writeManifestFile(deploymentPackageManifest);
      }
    }
  
    private void buildJar(final OrderedManifest p_orderedManifest) {
      // the target deployment package jar file
      final File jarFile = new File(m_ctx.getBuildDirectory(), getBundleName());
  
      // make dir dirs if not exists
      jarFile.getParentFile().mkdirs();
  
      final Artifact mainArtifact = m_ctx.getProject().getArtifact();
      // workaround for MNG-1682: force maven to install artifact using the "jar" handler
      mainArtifact.setArtifactHandler(m_ctx.getArtifactHandlerManager().getArtifactHandler("jar"));
      mainArtifact.setFile(jarFile);
  
      // Write the deployment package jar, which includes the manifest and all resources.
      OutputStream out = null;
      try {
       out = new FileOutputStream(jarFile);
       // The destination jar file
       final JarOutputStream jout = new JarOutputStream(out);
 
       writeManifestIntoJar(p_orderedManifest, jout);
       writeResourcesIntoJar(jout);
       jout.finish();
     } catch (final Exception t) {
       throw new DeploymentPluginException("Problem writing Deployment package jar " + jarFile, t);
     } finally {
       if (out != null) {
         try {
           out.close();
         } catch (final IOException e) {
           throw new DeploymentPluginException("Problem closing stream of Deployment package jar " + jarFile, e);
         }
       }
     }
   }
 
   private void writeManifestFile(final OrderedManifest p_orderedManifest) {
     final File outputFile = new File(m_ctx.getManifestLocation(), "MANIFEST.MF");
     outputFile.getParentFile().mkdirs();
 
     FileOutputStream os = null;
     try {
       os = new FileOutputStream(outputFile);
       p_orderedManifest.write(os);
     } catch (final Exception e) {
       throw new DeploymentPluginException("Error trying to write Manifest to file " + outputFile, e);
     } finally {
       try {
         os.close();
       } catch (final IOException e) {
         throw new DeploymentPluginException("Error trying to close the stream to the Manifest to file " + outputFile, e);
       }
     }
   }
 
   private void writeResourcesIntoJar(final JarOutputStream p_jout) {
     final DeploymentPackageInfo deploymentPackageInfo = m_ctx.getDeploymentPackageInfo();
 
     // Sort the resources
     // 1. META-INF/MANIFEST.MF (Will be generated)
     // 2. Signature files TODO
     // 3. Localization files (Stored in the OSGI-INF directory)
     // 4. Bundle resources
     // 5. processed resources
 
     for (final ProcessedResource localizationResource : deploymentPackageInfo.getLocalizationResources()) {
       copyIntoJar(p_jout, localizationResource);
     }
 
     for (final BundleResource bundleResource : deploymentPackageInfo.getBundleResources()) {
       copyIntoJar(p_jout, bundleResource);
     }
 
     for (final ProcessedResource processedResource : deploymentPackageInfo.getProcessedResources()) {
       copyIntoJar(p_jout, processedResource);
     }
   }
 
   private void copyIntoJar(final JarOutputStream p_jout, final ProcessedResource p_processedResource) {
     copyIntoJar(p_jout, new File(m_ctx.getOutputDirectory(), p_processedResource.getFilePath()), p_processedResource.getResourceId());
   }
 
   private void copyIntoJar(final JarOutputStream p_jout, final BundleResource p_bundleResource) {
     copyIntoJar(p_jout, p_bundleResource.getResolvedFile(), p_bundleResource.getResourceId());
   }
 
   private static final int BUFFER_SIZE = 1024;
 
   private static void copyIntoJar(final JarOutputStream p_jout, final File p_file, final String p_path) {
     try {
       p_jout.putNextEntry(new JarEntry(p_path));
       final FileInputStream inputStream = new FileInputStream(p_file);
       final byte[] buffer = new byte[BUFFER_SIZE];
       int bytesRead = 0;
       while ((bytesRead = inputStream.read(buffer)) > 0) {
         p_jout.write(buffer, 0, bytesRead);
       }
       inputStream.close();
       p_jout.closeEntry();
       p_jout.flush();
     } catch (final Exception e) {
       // Wrap checked exception
       throw new RuntimeException("Error while copying file " + p_file + " into jar", e);
     }
   }
 
   private void writeManifestIntoJar(final OrderedManifest p_manifest, final JarOutputStream p_jout) {
     try {
       p_jout.putNextEntry(new JarEntry(MANIFEST_MF_PATH));
       p_manifest.write(p_jout);
       p_jout.closeEntry();
     } catch (IOException e) {
       throw new DeploymentPluginException("Error while writing the manifest into " + MANIFEST_MF_PATH, e);
     }
   }
 
   /**
    * @return the bundle symbolic name derived from the maven project informations.
    */
   private String getBundleName() {
     final String finalName = m_ctx.getProject().getBuild().getFinalName();
 
     return finalName + DP_FILE_EXTENSION;
   }
 }