/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at
 * trunk/opends/resource/legal-notices/OpenDS.LICENSE
 * or https://OpenDS.dev.java.net/OpenDS.LICENSE.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at
 * trunk/opends/resource/legal-notices/OpenDS.LICENSE.  If applicable,
 * add the following below this CDDL HEADER, with the fields enclosed
 * by brackets "[]" replaced with your own identifying * information:
 *      Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 *
 *
 *      Portions Copyright 2006 Sun Microsystems, Inc.
 */
package org.opends.server.tools;



import java.io.ByteArrayOutputStream;
import java.io.File;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedList;

import org.opends.server.config.ConfigFileHandler;
import org.opends.server.core.DirectoryServer;
import org.opends.server.types.DN;
import org.opends.server.types.ExistingFileBehavior;
import org.opends.server.types.LDIFExportConfig;
import org.opends.server.util.LDIFWriter;
import org.opends.server.util.PasswordReader;
import org.opends.server.util.args.ArgumentException;
import org.opends.server.util.args.ArgumentParser;
import org.opends.server.util.args.BooleanArgument;
import org.opends.server.util.args.FileBasedArgument;
import org.opends.server.util.args.IntegerArgument;
import org.opends.server.util.args.StringArgument;

import static org.opends.server.messages.MessageHandler.*;
import static org.opends.server.messages.ToolMessages.*;
import static org.opends.server.util.DynamicConstants.*;
import static org.opends.server.util.StaticUtils.*;



/**
 * This class provides a very simple mechanism for installing the OpenDS
 * Directory Service.  It performs the following tasks:
 * <UL>
 *   <LI>Ask the user what base DN should be used for the data</LI>
 *   <LI>Ask the user whether to create the base entry, or to import LDIF</LI>
 *   <LI>Ask the user for the LDAP port and make sure it's available</LI>
 *   <LI>Ask the user for the default root DN and password</LI>
 *   <LI>Ask the user if they want to start the server when done installing</LI>
 * </UL>
 */
public class InstallDS
{
  /**
   * The fully-qualified name of this class for debugging purposes.
   */
  private static final String CLASS_NAME = "org.opends.server.tools.InstallDS";



  /**
   * The position at which to wrap long lines.
   */
  public static final int MAX_LINE_WIDTH = 79;



  /**
   * Indicates whether we think we're running on a Windows system.
   */
  private static boolean isWindows = false;



  /**
   * The version string for the server.
   */
  private static String versionString = "OpenDS Directory Service";



  /**
   * The name of the program used to launch this installation process.
   */
  private static String programName = "setup";



  /**
   * Invokes the <CODE>installMain</CODE> method with the provided arguments.
   *
   * @param  args  The command-line arguments to use for this program.
   */
  public static void main(String[] args)
  {
    int exitCode = installMain(args);
    if (exitCode != 0)
    {
      System.exit(exitCode);
    }
  }



