/*

  * 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.commons.openpgp.ant;

 import org.apache.tools.ant.Task;

 import org.apache.tools.ant.BuildException;

 import org.apache.tools.ant.DirectoryScanner;

 import org.apache.tools.ant.util.FileNameMapper;

 import org.apache.tools.ant.util.GlobPatternMapper;

 import org.apache.tools.ant.util.FileUtils;

 import org.apache.tools.ant.types.FileSet;

 import org.apache.tools.ant.types.Mapper;

 import org.apache.commons.openpgp.*;

 import org.bouncycastle.openpgp.PGPException;

 import java.io.*;

 import java.util.Collection;

 import java.util.ArrayList;

 import java.util.Iterator;

 /**

  */

 public class OpenPgpSignerTask extends Task {

     private File secring;

     private File pubring;

     private String password;

     private String keyId;

     private Collection<FileSet> tosign = new ArrayList<FileSet>();

     private File artefact;

     private boolean asciiarmor = true;

     private Mapper mapperElement;

     /**

      * set the secret keyring

      * @param secring secret keyring file

      */

     public void setSecring(File secring) {

         this.secring = secring;

     }

     /**

      * set the public keyring

      * @param pubring public keyring file

      */

     public void setPubring(File pubring) {

         this.pubring = pubring;

     }

     /**

      * set the key id

      * @param keyId

      */

     public void setKeyId(String keyId) {

         this.keyId = keyId;

     }

     /**

      * asciiarmor the signature ?

      * @param asciiarmor ascii armored signature ?

      */

     public void setAsciiarmor(boolean asciiarmor) {

         this.asciiarmor = asciiarmor;

     }

     /**

      * set the value of the password

      * @param password value of the password

      */

     public void setPassword(String password) {

         this.password = password;

     }

     /**

      * artefact to be signed

      * @param artefact artefact to be signed

      */

     public void setArtefact(File artefact) {

         this.artefact = artefact;

     }

     public void add(FileSet fs) {

         tosign.add(fs);

     }

     /**

      * Define the mapper to map source to destination files.

      * @return a mapper to be configured.

      * @exception org.apache.tools.ant.BuildException if more than one mapper is defined.

      */

     public Mapper createMapper() throws BuildException {

         if (mapperElement != null) {

             throw new BuildException("Cannot define more than one mapper",

                     getLocation());

         }

         mapperElement = new Mapper(getProject());

         return mapperElement;

     }

     public void execute() {

         if (secring == null) {

             throw new BuildException("secring attribute compulsory");

         }

         if (pubring == null) {

             throw new BuildException("pubring attribute compulsory");

         }

         if (password == null) {

             throw new BuildException("password attribute compulsory");

         }

         if (tosign.size() == 0 && artefact == null) {

             throw new BuildException("supply the attribute 'artefact' or one nested fileset");

         }

         if (!secring.exists() || !secring.canRead()) {

             throw new  BuildException("secret keyring file '" + secring.getAbsolutePath() + "' does not exist or is not readable");

         }

         if (!pubring.exists() || !pubring.canRead()) {

             throw new  BuildException("public keyring file '" + pubring.getAbsolutePath() + "' does not exist or is not readable");

         }

         FileInputStream secStream;

         FileInputStream pubStream;

         KeyRing keyRing = null;

         try {

             secStream = new FileInputStream(secring);

             pubStream = new FileInputStream(pubring);

             keyRing = new BouncyCastleKeyRing(secStream,

                     pubStream, password.toCharArray() );

         } catch (IOException ioe) {

             throw new BuildException(ioe);

         } catch (PGPException pgpe) {

             throw new BuildException(pgpe);

         }

         if (artefact != null) {

             dosign(keyRing, artefact);

         }

         if (tosign.size() != 0) {

             for (FileSet fileset : tosign) {

                 dosign(keyRing, fileset);

             }

         }

         FileUtils.close(secStream);

         FileUtils.close(pubStream);

     }

     private void dosign(KeyRing keyRing, FileSet fs) {

         DirectoryScanner ds = fs.getDirectoryScanner(getProject());

         String[] artefacts = ds.getIncludedFiles();

         for (String artefact : artefacts) {

             dosign(keyRing, new File(fs.getDir(getProject()), artefact), fs.getDir(getProject()), artefact);

         }

     }

     private void dosign(KeyRing keyRing, File oneartefact) {

         dosign(keyRing, oneartefact, oneartefact.getParentFile(), oneartefact.getName());

     }

     private void dosign(KeyRing keyRing, File oneartefact, File basedir, String relpath) {

         FileInputStream fis = null;

         FileOutputStream fos = null;

         File signature;

         try {

             fis = new FileInputStream(oneartefact);

             FileNameMapper mapper = getMapper();

             String [] mappedFiles = mapper.mapFileName(relpath);

             if (mappedFiles == null || mappedFiles.length != 1) {

                 throw new BuildException("mapper returned more or less than one output");

             }

             signature = new File(basedir, mappedFiles[0]);

             fos = new FileOutputStream(signature);

             OpenPgpSigner signer = new BouncyCastleOpenPgpSigner();

             signer.detachedSign(fis, fos, keyId, keyRing, asciiarmor);

         } catch (FileNotFoundException fnfe) {

             throw new BuildException(fnfe);

         } catch (IOException ioe) {

             throw new BuildException(ioe);

         } catch (OpenPgpException opgpe) {

             throw new BuildException(opgpe);

         }

         FileUtils.close(fos);

         FileUtils.close(fis);

     }

     /**

      * returns the mapper to use based on nested elements or the

      */

     private FileNameMapper getMapper() {

         FileNameMapper mapper = null;

         if (mapperElement != null) {

             mapper = mapperElement.getImplementation();

         } else {

             mapper = new GlobPatternMapper();

             mapper.setFrom("*");

             if (asciiarmor) {

                 mapper.setTo("*.asc");

             } else {

                 mapper.setTo("*.sig");

             }

         }

         return mapper;

     }

 }