/**
 * <copyright> Copyright 2006 by Know-Center, Graz, Austria </copyright>
 * PDF-AS has been contracted by the E-Government Innovation Center EGIZ, a
 * joint initiative of the Federal Chancellery Austria and Graz University of
 * Technology.
 *
 * Licensed under the EUPL, Version 1.1 or - as soon they will be approved by
 * the European Commission - subsequent versions of the EUPL (the "Licence");
 * You may not use this work except in compliance with the Licence.
 * You may obtain a copy of the Licence at:
 * http://www.osor.eu/eupl/
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the Licence is distributed on an "AS IS" basis,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the Licence for the specific language governing permissions and
 * limitations under the Licence.
 *
 * This product combines work with different licenses. See the "NOTICE" text
 * file for details on the various modules and licenses.
 * The "NOTICE" text file is part of the distribution. Any derivative works
 * that you distribute must include a readable copy of the "NOTICE" text file.
 *
 * $Id: Main.java,v 1.5 2006/10/31 08:06:56 wprinz Exp $
 */
package at.knowcenter.wag.egov.egiz.commandline;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Set;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import at.gv.egiz.pdfas.commandline.CommandlineConnectorChooser;
import at.gv.egiz.pdfas.exceptions.ErrorCode;
import at.gv.egiz.pdfas.exceptions.ErrorCodeHelper;
import at.gv.egiz.pdfas.exceptions.external.ExternalErrorException;
import at.gv.egiz.pdfas.framework.DataSourceHolder;
import at.gv.egiz.pdfas.framework.config.SettingsHelper;
import at.gv.egiz.pdfas.framework.input.DataSource;
import at.gv.egiz.pdfas.framework.input.ExtractionStage;
import at.gv.egiz.pdfas.framework.input.PdfDataSource;
import at.gv.egiz.pdfas.framework.output.DataSink;
import at.gv.egiz.pdfas.framework.vfilter.VerificationFilterParameters;
import at.gv.egiz.pdfas.impl.input.FileBasedPdfDataSourceImpl;
import at.gv.egiz.pdfas.impl.input.TextDataSourceImpl;
import at.gv.egiz.pdfas.impl.output.FileBasedDataSink;
import at.knowcenter.wag.egov.egiz.PdfAS;
import at.knowcenter.wag.egov.egiz.PdfASID;
import at.knowcenter.wag.egov.egiz.cfg.SettingsReader;
import at.knowcenter.wag.egov.egiz.exceptions.ConnectorFactoryException;
import at.knowcenter.wag.egov.egiz.exceptions.PDFDocumentException;
import at.knowcenter.wag.egov.egiz.exceptions.PlaceholderException;
import at.knowcenter.wag.egov.egiz.exceptions.PresentableException;
import at.knowcenter.wag.egov.egiz.exceptions.SettingNotFoundException;
import at.knowcenter.wag.egov.egiz.exceptions.SignatureException;
import at.knowcenter.wag.egov.egiz.exceptions.SignatureTypesException;
import at.knowcenter.wag.egov.egiz.framework.SignatorFactory;
import at.knowcenter.wag.egov.egiz.pdf.SignatureHolder;
import at.knowcenter.wag.egov.egiz.pdf.TablePos;
import at.knowcenter.wag.egov.egiz.sig.ConnectorFactory;
import at.knowcenter.wag.egov.egiz.sig.ConnectorInformation;
import at.knowcenter.wag.egov.egiz.sig.SignatureResponse;
import at.knowcenter.wag.egov.egiz.sig.SignatureTypes;

/**
 * The main program entry point of the commandline tool.
 * 
 * @author wprinz
 */
public abstract class Main
{
  /**
   * Command line parameter setting the application mode sign|verify
   */
  protected static final String PARAMETER_MODE = "-mode";

  /**
   * Command line parameter setting the application to connect
   */
  protected static final String PARAMETER_CONNECTOR = "-connector";

  /**
   * Command line parameter setting the signature mode.
   */
  protected static final String PARAMETER_SIGNATURE_MODE = "-sigmode";

  /**
   * Command line parameter setting the signature type.
   */
  protected static final String PARAMETER_SIGNATURE_TYPE = "-sigtype";

  /**
   * Command line parameter setting the username
   */
  protected static final String PARAMETER_USER_NAME = "-username";

  /**
   * Command line parameter setting the users password
   */
  protected static final String PARAMETER_USER_PASSWORD = "-password";

  /**
   * Command line parameter selecting the position of the signature.
   */
  protected static final String PARAMETER_POS = "-pos";