  /**
   * Prompts the user for the necessary information, installs the OpenDS
   * software in the appropriate location, and gives it the desired
   * configuration.
   *
   * @param  args  The command-line arguments to use for this program.
   *
   * @return  A value of zero if the installation process was successful, or a
   *          nonzero value if a problem occurred.
   */
  public static int installMain(String[] args)
  {
    // Determine whether we think we're running on Windows.
    String osName = System.getProperty("os.name");
    if ((osName != null) && (osName.toLowerCase().indexOf("windows") >= 0))
    {
      isWindows = true;
    }


    // Construct the product version string and the setup filename.
    versionString = PRODUCT_NAME + " " + MAJOR_VERSION + "." + MINOR_VERSION;
    if ((VERSION_QUALIFIER == null) || (VERSION_QUALIFIER.length() == 0))
    {
      versionString += "." + POINT_VERSION;
    }
    else
    {
      versionString += VERSION_QUALIFIER;
    }

    if (isWindows)
    {
      programName = "setup.bat";
    }
    else
    {
      programName = "setup.sh";
    }


    // Create and initialize the argument parser for this program.
    ArgumentParser argParser = new ArgumentParser(CLASS_NAME, false);
    BooleanArgument   addBaseEntry;
    BooleanArgument   testOnly;
    BooleanArgument   showUsage;
    BooleanArgument   silentInstall;
    BooleanArgument   skipPortCheck;
    FileBasedArgument rootPWFile;
    IntegerArgument   ldapPort;
    StringArgument    baseDN;
    StringArgument    configClass;
    StringArgument    configFile;
    StringArgument    importLDIF;
    StringArgument    progName;
    StringArgument    rootDN;
    StringArgument    rootPWString;

    try
    {
      testOnly = new BooleanArgument("test", 't', "testOnly",
                                     MSGID_INSTALLDS_DESCRIPTION_TESTONLY);
      testOnly.setHidden(true);
      argParser.addArgument(testOnly);

      progName = new StringArgument("progname", 'P', "programName", false,
                                    false, true, "{programName}", programName,
                                    null, MSGID_INSTALLDS_DESCRIPTION_PROGNAME);
      progName.setHidden(true);
      argParser.addArgument(progName);

      configFile = new StringArgument("configfile", 'c', "configFile", false,
                                      false, true, "{configFile}", null, null,
                                      MSGID_INSTALLDS_DESCRIPTION_CONFIG_FILE);
      argParser.addArgument(configFile);

      configClass = new StringArgument("configclass", 'C', "configClass", false,
                             false, true, "{configClass}",
                             ConfigFileHandler.class.getName(), null,
                             MSGID_INSTALLDS_DESCRIPTION_CONFIG_CLASS);
      argParser.addArgument(configClass);

      silentInstall = new BooleanArgument("silent", 's', "silentInstall",
                                          MSGID_INSTALLDS_DESCRIPTION_SILENT);
      argParser.addArgument(silentInstall);

      baseDN = new StringArgument("basedn", 'b', "baseDN", false, true, true,
                                  "{baseDN}", "dc=example,dc=com", null,
                                  MSGID_INSTALLDS_DESCRIPTION_BASEDN);
      argParser.addArgument(baseDN);

      addBaseEntry = new BooleanArgument("addbase", 'a', "addBaseEntry",
                                         MSGID_INSTALLDS_DESCRIPTION_ADDBASE);
      argParser.addArgument(addBaseEntry);

      importLDIF = new StringArgument("importldif", 'i', "importLDIF", false,
                                      true, true, "{ldifFile}", null, null,
                                      MSGID_INSTALLDS_DESCRIPTION_IMPORTLDIF);
      argParser.addArgument(importLDIF);

      ldapPort = new IntegerArgument("ldapport", 'p', "ldapPort", false, false,
                                     true, "{port}", 389, null, true, 1, true,
                                     65535,
                                     MSGID_INSTALLDS_DESCRIPTION_LDAPPORT);
      argParser.addArgument(ldapPort);

      skipPortCheck = new BooleanArgument("skipportcheck", 'S', "skipPortCheck",
                                          MSGID_INSTALLDS_DESCRIPTION_SKIPPORT);
      argParser.addArgument(skipPortCheck);

      rootDN = new StringArgument("rootdn", 'D', "rootUserDN", false, true,
                                  true, "{rootDN}", "cn=Directory Manager",
                                  null, MSGID_INSTALLDS_DESCRIPTION_ROOTDN);
      argParser.addArgument(rootDN);

      rootPWString = new StringArgument("rootpwstring", 'w', "rootUserPassword",
                                        false, false, true, "{password}", null,
                                        null,
                                        MSGID_INSTALLDS_DESCRIPTION_ROOTPW);
      argParser.addArgument(rootPWString);

      rootPWFile = new FileBasedArgument("rootpwfile", 'W',
                            "rootUserPasswordFile", false, false, "{filename}",
                            null, null, MSGID_INSTALLDS_DESCRIPTION_ROOTPWFILE);
      argParser.addArgument(rootPWFile);

      showUsage = new BooleanArgument("help", 'H', "help",
                                      MSGID_INSTALLDS_DESCRIPTION_HELP);
      argParser.addArgument(showUsage);
      argParser.setUsageArgument(showUsage);
    }
    catch (ArgumentException ae)
    {
      System.err.println(wrapText(ae.getMessage(), MAX_LINE_WIDTH));
      System.err.println(argParser.getUsage());
      return 1;
    }


    // Parse all of the configuration arguments.
    try
    {
      argParser.parseArguments(args);
    }
    catch (ArgumentException ae)
    {
      System.err.println(wrapText(ae.getMessage(), MAX_LINE_WIDTH));
      System.err.println(argParser.getUsage());
      return 1;
    }


    // If either the showUsage or testOnly arguments were provided, then we're
    // done.
    if (showUsage.isPresent() || testOnly.isPresent())
    {
      return 0;
    }


    // Make sure the path to the configuration file was given.
    String configFileName;
    if (configFile.isPresent())
    {
      configFileName = configFile.getValue();
    }
    else
    {
      int    msgID   = MSGID_INSTALLDS_NO_CONFIG_FILE;
      String message = getMessage(msgID, configFile.getLongIdentifier());
      System.err.println(wrapText(message, MAX_LINE_WIDTH));
      return 1;
    }


    // Get the configuration handler class name.
    String configClassName = configClass.getValue();


    // If this isn't a silent install, then print the version string.
    if (! silentInstall.isPresent())
    {
      System.out.println(versionString);
      System.out.println();

      int    msgID   = MSGID_INSTALLDS_INITIALIZING;
      String message = getMessage(msgID);
      System.out.println(wrapText(message, MAX_LINE_WIDTH));
    }


    // Perform a base-level initialization that will be required to get
    // minimal functionality like DN parsing to work.
    DirectoryServer directoryServer = DirectoryServer.getInstance();
    directoryServer.bootstrapClient();

    try
    {
      directoryServer.initializeJMX();
    }
    catch (Exception e)
    {
      int    msgID   = MSGID_INSTALLDS_CANNOT_INITIALIZE_JMX;
      String message = getMessage(msgID,
                                  String.valueOf(configFile.getValue()),
                                  e.getMessage());
      System.err.println(wrapText(message, MAX_LINE_WIDTH));
      return 1;
    }

    try
    {
      directoryServer.initializeConfiguration(configClass.getValue(),
                                              configFile.getValue());
    }
    catch (Exception e)
    {
      int    msgID   = MSGID_INSTALLDS_CANNOT_INITIALIZE_CONFIG;
      String message = getMessage(msgID,
                                  String.valueOf(configFile.getValue()),
                                  e.getMessage());
      System.err.println(wrapText(message, MAX_LINE_WIDTH));
      return 1;
    }

    try
    {
      directoryServer.initializeSchema();
    }
    catch (Exception e)
    {
      int    msgID   = MSGID_INSTALLDS_CANNOT_INITIALIZE_SCHEMA;
      String message = getMessage(msgID,
                                  String.valueOf(configFile.getValue()),
                                  e.getMessage());
      System.err.println(wrapText(message, MAX_LINE_WIDTH));
      return 1;
    }


    // Determine the directory base DN.
    LinkedList<DN> baseDNs;
    if (baseDN.isPresent())
    {
      baseDNs = new LinkedList<DN>();
      for (String s : baseDN.getValues())
      {
        try
        {
          baseDNs.add(DN.decode(s));
        }
        catch (Exception e)
        {
          int    msgID   = MSGID_INSTALLDS_CANNOT_PARSE_DN;
          String message = getMessage(msgID, s, e.getMessage());
          System.err.println(wrapText(message, MAX_LINE_WIDTH));
          return 1;
        }
      }
    }
    else if (silentInstall.isPresent())
    {
      try
      {
        baseDNs = new LinkedList<DN>();
        baseDNs.add(DN.decode(baseDN.getDefaultValue()));
      }
      catch (Exception e)
      {
        int    msgID   = MSGID_INSTALLDS_CANNOT_PARSE_DN;
        String message = getMessage(msgID, baseDN.getDefaultValue(),
                                    e.getMessage());
        System.err.println(wrapText(message, MAX_LINE_WIDTH));
        return 1;
      }
    }
    else
    {
      int    msgID   = MSGID_INSTALLDS_PROMPT_BASEDN;
      String message = getMessage(msgID);

      baseDNs = new LinkedList<DN>();
      baseDNs.add(promptForDN(message, baseDN.getDefaultValue()));
    }


    // Determine whether to import data from LDIF.
    LinkedList<String> ldifFiles;
    if (silentInstall.isPresent())
    {
      if (importLDIF.isPresent())
      {
        ldifFiles = importLDIF.getValues();
      }
      else
      {
        ldifFiles = null;
      }
    }
    else if (importLDIF.isPresent())
    {
      ldifFiles = importLDIF.getValues();
    }
    else if (! baseDN.isPresent())
    {
      int     msgID          = MSGID_INSTALLDS_PROMPT_IMPORT;
      String  message        = getMessage(msgID);
      boolean importFromLDIF = promptForBoolean(message, false);

      if (importFromLDIF)
      {
        msgID   = MSGID_INSTALLDS_PROMPT_IMPORT_FILE;
        message = getMessage(msgID);

        ldifFiles = new LinkedList<String>();
        ldifFiles.add(promptForString(message, null));
      }
      else
      {
        ldifFiles = null;
      }
    }
    else
    {
      ldifFiles = null;
    }



    // Determine whether to add the base entry.
    boolean addBase;
    if (addBaseEntry.isPresent())
    {
      addBase = true;

      if ((ldifFiles != null) && (! ldifFiles.isEmpty()))
      {
        int msgID = MSGID_INSTALLDS_TWO_CONFLICTING_ARGUMENTS;
        String message = getMessage(msgID, addBaseEntry.getLongIdentifier(),
                                    importLDIF.getLongIdentifier());
        System.err.println(wrapText(message, MAX_LINE_WIDTH));
        return 1;
      }
    }
    else if (silentInstall.isPresent() ||
             ((ldifFiles != null) && (! ldifFiles.isEmpty())))
    {
      addBase = false;
    }
    else if (baseDN.isPresent())
    {
      addBase = false;
    }
    else
    {
      int    msgID   = MSGID_INSTALLDS_PROMPT_ADDBASE;
      String message = getMessage(msgID, baseDNs.getFirst().toString());

      addBase = promptForBoolean(message, true);
    }


    // Determine the LDAP port number.
    int ldapPortNumber;
    if (silentInstall.isPresent() || ldapPort.isPresent())
    {
      try
      {
        ldapPortNumber = ldapPort.getIntValue();
      }
      catch (ArgumentException ae)
      {
        System.err.println(wrapText(ae.getMessage(), MAX_LINE_WIDTH));
        return 1;
      }
    }
    else
    {
      while (true)
      {
        int    msgID   = MSGID_INSTALLDS_PROMPT_LDAPPORT;
        String message = getMessage(msgID);
        ldapPortNumber = promptForInteger(message, 389, 1, 65535);

        if (! skipPortCheck.isPresent())
        {
          try
          {
            InetSocketAddress socketAddress =
                                   new InetSocketAddress(ldapPortNumber);
            ServerSocket serverSocket = new ServerSocket();
            serverSocket.setReuseAddress(true);
            serverSocket.bind(socketAddress);
            serverSocket.close();
            break;
          }
          catch (Exception e)
          {
            if (ldapPortNumber <= 1024)
            {
              msgID   = MSGID_INSTALLDS_CANNOT_BIND_TO_PRIVILEGED_PORT;
              message = getMessage(msgID, ldapPortNumber, e.getMessage());
              System.err.println(wrapText(message, MAX_LINE_WIDTH));
            }
            else
            {
              msgID   = MSGID_INSTALLDS_CANNOT_BIND_TO_PORT;
              message = getMessage(msgID, ldapPortNumber, e.getMessage());
              System.err.println(wrapText(message, MAX_LINE_WIDTH));
            }
          }
        }
      }
    }


    // Determine the initial root user DN.
    LinkedList<DN> rootDNs;
    if (rootDN.isPresent())
    {
      rootDNs = new LinkedList<DN>();
      for (String s : rootDN.getValues())
      {
        try
        {
          rootDNs.add(DN.decode(s));
        }
        catch (Exception e)
        {
          int    msgID   = MSGID_INSTALLDS_CANNOT_PARSE_DN;
          String message = getMessage(msgID, s, e.getMessage());
          System.err.println(wrapText(message, MAX_LINE_WIDTH));
          return 1;
        }
      }
    }
    else if (silentInstall.isPresent())
    {
      rootDNs = new LinkedList<DN>();
      try
      {
        rootDNs.add(DN.decode(rootDN.getDefaultValue()));
      }
      catch (Exception e)
      {
        int    msgID   = MSGID_INSTALLDS_CANNOT_PARSE_DN;
        String message = getMessage(msgID, rootDN.getDefaultValue(),
                                    e.getMessage());
        System.err.println(wrapText(message, MAX_LINE_WIDTH));
        return 1;
      }
    }
    else
    {
      int    msgID   = MSGID_INSTALLDS_PROMPT_ROOT_DN;
      String message = getMessage(msgID);

      rootDNs = new LinkedList<DN>();
      rootDNs.add(promptForDN(message, rootDN.getDefaultValue()));
    }


    // Determine the initial root user password.
    String rootPassword;
    if (rootPWString.isPresent())
    {
      rootPassword = rootPWString.getValue();

      if (rootPWFile.isPresent())
      {
        int msgID = MSGID_INSTALLDS_TWO_CONFLICTING_ARGUMENTS;
        String message = getMessage(msgID, rootPWString.getLongIdentifier(),
                                    rootPWFile.getLongIdentifier());
        System.err.println(wrapText(message, MAX_LINE_WIDTH));
        return 1;
      }
    }
    else if (rootPWFile.isPresent())
    {
      rootPassword = rootPWFile.getValue();
    }
    else if (silentInstall.isPresent())
    {
      int    msgID   = MSGID_INSTALLDS_NO_ROOT_PASSWORD;
      String message = getMessage(msgID, rootPWString.getLongIdentifier(),
                                  rootPWFile.getLongIdentifier());
      System.err.println(wrapText(message, MAX_LINE_WIDTH));
      return 1;
    }
    else
    {
      int    msgID         = MSGID_INSTALLDS_PROMPT_ROOT_PASSWORD;
      String initialPrompt = getMessage(msgID);

      msgID = MSGID_INSTALLDS_PROMPT_CONFIRM_ROOT_PASSWORD;
      String confirmPrompt = getMessage(msgID);

      rootPassword =
           new String(promptForPassword(initialPrompt, confirmPrompt));
    }


    // At this point, we should be able to invoke the ConfigureDS utility to
    // apply the requested configuration.
    ArrayList<String> argList = new ArrayList<String>();
    argList.add("-C");
    argList.add(configClassName);
    argList.add("-c");
    argList.add(configFileName);
    argList.add("-p");
    argList.add(String.valueOf(ldapPortNumber));

    for (DN dn : baseDNs)
    {
      argList.add("-b");
      argList.add(dn.toString());
    }

    for (DN dn : rootDNs)
    {
      argList.add("-D");
      argList.add(dn.toString());
    }

    argList.add("-w");
    argList.add(rootPassword);

    String[] configureDSArguments = new String[argList.size()];
    argList.toArray(configureDSArguments);

    if (! silentInstall.isPresent())
    {
      System.out.println();

      String message = getMessage(MSGID_INSTALLDS_STATUS_CONFIGURING_DS);
      System.out.println(wrapText(message, MAX_LINE_WIDTH));
    }

    int returnValue = ConfigureDS.configMain(configureDSArguments);
    if (returnValue != 0)
    {
      return returnValue;
    }


    // If we should import data or add the base entry, then do so now.
    if (addBase)
    {
      // Create a temporary LDIF file that will hold the entry to add.
      if (! silentInstall.isPresent())
      {
        String message = getMessage(MSGID_INSTALLDS_STATUS_CREATING_BASE_LDIF);
        System.out.println(wrapText(message, MAX_LINE_WIDTH));
      }

      try
      {
        File   ldifFile     = File.createTempFile("opends-base-entry", ".ldif");
        String ldifFilePath = ldifFile.getAbsolutePath();
        ldifFile.deleteOnExit();

        LDIFExportConfig exportConfig =
             new LDIFExportConfig(ldifFilePath, ExistingFileBehavior.OVERWRITE);
        LDIFWriter writer = new LDIFWriter(exportConfig);

        for (DN dn : baseDNs)
        {
          writer.writeEntry(createEntry(dn));
        }

        writer.close();

        if (ldifFiles == null)
        {
          ldifFiles = new LinkedList<String>();
          ldifFiles.add(ldifFilePath);
        }
      }
      catch (Exception e)
      {
        int    msgID   = MSGID_INSTALLDS_CANNOT_CREATE_BASE_ENTRY_LDIF;
        String message = getMessage(msgID, String.valueOf(e));

        System.err.println(wrapText(message, MAX_LINE_WIDTH));
        return 1;
      }
    }

    if ((ldifFiles != null) && (! ldifFiles.isEmpty()))
    {
      if (! silentInstall.isPresent())
      {
        String message = getMessage(MSGID_INSTALLDS_STATUS_IMPORTING_LDIF);
        System.out.println(wrapText(message, MAX_LINE_WIDTH));
      }

      // Use the ImportLDIF tool to perform the import.
      argList = new ArrayList<String>();
      argList.add("-C");
      argList.add(configClassName);
      argList.add("-f");
      argList.add(configFileName);
      argList.add("-n");
      argList.add("userRoot");

      for (String s : ldifFiles)
      {
        argList.add("-l");
        argList.add(s);
      }

      if (addBase)
      {
        argList.add("-q");
      }

      String[] importLDIFArguments = new String[argList.size()];
      argList.toArray(importLDIFArguments);

      returnValue = ImportLDIF.mainImportLDIF(importLDIFArguments);
      if (returnValue != 0)
      {
        return returnValue;
      }
      else
      {
        String message = getMessage(MSGID_INSTALLDS_IMPORT_SUCCESSFUL);
        System.out.println(wrapText(message, MAX_LINE_WIDTH));
      }
    }


    // If we've gotten here, then everything seems to have gone smoothly.
    if (! silentInstall.isPresent())
    {
      String message = getMessage(MSGID_INSTALLDS_STATUS_SUCCESS);
      System.out.println(wrapText(message, MAX_LINE_WIDTH));
    }

    return 0;
  }



