package INSTALL::query;

use INSTALL::common;
use strict;

my $CONST_Columns;
my $CONST_Rows;
my $CONST_Initialized;

BEGIN {
  $CONST_Columns = 80;
  $CONST_Rows = 24;
}

#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# Internal functions
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

# On solaris, background processes (which do not have control of the tty
# are unable to invoke stty -- it will block indefinitely).  As a result,
# I have added this function to be invoked once and only once, after the
# code has initialized, and then only in interactive mode.  Anything else
# will result in hanging characteristics.
sub Initialize {
  if ((not $CONST_Initialized) && interactive) {
    my @stty_output = split("\n",`stty -a 2> /dev/null`);

    foreach(@stty_output) {
      if (/columns\s+[=]?\s*([0-9]+)/) {
        my $value = $1;

        if ($value > 0) {
          $CONST_Columns = $value;
        }
      }
      elsif (/([0-9]+)\s+columns/) { # AIX's twisted format.
        my $value = $1;

        if ($value > 0) {
          $CONST_Columns = $value;
        }
      }

      if (/rows\s+[=]?\s*([0-9]+)/) {
        my $value = $1;

        if ($value > 0) {
          $CONST_Rows = $value;
        }
      }
      elsif (/([0-9]+)\s+rows/) { # AIX's twisted format.
        my $value = $1;

        if ($value > 0) {
          $CONST_Rows = $value;
        }
      }
    }
  }

#   print "Columns: $CONST_Columns\n";
#   print "Rows: $CONST_Rows\n";

  $CONST_Initialized = 1;
}

#------------------------------------------------------------------------------
# Confirms / enforces that each item of the list is only listed once in the
# output.
#------------------------------------------------------------------------------
sub squeeze_list
{
  my %UniqueMap;
  my @result;

  foreach my $item (@_) {
    unless (exists $UniqueMap{$item}) {
      $UniqueMap{$item} = undef;
      push @result, $item;
    }
  }

  return(@result);
}