  /**
   * Command line parameter selecting the signature which is going to be
   * verified.
   */
  protected static final String PARAMETER_VERIFY_WHICH = "-verify_which";

  /**
   * The application mode sign
   */
  public static final String VALUE_MODE_SIGN = "sign";

  /**
   * The application mode verify
   */
  public static final String VALUE_MODE_VERIFY = "verify";

  /**
   * The application mode sign
   */
  public static final String VALUE_SIGNATURE_MODE_BINARY = "binary";

  /**
   * The application mode verify
   */
  public static final String VALUE_SIGNATURE_MODE_TEXTUAL = "textual";

  /**
   * The application mode verify
   */
  public static final String VALUE_SIGNATURE_MODE_DETACHED = "detached";

  /**
   * The application mode verify
   */
  public static final String VALUE_SIGNATURE_MODE_DETACHED_TEXT = "detachedtextual";

  /**
   * The log.
   */
  private static final Log logger_ = LogFactory.getLog(Main.class);

  /**
   * Main program entry point.
   * 
   * @param args
   *          The commandline arguments.
   * @throws IOException
   * 
   * @deprecated use {@link at.gv.egiz.pdfas.commandline.Main} instead
   */
  public static void main(String[] args) throws IOException {
     System.out.println("\nWarning: The entry point at.knowcenter.wag.egov.egiz.commandline.Main is deprecated. Use at.gv.egiz.pdfas.commandline.Main instead.\n");
     at.gv.egiz.pdfas.commandline.Main.main(args);
  }
  