  /**
   * Interactively prompts (on standard output) the user to provide a Boolean
   * value.  The answer provided must be one of "true", "t", "yes", "y",
   * "false", "f", "no", or "n", ignoring capitalization.  It will keep
   * prompting until an acceptable value is given.
   *
   * @param  prompt        The prompt to present to the user.
   * @param  defaultValue  The default value to assume if the user presses ENTER
   *                       without typing anything, or <CODE>null</CODE> if
   *                       there should not be a default and the user must
   *                       explicitly provide a value.
   *
   * @return  The <CODE>boolean</CODE> value read from the user input.
   */
  private static boolean promptForBoolean(String prompt, Boolean defaultValue)
  {
    String wrappedPrompt = wrapText(prompt, MAX_LINE_WIDTH);

    while (true)
    {
      System.out.println();
      System.out.println(wrappedPrompt);

      if (defaultValue == null)
      {
        System.out.print(": ");
      }
      else
      {
        System.out.print("[");

        if (defaultValue)
        {
          System.out.print(getMessage(MSGID_INSTALLDS_PROMPT_VALUE_YES));
        }
        else
        {
          System.out.print(getMessage(MSGID_INSTALLDS_PROMPT_VALUE_NO));
        }

        System.out.print("]: ");
      }

      System.out.flush();

      String response = toLowerCase(readLine());
      if (response.equals("true") || response.equals("yes") ||
          response.equals("t") || response.equals("y"))
      {
        return true;
      }
      else if (response.equals("false") || response.equals("no") ||
               response.equals("f") || response.equals("n"))
      {
        return false;
      }
      else if (response.equals(""))
      {
        if (defaultValue == null)
        {
          String message = getMessage(MSGID_INSTALLDS_INVALID_YESNO_RESPONSE);
          System.err.println(wrapText(message, MAX_LINE_WIDTH));
        }
        else
        {
          return defaultValue;
        }
      }
      else
      {
        String message = getMessage(MSGID_INSTALLDS_INVALID_YESNO_RESPONSE);
        System.err.println(wrapText(message, MAX_LINE_WIDTH));
      }
    }
  }