#------------------------------------------------------------------------------
# Constructs a string which is the result of repeating <repeat_text>, <count>
# times.
#------------------------------------------------------------------------------
sub repeat_text
{
  ($#_ == 1) || die "Invalid number of arguments.";

  my ($repeat_text, $count) = @_;

  return($repeat_text x $count);
}

#------------------------------------------------------------------------------
# Places <text> into a justified region of <justify_length>, surrounded by
# <terminal_left> and <terminal_right> characters.  The <text> may span several
# lines.
#------------------------------------------------------------------------------
sub justify_text
{
  sub justify_text_block
{
    ($#_ == 3) || die "Invalid number of arguments.";

    my ($text, $justify_length, $terminal_left, $terminal_right) = @_;
    my $length = 0;
    my $result;

   $justify_length -= length($terminal_left) + length($terminal_right);

    my $terminal_left_length = length($terminal_left);

    while($text) {
      if ($text =~ /(\s*\S*\s*)/) {
        my $word = $1;
        my $pattern = quotemeta($word);

        $text =~ s/^$pattern//;

        if ($length == 0) {
          $result .= $terminal_left;
        }

        chomp $word;
        my $word_length = length($word);

        if ($word_length > $justify_length) {
          if ($length) {
            $result .= repeat_text(" ",$justify_length - $length) .
              "$terminal_right\n$terminal_left$word$terminal_right\n";
          }
          else {
            $result .= "$word$terminal_right\n";
          }
          $length = 0;
        }
        elsif (($word_length + $length) >= $justify_length) {
          $result .=  repeat_text(" ",$justify_length - $length) .
            "$terminal_right\n$terminal_left" . $word;
          $length = $word_length;
        }
        else {
          $result .= $word;
          $length += $word_length;
        }
      }
    }

    if ($length && ($length <= $justify_length)) {
      $result .= repeat_text(" ",$justify_length - $length)."$terminal_right\n";
    }

    return($result);
  }

  ($#_ == 3) || die "Invalid number of arguments.";

  my ($text, $justify_length, $terminal_left, $terminal_right) = @_;

  my @newline_text = split(m@\n@,$text);
  my $result = "";

  foreach(@newline_text) {
    $result .= justify_text_block($_,$justify_length,$terminal_left,$terminal_right);
  }

  return($result);
}

#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# External functions
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

#------------------------------------------------------------------------------
# This method queries the user such that the resultant value will be passed to
# a user defined function <query_function>.  If this function returned success,
# then the value is accepted and the result is returned.  If the function
# returns failed, $options{invalid_choice} will be displayed to the user and
# the user will be requeried.
#
# Parameter 1 (<query_string>) is the string which will be prompted to the user
# to answer.
#
# Parameter 2 (<query_function>) is the user defined function which will be
# queried for answer validity.
#
# Parameter 3 - n (<passed_valid_values>) are optional parameters which, among
# other things, provides a list of options which will be listed alongside the
# <query_string> as valid options.  It should be noted that these options must
# pass <query_function> lest a problem will occur.  These parameters may also
# be keyed option specifiers.  For example, "terminal_mark=?" will cause the
# terminal character at the end of <query_string> to be '?'.  The following
# list of options exists:
#  terminal_mark=<option> (default value: ':')
#    - changes the character(s) which succeed the <query_string>.
#
#  invalid_choice=<option> (default value: "Invalid choice")
#    - changes the string which gets displayed when the user inputs an invalid
#      option.  If <option> = "", no 'Invalid choice' message will be
#      displayed.  Instead, it is assumed that the user function will handle
#      this.
#
#  default=<option> (default value: none)
#    - changes the default behavior of hitting return without inputing any
#      data.  If a user hits return, with "default=foo", the resulting return
#      will be interpreted as if the user had typed foo and then hit return.
#
#  case_sensitive=[yes|no] (default value: no)
#    - specifies whether or not matches are case sensitive.
#
#  multiline=[yes|no] (default value: no)
#    - specifies that the input of the request should be provided on another
#      line.
#      For example:
#        Where is your webserver configration: [/opt/casp/apache/conf/httpd.conf]
#        => <blink>
#      Notice the =>.
#------------------------------------------------------------------------------
sub user_function
{
  my ($query_string, $query_function, @passed_valid_values) = @_;

  my %options = (
                 terminal_mark => ':',
                 invalid_choice => 'Invalid choice',
                 break_key => "break-out",
                 paren_delimiter => '/'
                );
  my @valid_values;

  foreach (@passed_valid_values) {
    if (/default\s*=\s*(.*)/si) {
      (not exists $options{default_value}) || die "More than one default value in query_user.";
      $options{default_value} = $1;
      push @valid_values,$1;
    }
    elsif (/terminal_mark\s*=\s*(.*)/si) {
      $options{terminal_mark}=$1;
    }
    elsif (/invalid_choice\s*=\s*(.*)/si) {
      $options{invalid_choice}=$1;
    }
    elsif (/case_sensitive\s*=\s*(.*)/si) {
      $options{case_sensitive} = $1;
    }
    elsif (/multiline\s*=\s*(.*)/si) {
      $options{multiline} = $1;
    }
    elsif (/paren_delimiter\s*=\s*(.*)/si) {
      $options{paren_delimiter} = $1;
    }
    else {
      push @valid_values,$_;
    }
  }

  @valid_values = squeeze_list(@valid_values);

  my $answer;
  my $query_pattern = join("|",@valid_values);
  my $query_options;

  my @paren_options;

  if (@valid_values > ((exists $options{default_value}) ? 1 : 0)) {
    @paren_options = @valid_values;
  }

  if (@paren_options) {
    $query_options = ' ('.join($options{paren_delimiter},@paren_options).")$options{terminal_mark}";
  }
  else {
    $query_options = "$options{terminal_mark}";
  }

  if (exists $options{default_value}) {
    $query_string = "$query_string$query_options \[$options{default_value}\]";
    if (boolean_value($options{multiline})) {
      $query_string .= "\n=>";
    }
  }
  else {
    $query_string = "$query_string$query_options";
  }

 QUERY_LOOP:
  while(1) {
    if (defined $answer)
    {
      # only print the invalid choice message when the defined $answer
      # is not the default value.  Otherwise, we are handling a case
      # which has been documented (above) to be handled by the user
      # function.

      if ($options{invalid_choice} ne "") {
        print "$options{invalid_choice}: $answer.\n\n";
      }
    }

    print "$query_string ";

    $answer = <STDIN>;
    chomp $answer;

    if ($answer eq "") {
      if (exists $options{default_value}) {
        $answer = $options{default_value};
      }
      else {
        redo QUERY_LOOP;
      }
    }

    if (&$query_function($answer)) {
      return($answer);
    }
  }
}

#------------------------------------------------------------------------------
# This method queries the user such that the resultant value will be matched
# against the list of valid options, provided by the implementor.
#
# Parameter 1 (<query_string>) is the string which will be prompted to the user
# to answer.
#
# Parameter 2 - n (<passed_valid_values>) are parameters which, among other
# things, provides a list of options which will be listed alongside the
# <query_string> as valid options. These parameters may also be keyed option
# specifiers.  For example, "terminal_mark=?" will cause the terminal
# character at the end of <query_string> to be '?'.  The following list of
# options exists:
#  terminal_mark=<option> (default value: ':')
#    - changes the character(s) which succeed the <query_string>.
#
#  invalid_choice=<option> (default value: "Invalid choice")
#    - changes the string which gets displayed when the user inputs an invalid
#      option.
#
#  default=<option> (default value: none)
#    - changes the default behavior of hitting return without inputing any
#      data.  If a user hits return, with "default=foo", the resulting return
#      will be interpreted as if the user had typed foo and then hit return.
#
#  case_sensitive=[yes|no] (default value: no)
#    - specifies whether or not matches are case sensitive.
#------------------------------------------------------------------------------
sub user
{
  my ($query_string, @passed_valid_values) = @_;

  my %options = (
                 terminal_mark => ':',
                 invalid_choice => 'Invalid choice',
                 paren_delimiter => '/'
                );
  my @valid_values;

  foreach (@passed_valid_values) {
    if (/default\s*=\s*(.*)/si) {
      (not exists $options{default_value}) || die "More than one default value in query_user.";
      $options{default_value} = $1;
      push @valid_values,$1;
    }
    elsif (/invalid_choice\s*=\s*(.*)/si) {
      $options{invalid_choice}=$1;
    }
    elsif (/terminal_mark\s*=\s*(.*)/si) {
      $options{terminal_mark}=$1;
    }
    elsif (/case_sensitive\s*=\s*(.*)/si) {
      $options{case_sensitive} = $1;
    }
    elsif (/multiline\s*=\s*(.*)/si) {
      $options{multiline} = $1;
    }
    elsif (/paren_delimiter\s*=\s*(.*)/si) {
      $options{paren_delimiter} = $1;
    }
    else {
      push @valid_values,$_;
    }
  }

  @valid_values = squeeze_list(@valid_values);

  my $answer;
  my $query_pattern = join("|",@valid_values);
  my $query_options;

  my @paren_options;

  if (@valid_values > ((exists $options{default_value}) ? 1 : 0)) {
    @paren_options = @valid_values;
  }

  if (@paren_options) {
    $query_options = ' ('.join($options{paren_delimiter},@paren_options).")$options{terminal_mark}";
  }
  else {
    $query_options = "$options{terminal_mark}";
  }

  if (exists $options{default_value}) {
    $query_string = "$query_string$query_options \[$options{default_value}\]";
    if (boolean_value($options{multiline})) {
      $query_string .= "\n=>";
    }
  }
  else {
    $query_string = "$query_string$query_options";
  }

 QUERY_LOOP:
  while(1) {
    print "$query_string ";

    $answer = <STDIN>;

    chomp $answer;
    if ($answer eq "") {
      if (exists $options{default_value}) {
        $answer = $options{default_value};
      }
    }

    if (boolean_value($options{case_sensitive}) &&
        ($answer =~ /^($query_pattern)$/))
    {
      return($answer);
    }
    elsif ($answer =~ /^($query_pattern)$/si) {
      return(lc($answer))
    }
    else {
      print "Invalid choice.\n";
    }
  }
}

sub boolean_default
{
  ($#_ == 1) || die "Invalid number of arguments.";
  my ($query_string,$default) = @_;
  my @options;

  if ($default) {
    @options = ("default=y","n");
  }
  else {
    @options = ("y","default=n");
  }

  return(boolean_value(user($query_string,"terminal_mark=?",@options)));
}


sub browser
{
  # Initialize tty settings.
  Initialize;

  ($#_ >= 1) || die "Invalid number of arguments.";
  my ($menu_title,$menu_text,@options) = @_;

  my $menu_width = $CONST_Columns - 1;
  my $menu_height = $CONST_Rows - 1;
  my $header = " ".repeat_text("-",$menu_width - 2)."\n";
  my $footer = $header;
  my $separator = "|".repeat_text("-",$menu_width - 2)."|\n";
  my $empty = "|".repeat_text(" ",$menu_width - 2)."|";
  my %options;

  foreach(@options) {
    if (/disable_help=(.*)/) {
      $options{disable_help} = $1;
    }
    else {
      error_log("Invalid browser option specified.");
    }
  }

  # The portion of the menu which is always visible.
  my @menu_header =
    split(/\n/,
          "\n".
          $header.
          justify_text($menu_title,$menu_width,"| ", " |").
          $separator
         );

  my @menu_text =
    (
     split(/\n/,justify_text($menu_text,$menu_width,"| ", " |")),
     $empty
    );

  my $query_line;

  unless(boolean_value($options{disable_help})) {
    $query_line = " - Press ? for navigation help ";
  }

  my $length = length($query_line);

  if ($length < $menu_width) {
    # Don't make the situation worse than it already is, if the above was
    # already too wide. (length for 00%)
    $query_line .= repeat_text("-",$menu_width - $length - 10) . "%3d%" . "-----";
  }

  my $head = 0;
  # menu_header + query_line * 2
  my $implicit_height = scalar(@menu_header) + 2;
  my $page_height = $menu_height - $implicit_height;

  my $multiple_pages;

  if (scalar(@menu_text) > $page_height) {
    $multiple_pages = 1;
  }

  my $tty_settings = `stty -g`;
  local *TTY;
  open(TTY,"/dev/tty");

 BROWSER_WHILE:
  while(1) {
    system("clear");

    if ($head < 0) {
      $head = 0;
    }

    my $tail = $head + $page_height;

    if ($tail > $#menu_text) {
      $head = $#menu_text - $page_height;
      $tail = $#menu_text;
    }

    if ($multiple_pages) { # Too many lines to fit on a screen?
      print join("\n",
                 @menu_header,
                 @menu_text[$head .. $tail],
                 sprintf($query_line,int($tail/$#menu_text*100.0))),"\n";
    }
    else {
      print join("\n",
                 @menu_header,
                 @menu_text,
                 sprintf($query_line,100)),"\n";
    }

    system("stty -icanon -echo min 0 time 0");
    my $readfd;
    vec($readfd,fileno(TTY),1) = 1;
    select $readfd,undef,undef,undef;


    my $read;

    if (sysread(TTY,$read,1))
    {
      system("stty $tty_settings");
      $read = lc($read);

      if ((not boolean_value($options{disable_help})) &&
          ($read eq "?"))
      {
        browser("Browser options",
                "Typing one of the following characters will operate on the display buffer: \n".
                "u              Page up\n".
                "d or <space>   Page down\n".
                "b              Backward one line\n".
                "f or <enter>   Forward one line\n".
                "q              Exit the menu\n".
                " \n".
                "Press Enter to return to the browser.",
                "disable_help=true"
               );
        next;
      }

      if ($multiple_pages) {
        ($read eq "u") &&
          do {
            $head -= $page_height;
            next;
          };

        ($read eq "d") &&
          do {
            $head += $page_height;
            next;
          };

        ($read eq "f") &&
          do {
            $head++;
            next;
          };

        ($read eq "b") &&
          do {
            $head--;
            next;
          };

        ($read eq "\n") &&
          do {
            $head++;
            if (($tail + 1) > $#menu_text) {
              last BROWSER_WHILE;
            }
            else {
              next;
            }
          };

        ($read eq " ") &&
          do {
            $head += $page_height;

            if ($head >= $#menu_text) {
              last BROWSER_WHILE;
            }
            else {
              next;
            }
          };

        ($read eq "q") &&
          do {
            last BROWSER_WHILE;
          };
      }
      elsif (($read eq "\n") || ($read eq " ") || ($read eq "q")) {
        last BROWSER_WHILE;
      }

      # Beep
      print "\a";
    }
  }

  close(TTY);
  return(1);
}

#------------------------------------------------------------------------------
# This method queries the user such that the resultant value will be matched
# against the list of valid options, provided by the implementor.  This method
# is similar to the user method with the exception that the values are listed
# in a menu format.  In this way, each option is given a unique index number
# which specifies acceptance of that option.  Thus, the actual option can
# be a multi-word set of text.
#
# Parameter 1 (<menu_title>) is a parameter which provides a general
# description of what the meaning of the menu is.
#
# Parameter 2 (<menu_text>) is a parameter which provides a description of what
# all of the options are trying to allow the user to answer.
#
# Parameter 3 (<query_string>) is a parameter which will be displayed as a text
# query string, succeeding the list of options.  It should contain the query
# which would be made regarding which of the choices the user would like to
# select.
#
# Parameter 4 - n (<passed_valid_values>) are parameters which, among other
# things, provides a list of options which will be listed as valid options.
# These parameters may also be keyed option specifiers.  For example,
# "terminal_mark=?" will cause the terminal character at the end of
# <query_string> to be '?'.  The following list of options exists:
#  terminal_mark=<option> (default value: ':')
#    - changes the character(s) which succeed the <query_string>.
#
#  invalid_choice=<option> (default value: "Invalid choice")
#    - changes the string which gets displayed when the user inputs an invalid
#      option.
#
#  default=<option> (default value: none)
#    - changes the default behavior of hitting return without inputing any
#      data.  If a user hits return, with "default=foo", the resulting return
#      will be interpreted as if the user had typed foo and then hit return.
#------------------------------------------------------------------------------
sub user_menu
{
  # Initialize tty settings.
  Initialize;

  ($#_ >= 1) || die "Invalid number of arguments.";
  my ($menu_title,$menu_text,$query_string,@options) = @_;

  my $menu_width = $CONST_Columns - 1;
  my $menu_height = $CONST_Rows - 1;
  my $header = " ".repeat_text("-",$menu_width - 2)."\n";
  my $separator = "|".repeat_text("-",$menu_width - 2)."|\n";
  my $empty = "|".repeat_text(" ",$menu_width - 2)."|";
  my %options =
    (
     terminal_mark => ":",
     invalid_choice => "Invalid choice"
    );

  my @menu_options;

  my $count = 1;
  foreach(@options) {
    if (/disable_help=(.*)/) {
      $options{disable_help} = $1;
    }
    elsif (/default\s*=\s*(.*)/si) {
      (not exists $options{default_value}) || die "More than one default value in query_user.";

      my $default = $1;

      # If the default contains a non-digit, it is referring to making a default item.
      if ($default =~ /\D/) {
        $options{default_value} = $count;
        push @menu_options,$default;
        $count++;
      }
      else {
        $options{default_value} = $default;
      }
    }
    elsif (/invalid_choice\s*=\s*(.*)/si) {
      $options{invalid_choice}=$1;
    }
    elsif (/terminal_mark\s*=\s*(.*)/si) {
      $options{terminal_mark}=$1;
    }
    else {
      push @menu_options,$_;
      $count++;
    }
  }

  if ($query_string) {
    $query_string .= $options{terminal_mark};
    $query_string .= " [$options{default_value}]" if (exists $options{default_value});
    $query_string .= " ";
  }

  my @query_string = split(/\n/,$query_string);

  # The portion of the menu which is always visible.
  my @menu_header =
    split(/\n/,
          "\n".
          $header.
          justify_text($menu_title,$menu_width,"| ", " |").
          $separator.
          justify_text($menu_text,$menu_width,"| ", " |").
          (@menu_options ? $empty : ())
         );

  my @menu_text;

  my $implicit_height = scalar(@menu_header) + 2 + 1 + @query_string;
    # menu_header + last_menu_line * 2 + 1 <empty line> + query_string;
  my $page_height = $menu_height - $implicit_height;

  my %LineMap;
    # Contains a mapping between an actual line # (starting from 0) and
    # the line number which started the current option.

  my $index = 0;
  foreach my $option (@menu_options) {
    my $base_line = @menu_text;

    $index++;
    my @option_text = split(/\n/,justify_text(headerize("  $index. ", split(/\n/,$option)),$menu_width,"| ", " |"));
    push @menu_text, @option_text;

    for(my ($i, $last) = ($base_line,$base_line + @option_text);
        $i < $last;
        $i++)
    {
      $LineMap{$i} = $base_line;
    }
  }

  my $head = 0;
  my $multiple_pages;

  if (scalar(@menu_text) > $page_height) {
    $multiple_pages = 1;
  }

  my $last_menu_line = ' ';

  unless(boolean_value($options{disable_help}) || (not $multiple_pages)) {
    $last_menu_line .= '- Enter ? for option navigation help ';
  }

  my $length = length($last_menu_line);

  if ($length < $menu_width) {
    # Don't make the situation worse than it already is, if the above was
    # already too wide. (length for 00%)
    if (@menu_options) {
      $last_menu_line .= repeat_text("-",$menu_width - $length - 10) . "%3d%" . "-----";
    }
    else {
      $last_menu_line .= repeat_text("-",$menu_width - $length - 1);
    }
  }


  my $answer;

 MENU_WHILE:
  while(1) {
    system("clear");

    if ($head < 0) {
      $head = 0;
    }
    elsif ($head > (@menu_text - 2)) {
      $head = $LineMap{@menu_text - 2};
    }
    else {
      $head = $LineMap{$head};
    }

    my $tail = $head + $page_height;

    if ($tail > $#menu_text) {
      $head = $#menu_text - $page_height;
      $tail = $#menu_text;
    }

    if ($multiple_pages) { # Too many lines to fit on a screen?
      print(join("\n",
                 @menu_header,
                 @menu_text[$head .. $tail],
                 $empty,
                 sprintf($last_menu_line,int($tail/$#menu_text*100.0))),
            "\n\n");
    }
    else {
      print(join("\n",
                 @menu_header,
                 @menu_text,
                 $empty,
                 sprintf($last_menu_line,100)),
            "\n\n");

    }

    if (@menu_options) {
      print join("\n",@query_string);
    }
    else {
      last MENU_WHILE;
    }

    if ($answer = <STDIN>) {
      $answer = lc($answer);
      chomp $answer;

      if ((not boolean_value($options{disable_help})) &&
          ($answer eq "?"))
      {
        browser("Browser options",
                "Typing one of the following characters will operate on the display buffer: \n".
                "u              Page up\n".
                "d              Page down\n".
                "b              Backward one option\n".
                "f              Forward one option\n".
                " \n".
                "Press Enter to return to the browser.",
                "disable_help=true"
               );
        next;
      }

      if ($multiple_pages) {
        ($answer eq "u") &&
          do {
            $head -= $page_height;
            next;
          };

        ($answer eq "d") &&
          do {
            $head += $page_height;
            next;
          };

        ($answer eq "f") &&
          do {
            my $current_option = $LineMap{$head};
            while(($head < @menu_text)  && 
                  ($current_option == $LineMap{$head}))
            {
              $head++;
            }
            next;
          };

        ($answer eq "b") &&
          do {
            my $current_option = $LineMap{$head};
            while(($head > 0) && 
                  ($current_option == $LineMap{$head})) 
            {
              $head--;
            }
            next;
          };
      }

      ($answer =~ /[0-9]*/) &&
        do {
          if ((($answer eq '') && (exists $options{default_value})) ||
              (($answer > 0) &&
               ($answer <= @menu_options)))
          {
            last MENU_WHILE;
          }
        };

      # Beep
      print "\a";
      my $enter_choice = "Press enter to select again ...";
      if (length("$options{invalid_choice}: $enter_choice") < $CONST_Columns) {
        print "$options{invalid_choice}: $enter_choice";
      }
      else {
        print "$options{invalid_choice}.\n$enter_choice";
      }
      <STDIN>;
      $answer = undef;
    }
  }

  if ($answer) {
    return($answer);
  }
  else {
    return($options{default_value});
  }

  return(1);
}

sub user_menu_old {
  # Initialize tty settings.
  Initialize;

  my ($menu_title,$menu_text,$query_string,@passed_menu_options) = @_;
  my @menu_options;
  my %options =
    (
     terminal_mark => ":",
     invalid_choice => "Invalid choice"
    );

  my $count = 1;
  foreach (@passed_menu_options) {
    if (/default\s*=\s*(.*)/si) {
      (not exists $options{default_value}) || die "More than one default value in query_user.";

      my $default = $1;

      # If the default contains a non-digit, it is referring to making a default item.
      if ($default =~ /\D/) {
        $options{default_value} = $count;
        push @menu_options,$default;
        $count++;
      }
      else {
        $options{default_value} = $default;
      }
    }
    elsif (/invalid_choice\s*=\s*(.*)/si) {
      $options{invalid_choice}=$1;
    }
    elsif (/terminal_mark\s*=\s*(.*)/si) {
      $options{terminal_mark}=$1;
    }
    else {
      push @menu_options,$_;
      $count++;
    }
  }

  my $menu_width = $CONST_Columns - 1;
  my $header = " ".repeat_text("-",$menu_width - 2)."\n";
  my $footer = $header;
  my $separator = "|".repeat_text("-",$menu_width - 2)."|\n";
  my $empty = "|".repeat_text(" ",$menu_width - 2)."|\n";

  if (exists $options{default_value}) {
    if (($options{default_value} !~ /[0-9]+/) ||
        ($options{default_value} <= 0) ||
        ($options{default_value} > ($#menu_options + 1)))
    {
      die "Invalid default value.";
    }
  }

  $query_string .= $options{terminal_mark};
  $query_string .= " [$options{default_value}]" if (exists $options{default_value});

  while(1) {
    system("clear");

    print("\n",$header,
          justify_text($menu_title,$menu_width,"| ", " |"),
          $separator,
          justify_text($menu_text,$menu_width,"| ", " |"));

    print $empty if ($#menu_options >= 0);

    my $i = 0;
    foreach (@menu_options) {
      my $index = $i + 1;
      print justify_text("  $index. $menu_options[$i]",$menu_width,"| ", " |");
      $i = $index;
    }
    print $empty, $footer,"\n";

    if ($#_ <= 2) {
      last;
    }
    else {
      print "$query_string ";
      my $answer = <STDIN>;

      chomp $answer;

      if ((exists $options{default_value}) && ($answer eq "")) {
        return($options{default_value});
      }
      elsif (($answer =~ /^[0-9]+$/) && ($answer <= $i)) {
        return($answer);
      }
      else {
        my $enter_choice = "Press enter to select again ...";
        if (length("$options{invalid_choice}: $enter_choice") < $CONST_Columns) {
          print "$options{invalid_choice}: $enter_choice";
        }
        else {
          print "$options{invalid_choice}.\n$enter_choice";
        }
        <STDIN>;
      }
    }
  }
}

1;