  /*
  public static void main(String[] args) throws IOException
  {
    // ConfigLogger.setLevel(Level.DEBUG);

    SettingsReader.initializeForCommandLine();
    PropertyConfigurator.configure(SettingsReader.CONFIG_PATH + "log4j.properties");

      // printUsage(System.out);

      String mode = null;
      String signature_mode = null;
      String connector = null;

      String signature_type = null;
      String user_name = null;
      String user_password = null;
      String pos_string = null;

      int verify_which = -1;

      String input = null;
      String output = null;

    try
    {

      // for (int i = 0; i < args.length; i++)
      // {
      // logger_.debug("arg[" + i + "] = " + args[i]);
      // }

      for (int i = 0; i < args.length; i++)
      {
        String cur_arg = args[i].trim();

        if (cur_arg.equals(PARAMETER_MODE))
        {
          i++;
          if (i >= args.length)
          {
            printNoValue(PARAMETER_MODE);
            return;
          }
          mode = args[i];
          if (!checkMode(mode))
          {
            printUnrecognizedValue(PARAMETER_MODE, mode);
            return;
          }
          continue;
        }

        if (cur_arg.equals(PARAMETER_CONNECTOR))
        {
          i++;
          if (i >= args.length)
          {
            printNoValue(PARAMETER_CONNECTOR);
            return;
          }
          connector = args[i];
          if (!checkConnector(connector))
          {
            printUnrecognizedValue(PARAMETER_CONNECTOR, connector);
            return;
          }
          continue;
        }

        if (cur_arg.equals(PARAMETER_SIGNATURE_MODE))
        {
          i++;
          if (i >= args.length)
          {
            printNoValue(PARAMETER_SIGNATURE_MODE);
            return;
          }
          signature_mode = args[i];
          if (!checkSignatureMode(signature_mode))
          {
            printUnrecognizedValue(PARAMETER_SIGNATURE_MODE, signature_mode);
            return;
          }
          continue;
        }

        if (cur_arg.equals(PARAMETER_SIGNATURE_TYPE))
        {
          i++;
          if (i >= args.length)
          {
            printNoValue(PARAMETER_SIGNATURE_TYPE);
            return;
          }
          signature_type = args[i];
          if (!checkSignatureType(signature_type))
          {
            printUnrecognizedValue(PARAMETER_SIGNATURE_TYPE, signature_type);
            return;
          }
          continue;
        }

        if (cur_arg.equals(PARAMETER_USER_NAME))
        {
          i++;
          if (i >= args.length)
          {
            printNoValue(PARAMETER_USER_NAME);
            return;
          }
          user_name = args[i];
          continue;
        }

        if (cur_arg.equals(PARAMETER_USER_PASSWORD))
        {
          i++;
          if (i >= args.length)
          {
            printNoValue(PARAMETER_USER_PASSWORD);
            return;
          }
          user_password = args[i];
          continue;
        }

        if (cur_arg.equals(PARAMETER_POS))
        {
          i++;
          if (i >= args.length)
          {
            printNoValue(PARAMETER_POS);
            return;
          }
          pos_string = args[i];
          continue;
        }

        if (cur_arg.equals(PARAMETER_VERIFY_WHICH))
        {
          i++;
          if (i >= args.length)
          {
            printNoValue(PARAMETER_VERIFY_WHICH);
            return;
          }
          String str_verify_which = args[i];
          try
          {
            verify_which = Integer.parseInt(str_verify_which);
          }
          catch (NumberFormatException e)
          {
            printUnrecognizedValue(PARAMETER_VERIFY_WHICH, str_verify_which);
            return;
          }

          continue;
        }

        if (cur_arg.charAt(0) == '-')
        {
          printUnrecognizedOption(cur_arg);
          return;
        }

        if (input == null)
        {
          input = cur_arg;
          continue;
        }

        if (output == null)
        {
          output = cur_arg;
          continue;
        }

        printUnrecognizedAdditionalCommandlineArgument(cur_arg);
        return;
      }

      if (mode == null)
      {
        printMissingParameter("a mode", PARAMETER_MODE);
        return;
      }
      if (connector == null)
      {
        printMissingParameter("a connector", PARAMETER_CONNECTOR);
        return;
      }
      if (mode.equals(VALUE_MODE_SIGN))
      {
        if (signature_mode == null)
        {
          printMissingParameter("a signature mode", PARAMETER_SIGNATURE_MODE);
          return;
        }
        if (signature_type == null)
        {
          SettingsReader settings = SettingsReader.getInstance();
          String default_type = settings.getValueFromKey(SignatureTypes.DEFAULT_TYPE);
          signature_type = default_type;
        }
        if (user_name == null)
        {
          user_name = "";
          // printMissingParameter("a user name", PARAMETER_USER_NAME);
          // return;
        }
        if (user_password == null)
        {
          user_password = "";
          // printMissingParameter("a user password", PARAMETER_USER_PASSWORD);
          // return;
        }
      }

      if (input == null)
      {
        printMissing("an input document");
        return;
      }

      File file = new File(input);
      if (!file.exists())
      {
        System.err.println("The input file '" + input + "' doesn't exist.");
        return;
      }

      if (mode.equals(VALUE_MODE_SIGN) && output == null)
      {
        output = generateOutputFileNameFromInput(input, signature_mode);
      }

      carryOutCommand(mode, signature_mode, connector, signature_type, user_name, user_password, verify_which, input, output, pos_string);

    }
    catch (PresentableException e)
    {
      printPresentableException(e);
      
      if (output != null)
      {
        logger_.debug("Deleting output file on error.");
        File oFile = new File(output);
        boolean deleted = oFile.delete();
        if (!deleted)
        {
          logger_.error("Couldn't delete output file " + output);
        }
      }
    }
    finally
    {
      SettingsReader.clearTemporaryDirectory();
    }
  }
  */

  protected static void carryOutCommand(final String mode, final String signature_mode, final String connector, final String signature_type, final String user_name, final String user_password,
      final int verify_which, final String input, String output, final String pos_string) throws PresentableException
  {
    // File file = new File(input);
    //
    // byte[] input_bytes = null;
    // try
    // {
    // FileInputStream fis = new FileInputStream(file);
    // input_bytes = new byte[(int) file.length()];
    // fis.read(input_bytes);
    // fis.close();
    // }
    // catch (IOException e)
    // {
    // throw new PDFDocumentException(201);
    // }

    PrintWriter messageOutput = new PrintWriter(System.out);
    
    
    if (mode.equals(VALUE_MODE_SIGN))
    {    	
      carryOutSign(input, connector, signature_mode, signature_type, pos_string, user_name, user_password, output, messageOutput);
    }
    else
    {
      carryOutVerify(input, connector, verify_which, messageOutput);
    }
    messageOutput.flush();
  }