  /**
   * Interactively prompts (on standard output) the user to provide an integer
   * value.  The answer provided must be parseable as an integer, and may be
   * required to be within a given set of bounds.  It will keep prompting until
   * an acceptable value is given.
   *
   * @param  prompt        The prompt to present to the user.
   * @param  defaultValue  The default value to assume if the user presses ENTER
   *                       without typing anything, or <CODE>null</CODE> if
   *                       there should not be a default and the user must
   *                       explicitly provide a value.
   * @param  lowerBound    The lower bound that should be enforced, or
   *                       <CODE>null</CODE> if there is none.
   * @param  upperBound    The upper bound that should be enforced, or
   *                       <CODE>null</CODE> if there is none.
   *
   * @return  The <CODE>int</CODE> value read from the user input.
   */
  private static int promptForInteger(String prompt, Integer defaultValue,
                                      Integer lowerBound, Integer upperBound)
  {
    String wrappedPrompt = wrapText(prompt, MAX_LINE_WIDTH);

    while (true)
    {
      System.out.println();
      System.out.println(wrappedPrompt);

      if (defaultValue == null)
      {
        System.out.print(": ");
      }
      else
      {
        System.out.print("[");
        System.out.print(defaultValue);
        System.out.print("]: ");
      }

      System.out.flush();

      String response = readLine();
      if (response.equals(""))
      {
        if (defaultValue == null)
        {
          String message = getMessage(MSGID_INSTALLDS_INVALID_INTEGER_RESPONSE);
          System.err.println(wrapText(message, MAX_LINE_WIDTH));
        }
        else
        {
          return defaultValue;
        }
      }
      else
      {
        try
        {
          int intValue = Integer.parseInt(response);
          if ((lowerBound != null) && (intValue < lowerBound))
          {
            String message =
                        getMessage(MSGID_INSTALLDS_INTEGER_BELOW_LOWER_BOUND,
                                   lowerBound);
            System.err.println(wrapText(message, MAX_LINE_WIDTH));
          }
          else if ((upperBound != null) && (intValue > upperBound))
          {
            String message =
                        getMessage(MSGID_INSTALLDS_INTEGER_ABOVE_UPPER_BOUND,
                                   upperBound);
            System.err.println(wrapText(message, MAX_LINE_WIDTH));
          }
          else
          {
            return intValue;
          }
        }
        catch (NumberFormatException nfe)
        {
          String message = getMessage(MSGID_INSTALLDS_INVALID_INTEGER_RESPONSE);
          System.err.println(wrapText(message, MAX_LINE_WIDTH));
        }
      }
    }
  }