  public static void carryOutSign(String input, String connector, String signature_mode, String signature_type, String pos_string, String user_name, String user_password, String output,
      PrintWriter messageOutput) throws PresentableException
  {
    messageOutput.println("Signing...");
    
    // for performance measurement
    long startTime = 0; 
    long fileSize = 0;
    if (logger_.isInfoEnabled()) {
    	startTime = System.currentTimeMillis();    	
    }

    PdfDataSource pdfDataSource;
    try
    {
      File file = new File(input);
      pdfDataSource = new FileBasedPdfDataSourceImpl(file, (int)file.length());
      if (logger_.isDebugEnabled()) 
    	  fileSize = file.length(); 
      
    }
    catch (IOException e)
    {
      throw new PDFDocumentException(201, e);
    }

    FileBasedDataSink dataSink = null;
    File outputFile = null;
    try
    {
      outputFile = new File(output);
      
      dataSink = new FileBasedDataSink(outputFile);
    }
    catch (IOException e)
    {
      throw new PDFDocumentException(ErrorCode.CANNOT_WRITE_PDF, e);
    }

    try {
       processSign(pdfDataSource, connector, signature_mode, signature_type, pos_string, dataSink);
    } catch (Exception e) {
       // Exception caught in order to delete file based datasink
       if (outputFile != null && outputFile.exists())
       {
         logger_.debug("Deleting output file on error.");
         boolean deleted = outputFile.delete();
         if (!deleted)
         {
           logger_.error("Couldn't delete output file " + output);
         }
       }
       if (e instanceof PresentableException) {
          throw (PresentableException)e;
       } else {
          throw new PresentableException(ErrorCode.UNKNOWN_ERROR, e);
       }
    }

    // for performance measurement
    if (logger_.isInfoEnabled()) {
    	long endTime = System.currentTimeMillis();
    	String toReport = "SIGN;" + signature_mode + ";" + input + ";"+ fileSize + ";" + (endTime - startTime); 
    	logger_.info(toReport);
    }
    
    messageOutput.println("Signing was successful.");
  }

  public static void carryOutVerify(String input, String connector, int verify_which, PrintWriter messageOutput) throws PresentableException
  {
    messageOutput.println("Verifying...");
    
    // for performance measurement
    long startTime = 0; 
    long fileSize = 0;
    if (logger_.isInfoEnabled()) {
    	startTime = System.currentTimeMillis();    	
    }
    
    DataSource dataSource = null;
    try
    {
      File file = new File(input);
      if (logger_.isDebugEnabled())
    	  fileSize = file.length();
      String extension = extractExtension(input);
      if (extension != null && extension.equals("txt"))
      {
        try
        {
          FileInputStream fis = new FileInputStream(file);          
          byte[] input_bytes = new byte[(int) file.length()];
          fis.read(input_bytes);
          fis.close();

          String text = new String(input_bytes, "UTF-8");
          dataSource = new TextDataSourceImpl(text);
        }
        catch (UnsupportedEncodingException e)
        {
          throw new RuntimeException("Very strange: UTF-8 character encoding not supported.", e);
        }
      }
      else
      {
        dataSource = new FileBasedPdfDataSourceImpl(file, (int)file.length());
      }
    }
    catch (IOException e)
    {
      throw new PDFDocumentException(ErrorCode.DOCUMENT_CANNOT_BE_READ, e);
    }

    List results = processVerify(new DataSourceHolder(dataSource), connector, verify_which);

    messageOutput.println("Verification results:");
    formatVerifyResults(results, messageOutput);
    
    // for performance measurement
    if (logger_.isInfoEnabled()) {
    	long endTime = System.currentTimeMillis();
    	String toReport = "VERIFY;"+ input + ";"+ fileSize + ";" + (endTime - startTime) + ";" + debugVerifyResults(results); 
    	logger_.info(toReport);
    }
    
    
  }

  /**
   * Extracts the extension from a file name string.
   * 
   * <p>
   * The extension of a file name is whatever text follows the last '.'.
   * </p>
   * 
   * @param file_name
   *          The file name.
   * @return Returns the extension. If the file name ends with the '.', then an
   *         empty string is returned. If the file name doesn't contain any '.'
   *         or file_name is null, null is returned.
   */
  public static String extractExtension(String file_name)
  {
    if (file_name == null)
    {
      return null;
    }

    int dot_index = file_name.lastIndexOf('.');
    if (dot_index < 0)
    {
      return null;
    }
    return file_name.substring(dot_index + 1);
  }