  /**
   * Interactively prompts (on standard output) the user to provide a DN value.
   * Any non-empty string will be allowed if it can be parsed as a valid DN (the
   * empty string will indicate that the default should be used, if there is
   * one).
   *
   * @param  prompt        The prompt to present to the user.
   * @param  defaultValue  The default value to assume if the user presses ENTER
   *                       without typing anything, or <CODE>null</CODE> if
   *                       there should not be a default and the user must
   *                       explicitly provide a value.
   *
   * @return  The DN value read from the user.
   */
  private static DN promptForDN(String prompt, String defaultValue)
  {
    String wrappedPrompt = wrapText(prompt, MAX_LINE_WIDTH);

    while (true)
    {
      System.out.println();
      System.out.println(wrappedPrompt);

      if (defaultValue == null)
      {
        System.out.print(": ");
      }
      else
      {
        System.out.print("[");
        System.out.print(defaultValue);
        System.out.print("]: ");
      }

      System.out.flush();

      String response = readLine();
      if (response.equals(""))
      {
        if (defaultValue == null)
        {
          String message = getMessage(MSGID_INSTALLDS_INVALID_DN_RESPONSE);
          System.err.println(wrapText(message, MAX_LINE_WIDTH));
        }
        else
        {
          try
          {
            return DN.decode(defaultValue);
          }
          catch (Exception e)
          {
            String message = getMessage(MSGID_INSTALLDS_INVALID_DN_RESPONSE);
            System.err.println(wrapText(message, MAX_LINE_WIDTH));
          }
        }
      }
      else
      {
        try
        {
          return DN.decode(response);
        }
        catch (Exception e)
        {
          String message = getMessage(MSGID_INSTALLDS_INVALID_DN_RESPONSE);
          System.err.println(wrapText(message, MAX_LINE_WIDTH));
        }
      }
    }
  }