  public static void processSign(PdfDataSource pdfDataSource, String connector, String signature_mode, String signature_type, String pos_string, DataSink dataSink) throws PresentableException
  {
    pdfDataSource = PdfAS.applyStrictMode(pdfDataSource);

    TablePos pos = null;
    if (pos_string != null)
    {
      try
      {
        pos = PdfAS.parsePositionFromPosString(pos_string);
      }
      catch (PDFDocumentException e)
      {
        printUnrecognizedValue(PARAMETER_POS, pos_string);
        return;

      }
    }

    PdfASID signatorId = translateSignatureModeToPdfASID(signature_mode);

    // TODO MOA detached signing is not allowed at the commandline
//    logger_.debug("Suggested sign algorithm = " + signatorId);
    if (connector.equals("moa"))
    {
      // TODO: possible new implementation of moa where is commandline call
      // supported
      // it should be checked in config file is it allowed to use MOA detached
      // from command line.
//      String msg = "Hinweis: Der MOA Detached Connector ist fuer die Kommandozeile nicht geeignet. Die Signatur wird daher im alten Base64 enveloping Format ausgefuehrt.";
//      System.out.println(msg);
//      logger_.warn(msg);
//
//      if (signature_mode.equals(VALUE_SIGNATURE_MODE_BINARY))
//      {
//        signatorId = BinarySignator_1_0_0.MY_ID;
//      }
//      if (signature_mode.equals(VALUE_SIGNATURE_MODE_TEXTUAL))
//      {
//        signatorId = TextualSignator_1_0_0.MY_ID;
//      }
    }
//    logger_.debug("Finally used sign algorithm = " + signatorId);
    
    String connectorId = CommandlineConnectorChooser.chooseCommandlineConnectorForSign(connector);

    PdfAS.signCommandline(pdfDataSource, dataSink, signatorId, connectorId, signature_type, null, pos, null, null);

//    PdfAS.sign(algorithm, pdfDataSource, dataSink, signature_type, connector, pos);
  }
  
  public static List processVerify(DataSourceHolder dataSource, String connector, int verify_which) throws PresentableException
  {
    VerificationFilterParameters parameters = SettingsHelper.readVerificationFilterParametersFromSettings();
    ExtractionStage es = new ExtractionStage();

    List signature_holders = es.extractSignatureHolders(dataSource, parameters);

    if (signature_holders.isEmpty())
    {
      throw new PDFDocumentException(ErrorCode.DOCUMENT_NOT_SIGNED, "Document is unsigned.");
    }

    List holders_to_verify = signature_holders;

    // verify_which - optional argument in command line/web
    if (verify_which >= 0)
    {
      if (verify_which >= signature_holders.size())
      {
        throw new SignatureException(312, "The selected signature to be verified doesn't exist.");
      }

      SignatureHolder holder = (SignatureHolder) signature_holders.get(verify_which);
      holders_to_verify = new ArrayList();
      holders_to_verify.add(holder);
    }
    
    List results = PdfAS.verifySignatureHolders(holders_to_verify, connector, false, null);

    return results;
  }

  // TODO old method - remove
  // /**
  // * Generates a suitable output file name for the output regarding the type
  // of
  // * the sign_result.
  // *
  // * @param input
  // * The input file name.
  // * @param sign_result
  // * The sign result.
  // * @return Returns the output file name.
  // */
  // protected static String generateOutputFileNameFromInput(String input,
  // SignResult sign_result)
  // {
  // String output = input + "_out";
  // if (sign_result.getMimeType().equals(DetachedSignator_1_0_0.MIME_TYPE))
  // {
  // output += ".xml";
  // }
  // else
  // {
  // output += ".pdf";
  // }
  //
  // return output;
  // }

  protected static String generateOutputFileNameFromInput(String input, String sig_mode)
  {
    String output = input + "_out";
    if (sig_mode.equals("detached"))
    {
      output += ".xml";
    }
    else
    {
      output += ".pdf";
    }

    return output;
  }

  /**
   * Prints that the provided option was unrecognized.
   * 
   * @param option
   *          The unrecognized option.
   * @throws PresentableException
   *           Forwarded exception.
   */
  protected static void printUnrecognizedOption(final String option) throws PresentableException
  {
    System.err.println("Unrecognized option '" + option + "'.");
    printUsage(System.out);
  }

  /**
   * Prints that the provided value was unrecognized.
   * 
   * @param parameter
   *          The parameter, which is missing a value.
   * @throws PresentableException
   *           Forwarded exception.
   */
  protected static void printNoValue(final String parameter) throws PresentableException
  {
    System.err.println("The parameter " + parameter + " requires a value as next argument.");
    printUsage(System.out);
  }

  /**
   * Prints that the provided value was unrecognized.
   * 
   * @param value
   *          The unrecognized value.
   * @throws PresentableException
   *           Forwarded exception.
   */
  protected static void printUnrecognizedValue(final String parameter, final String value) throws PresentableException
  {
    System.err.println("The parameter " + parameter + " doesn't recognize the provided value '" + value + "'.");
    printUsage(System.out);
  }

  /**
   * Prints that the provided additional commandline argument was unrecognized.
   * 
   * @param argument
   *          The unrecognized argument.
   * @throws PresentableException
   *           Forwarded exception.
   */
  protected static void printUnrecognizedAdditionalCommandlineArgument(final String argument) throws PresentableException
  {
    System.err.println("Unrecognized additional commandline argument '" + argument + "'.");
    printUsage(System.out);
  }

  /**
   * Prints that a certain parameter was missing.
   * 
   * @param missing_term
   *          A description of the missing parameter ("e.g. a mode").
   * @param parameter
   *          The missing parameter itself (e.g. "-mode").
   * @throws PresentableException
   *           Forwarded exception.
   */
  protected static void printMissingParameter(final String missing_term, final String parameter) throws PresentableException
  {
    printMissing(missing_term + " ('" + parameter + "' parameter)");
  }

  /**
   * Prints that something is missing.
   * 
   * @param missing_term
   *          A descriptive message of the missing thing.
   * @throws PresentableException
   *           Forwarded exception.
   */
  protected static void printMissing(final String missing_term) throws PresentableException
  {
    System.err.println("Please specify " + missing_term + ".");
    printUsage(System.out);
  }

  /**
   * Prints out the ErrorCodeException in a descriptive form.
   * 
   * @param ece
   *          The ErrorCodeException to be printed.
   */
  protected static void printPresentableException(final PresentableException e)
  {
    if (e.getErrorCode() == ErrorCode.PLACEHOLDER_EXCEPTION)
    {
      PlaceholderException phe = null;
      if (e instanceof PlaceholderException)
      {
        phe = (PlaceholderException) e;
      }
      else
      {
        phe = (PlaceholderException) e.getCause();
      }

      System.err.println("Der Platzhalter des Feldes " + phe.getField() + " ist um " + phe.getMissing() + " Bytes zu kurz. ");
    }

    System.err.println("Fehler " + e.getErrorCode() + ": " + ErrorCodeHelper.getMessageForErrorCode(e.getErrorCode()));

    if (e instanceof ExternalErrorException)
    {
      ExternalErrorException eee = (ExternalErrorException) e;
      System.err.println("Externer Fehlergrund: " + eee.getExternalErrorCode() + ": " + eee.getExternalErrorMessage());
    }

    logger_.error(e);
  }