  /**
   * Interactively prompts (on standard output) the user to provide a string
   * value.  Any non-empty string will be allowed (the empty string will
   * indicate that the default should be used, if there is one).
   *
   * @param  prompt        The prompt to present to the user.
   * @param  defaultValue  The default value to assume if the user presses ENTER
   *                       without typing anything, or <CODE>null</CODE> if
   *                       there should not be a default and the user must
   *                       explicitly provide a value.
   *
   * @return  The string value read from the user.
   */
  private static String promptForString(String prompt, String defaultValue)
  {
      System.out.println();
    String wrappedPrompt = wrapText(prompt, MAX_LINE_WIDTH);

    while (true)
    {
      System.out.println(wrappedPrompt);

      if (defaultValue == null)
      {
        System.out.print(": ");
      }
      else
      {
        System.out.print("[");
        System.out.print(defaultValue);
        System.out.print("]: ");
      }

      System.out.flush();

      String response = readLine();
      if (response.equals(""))
      {
        if (defaultValue == null)
        {
          String message = getMessage(MSGID_INSTALLDS_INVALID_STRING_RESPONSE);
          System.err.println(wrapText(message, MAX_LINE_WIDTH));
        }
        else
        {
          return defaultValue;
        }
      }
      else
      {
        return response;
      }
    }
  }