  /**
   * Prints the usage text.
   * 
   * @param writer
   *          The writer to print the text to.
   * @throws PresentableException
   *           Forwarded exception.
   */
  public static void printUsage(PrintStream writer) throws PresentableException
  {
    writer.println("Usage: pdf-as [OPTIONS] <input file> [output file]");
    writer.println("  Required OPTIONS:");

    writer.println("    " + PARAMETER_MODE + " <" + VALUE_MODE_SIGN + "|" + VALUE_MODE_VERIFY + ">");
    writer.println("      " + VALUE_MODE_SIGN + " ... signs a document");
    writer.println("      " + VALUE_MODE_VERIFY + " ... verifies a document");

    writer.print("    " + PARAMETER_CONNECTOR + " ");
    ConnectorInformation[] ci = ConnectorFactory.getConnectorInformationArray();
    for (int i = 0; i < ci.length; i++)
    {
      String id = ci[i].getIdentifier();
      if (!ConnectorFactory.isAvailableForCommandline(id))
      {
        continue;
      }
      writer.print(id);
      if (i < ci.length - 1)
      {
        writer.print("|");
      }
    }
    writer.println();
    for (int i = 0; i < ci.length; i++)
    {
      String id = ci[i].getIdentifier();
      if (!ConnectorFactory.isAvailableForCommandline(id))
      {
        continue;
      }
      writer.println("      " + id + " ... " + ci[i].getDescription());
    }

    writer.println("  OPTIONS for signation:");

    writer.println("    " + PARAMETER_SIGNATURE_MODE + " <" + VALUE_SIGNATURE_MODE_BINARY + "|" + VALUE_SIGNATURE_MODE_TEXTUAL + ">");
    writer.println("      " + VALUE_SIGNATURE_MODE_BINARY + " ... signs the complete binary document");
    writer.println("      " + VALUE_SIGNATURE_MODE_TEXTUAL + " ... signs only the textual portion of the document");
    //writer.println("      " + VALUE_SIGNATURE_MODE_DETACHED + " ... signs the document using the binary mode and returns the xml signature of it.");
    writer.println("      " + VALUE_SIGNATURE_MODE_DETACHED_TEXT + " ... signs the document using the textual mode and returns the xml signature of it.");

    writer.print("    " + PARAMETER_SIGNATURE_TYPE + " <");
    SignatureTypes sig_types = SignatureTypes.getInstance();
    SettingsReader settings = SettingsReader.getInstance();
    Set types_array = sig_types.getSignatureTypes();
    Iterator it = types_array.iterator();
    while (it.hasNext())
    {
      String type = (String) it.next();
      writer.print(type);
      if (it.hasNext())
      {
        writer.print("|");
      }
    }
    writer.println(">");
    writer.println("      ... [optional] the profile to be used. If omitted, the default");
    writer.println("          profile is used.");
    String default_type = settings.getValueFromKey(SignatureTypes.DEFAULT_TYPE);
    it = types_array.iterator();
    while (it.hasNext())
    {
      String type = (String) it.next();
      String descr_key = SignatureTypes.SIG_OBJ + type + "." + SignatureTypes.SIG_DESCR;
      String type_descr = settings.getValueFromKey(descr_key);

      writer.println("      " + type + " ... " + (type.equals(default_type) ? "(default) " : "") + type_descr);
    }

    writer.println("    " + PARAMETER_USER_NAME + " <user_name> ... [optional] the user name");
    writer.println("    " + PARAMETER_USER_PASSWORD + " <password> ... [optional] the user password");

    writer.println("    " + PARAMETER_POS + " <position> ... [optional] the position of the signature block");
    writer.println("      position has the format [x:x_algo];[y:y_algo];[w:w_algo][p:p_algo];[f:f_algo]");
    writer.println("      if not present default is set to  x:auto;y:auto;w:auto;p:auto;f:0");
    writer.println("      x_algo:='auto'     ... automatic positioning x");
    writer.println("              floatvalue ... absolute x must be >= 0");
    writer.println("      y_algo:='auto'     ... automatic positioning y");
    writer.println("              floatvalue ... absolute y must be >= 0");
    writer.println("      w_algo:='auto'     ... automatic width");
    writer.println("              floatvalue ... absolute width must be > 0");
    writer.println("      p_algo:='auto'     ... automatic last page");
    writer.println("              'new'      ... new page");
    writer.println("              intvalue   ... pagenumber must be > 0 if p>number of pages in document p-->handled like p:'new'");
    writer.println("      f_algo  floatvalue ... consider footerline must be >= 0 (only if y_algo is auto and p_algo is not 'new')");

    writer.println("  OPTIONS for verification:");
    writer.println("    " + PARAMETER_VERIFY_WHICH + " <number> ... [optional] zero based number of the signature");
    writer.println("      to be verified. If omitted, all signatures are verified.");

    writer.println("  Example usage:");
    writer.println("    pdf-as " + PARAMETER_MODE + " " + VALUE_MODE_SIGN + " " + PARAMETER_CONNECTOR + " moa some_document.pdf");
    writer.println("    pdf-as " + PARAMETER_MODE + " " + VALUE_MODE_VERIFY + " some_document.pdf_out.pdf");
  }

  /**
   * Checks the value for correctness.
   * 
   * @param mode
   *          The parameter's value.
   * @return Returns true, if the value is correct, false otherwise.
   */
  protected static boolean checkMode(String mode)
  {
    return mode.equals(VALUE_MODE_SIGN) || mode.equals(VALUE_MODE_VERIFY);
  }

  /**
   * Checks the value for correctness.
   * 
   * @param signature_mode
   *          The parameter's value.
   * @return Returns true, if the value is correct, false otherwise.
   */
  protected static boolean checkSignatureMode(String signature_mode)
  {
    return signature_mode.equals(VALUE_SIGNATURE_MODE_BINARY) || signature_mode.equals(VALUE_SIGNATURE_MODE_TEXTUAL) || signature_mode.equals(VALUE_SIGNATURE_MODE_DETACHED)
        || signature_mode.equals(VALUE_SIGNATURE_MODE_DETACHED_TEXT);
  }

  /**
   * Checks the value for correctness.
   * 
   * @param connector
   *          The parameter's value.
   * @return Returns true, if the value is correct, false otherwise.
   * @throws ConnectorFactoryException
   *           F.e.
   */
  protected static boolean checkConnector(String connector) throws ConnectorFactoryException
  {
    return ConnectorFactory.isValidConnectorIdentifier(connector) && ConnectorFactory.isAvailableForCommandline(connector);
  }

  /**
   * Checks the value for correctness.
   * 
   * @param signature_type
   *          The parameter's value.
   * @return Returns true, if the value is correct, false otherwise.
   */
  protected static boolean checkSignatureType(String signature_type) throws SignatureTypesException
  {
     return SignatureTypes.getInstance().getSignatureTypes().contains(signature_type);
     
     // exthex: uuuaaaahhhhh WHY??? wprinz again?, dont do that. Use List.contains(o), please 
     // take a java course and read: http://www.amazon.de/Java-f%C3%BCr-Dummies-Barry-Burd/dp/382662999X
//     List types_array = sig_types.getSignatureTypes();
//     Iterator it = types_array.iterator();
//     while (it.hasNext())
//     {
//       String type = (String) it.next();
//       if (type.equals(signature_type))
//       {
//         return true;
//       }
//     }
//     return false;
  }

  /**
   * Translates the commandline argument to a PDF-AS-ID.
   * 
   * @param signature_mode
   *          The signator mode commandline argument.
   * @return Returns the corresponding PDFASID.
   */
  protected static PdfASID translateSignatureModeToPdfASID(String signature_mode)
  {
    if (signature_mode.equals(VALUE_SIGNATURE_MODE_BINARY))
    {
      return SignatorFactory.MOST_RECENT_BINARY_SIGNATOR_ID;
    }
    if (signature_mode.equals(VALUE_SIGNATURE_MODE_TEXTUAL))
    {
      return SignatorFactory.MOST_RECENT_TEXTUAL_SIGNATOR_ID;
    }
    if (signature_mode.equals(VALUE_SIGNATURE_MODE_DETACHED))
    {
      return SignatorFactory.MOST_RECENT_DETACHED_SIGNATOR_ID;
    }
    if (signature_mode.equals(VALUE_SIGNATURE_MODE_DETACHED_TEXT))
    {
      return SignatorFactory.MOST_RECENT_DETACHEDTEXT_SIGNATOR_ID;
    }
    return null;
  }

  /**
   * Formats the verification results.
   * 
   * @param results
   *          The List of SignatureResponse verification results.
   * @param writer
   *          The output sink to write the formatted text to.
   * @throws SettingNotFoundException
   *           Forwarded exception.
   */
  protected static void formatVerifyResults(List results, PrintWriter writer) throws SettingNotFoundException
  {
    Iterator it = results.iterator();
    while (it.hasNext())
    {
      SignatureResponse result = (SignatureResponse) it.next();
      formatSignatureResponse(result, writer);

      if (it.hasNext())
      {
        writer.println();
      }
    }
  }
  
  /**
   * Formats the verification results for debugging. Returns  0 if no error occurs or the sum of all error-codes.
   * 
   * @param results
   *         
   * @param writer
   *          The output sink to write the formatted text to.
   * @throws SettingNotFoundException
   *           Forwarded exception.
   */
  protected static int debugVerifyResults(List results) throws SettingNotFoundException
  {
	int toreturn = 0;
    Iterator it = results.iterator();
    while (it.hasNext())
    {
      SignatureResponse result = (SignatureResponse) it.next();
      
      toreturn += Integer.valueOf(result.getSignatureCheckCode()).intValue();
    }
    return toreturn;
  }
  

  /**
   * Formats the SignatureResponse.
   * 
   * @param result
   *          The SignatureResponse to be printed.
   * @param writer
   *          The output sink to write the formatted text to.
   * @throws SettingNotFoundException
   *           Forwarded exception.
   */
  public static void formatSignatureResponse(SignatureResponse result, PrintWriter writer) throws SettingNotFoundException
  {

    writer.println("  Zertifikat:");
    writer.println("    Signator:     " + result.getX509SubjectName());
    writer.println("    Aussteller:   " + result.getX509IssuerName());
    writer.println("    Seriennummer: " + result.getX509SerialNumber());
    List public_properties = result.getPublicProperties();
    Iterator it = public_properties.iterator();
    while (it.hasNext())
    {
      String public_property = (String) it.next();
      writer.println("    Eigenschaft:  " + public_property);
    }

    writer.println("  Zertifikat-Check:");
    writer.println("    " + result.getCertificateCheckCode() + " - " + result.getCertificateCheckInfo());
    writer.println("  Signatur-Check:");
    writer.println("    " + result.getSignatureCheckCode() + " - " + result.getSignatureCheckInfo());
    writer.println("  Manifest-Check:");
    writer.println("    " + result.getSignatureManifestCheckCode() + " - " + result.getSignatureManifestCheckInfo());
  }

}