  /**
   * Interactively prompts (on standard output) the user to provide a string
   * value.  The response that the user provides will not be echoed, and it must
   * be entered twice for confirmation.  No default value will be allowed, and
   * the string entered must contain at least one character.
   *
   * @param  initialPrompt  The initial prompt to present to the user.
   * @param  reEntryPrompt  The prompt to present to the user when requesting
   *                        that the value be re-entered for confirmation.
   *
   * @return  The string value read from the user.
   */
  private static char[] promptForPassword(String initialPrompt,
                                          String reEntryPrompt)
  {
    String wrappedInitialPrompt = wrapText(initialPrompt, MAX_LINE_WIDTH);
    String wrappedReEntryPrompt = wrapText(reEntryPrompt, MAX_LINE_WIDTH);

    while (true)
    {
      System.out.println();
      System.out.print(wrappedInitialPrompt);
      System.out.print(": ");
      System.out.flush();

      char[] password = PasswordReader.readPassword();
      if ((password == null) || (password.length == 0))
      {
        String message = getMessage(MSGID_INSTALLDS_INVALID_PASSWORD_RESPONSE);
        System.err.println(wrapText(message, MAX_LINE_WIDTH));
      }
      else
      {
        System.out.print(wrappedReEntryPrompt);
        System.out.print(": ");
        System.out.flush();
        char[] confirmedPassword = PasswordReader.readPassword();
        if ((confirmedPassword == null) ||
            (! Arrays.equals(password, confirmedPassword)))
        {
          String message = getMessage(MSGID_INSTALLDS_PASSWORDS_DONT_MATCH);
          System.err.println(wrapText(message, MAX_LINE_WIDTH));
        }
        else
        {
          return password;
        }
      }
    }
  }



  /**
   * Reads a line of text from standard input.
   *
   * @return  The line of text read from standard input, or <CODE>null</CODE>
   *          if the end of the stream is reached or an error occurs while
   *          attempting to read the response.
   */
  private static String readLine()
  {
    try
    {
      ByteArrayOutputStream baos = new ByteArrayOutputStream();

      while (true)
      {
        int b = System.in.read();
        if ((b < 0) || (b == '\n'))
        {
          break;
        }
        else if (b == '\r')
        {
          int b2 = System.in.read();
          if (b2 == '\n')
          {
            break;
          }
          else
          {
            baos.write(b);
            baos.write(b2);
          }
        }
        else
        {
          baos.write(b);
        }
      }

      return new String(baos.toByteArray(), "UTF-8");
    }
    catch (Exception e)
    {
      String message = getMessage(MSGID_INSTALLDS_ERROR_READING_FROM_STDIN,
                                  String.valueOf(e));
      System.err.println(wrapText(message, MAX_LINE_WIDTH));

      return null;
    }
  }
}