/*
   Copyright (C) 2000 - 2007 Grid Systems, S.A.
   
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License, version 2, as
   published by the Free Software Foundation.
   
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  GNU General Public License for more details.
  
  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  */
  
  /*
   * Project: KernelConfigurator
   * Created on 02-mar-2004
   *
   * Copyright (c)2003 Grid Systems
   */
  package com.gridsystems.config.tools.console;
  
  import java.io.BufferedReader;
  import java.io.File;
  import java.io.FileDescriptor;
  import java.io.FileOutputStream;
  import java.io.IOException;
  import java.io.InputStreamReader;
  import java.io.PrintStream;
  import java.util.HashMap;
  import java.util.Map;
  
  /**
   * Helper functions for console interaction.
   *
   * @author <a href="mailto:rruiz@gridsystems.com">Rodrigo Ruiz Aguayo</a>
   * @version 1.0
   */
  public final class ConsoleTools {
    /**
     * ACS map index for the NW corner character.
     */
    private static final int NWCORNER = 0;
  
    /**
     * ACS map index for the NE corner character.
     */
    private static final int NECORNER = 1;
  
    /**
     * ACS map index for the SW corner character.
     */
    private static final int SWCORNER = 2;
  
    /**
     * ACS map index for the SE corner character.
     */
    private static final int SECORNER = 3;
  
    /**
     * ACS map index for the W corner character.
     */
    private static final int WCORNER = 4;
  
    /**
     * ACS map index for the E corner character.
     */
    private static final int ECORNER = 5;
  
    /**
     * ACS map index for the horizontal line character.
     */
    private static final int HLINE = 6;
  
    /**
     * ACS map index for the vertical line character.
     */
    private static final int VLINE = 7;
  
    /**
     * The active ACS (Alternative Character Set) map.
     */
    private static char[] acsmap = { '+', '+', '+', '+', '+', '+', '-', '|' };
  
    /**
     * Standard output replacement for allowing encoding selection.
     */
    private static FileOutputStream console = new FileOutputStream(FileDescriptor.out);
  
    /**
     * true if ANSI escape sequences are enabled.
     */
    private static boolean ansiEnabled = false;
  
    /**
     * true if ACS use is enabled.
    */
   private static boolean acsEnabled = false;
 
   /**
    * Reader instance to read from the console.
    */
   private static BufferedReader reader = null;
 
   /**
    * Charcter encoding name.
    */
   private static String encodingName;
 
   /**
    * true if an enconding switch must be made to print ACS characters.
    */
   private static boolean switchEncoding = false;
 
   /**
    * A list of ACS maps for a known set of encoding names.
    */
   private static Map<String, char[]> maps = null;
 
   static {
     maps = new HashMap<String, char[]>();
     maps.put("noacs", new char[] { '+', '+', '+', '+', '+', '+', '-', '|' });
     maps.put("ansi", new char[] { 'l', 'k', 'm', 'j', 't', 'u', 'q', 'x' });
     maps.put("Cp1252", new char[] { 0xDA, 0xBF, 0xC0, 0xD9, 0xC3, 0xB4, 0xC4, 0xB3 });
   };
 
   /**
    * Hidden constructor.
    */
   private ConsoleTools() { }
 
   /**
    * Sets the console configuration regarding to ANSI compliance and Alternate
    * Character Set support.
    *
    * @param ansi true if the console supports ANSI escape sequences
    * @param acs  true if the console supports ACS for line-drawing
    */
   public static void setup(boolean ansi, boolean acs) {
     String encoding = System.getProperty("file.encoding");
     encodingName = encoding;
 
     ConsoleTools.ansiEnabled = ansi;
     ConsoleTools.acsEnabled = acs;
 
     if (acs) {
       if (ansi) {
         encoding = "ansi";
         System.out.print("\u001b(B\u001b)0\u000F");
         System.out.flush();
       }
     } else {
       encoding = "noacs";
     }
 
     acsmap = (char[])maps.get(encoding);
     if (acsmap == null) {
       System.out.println("ACS Map for encoding '" + encoding + "' not found");
       if (File.separatorChar == '\\') {
         // Windows defaults to Cp1252 with encoding switch
         acsmap = (char[])maps.get("Cp1252");
         switchEncoding = true;
         acsEnabled = true;
       } else {
         acsmap = (char[])maps.get("noacs");
         acsEnabled = false;
       }
     }
   }
 
   /**
    * Clears the screen. It works far better in an ANSI compliant terminal.
    */
   public static void clear() {
     if (ansiEnabled) {
       System.out.print("\u001b[2J\u001b[0;0H");
       System.out.flush();
     } else {
       for (int i = 0; i < 40; i++) {
         System.out.println();
       }
     }
   }
 
   /**
    * Reads a line of text from the console.
    *
    * @param prompt       The user prompt
    * @return             The typed text
    * @throws IOException In case of I/O error
    */
   public static String readLine(String prompt) throws IOException {
     if (reader == null) {
       reader = new BufferedReader(new InputStreamReader(System.in));
     }
     System.out.print(prompt);
     return reader.readLine();
   }
 
   /**
    * Reads a line, masking the typed characters so they are not visible for
    * casual observers.
    *
    * @param prompt       The prompt for the user
    * @param replaceChar  The character to show instead of the typed ones
    * @return             The typed text
    * @throws IOException In case of I/O error
    */
   public static String readPassword(String prompt, char replaceChar) throws IOException {
     PasswordMasker pm = new PasswordMasker();
     pm.start();
     String line = readLine(prompt);
     pm.setStopped();
     return line;
   }
 
   /**
    * Adds count characters "c" to the end of sb.
    *
    * @param sb    The buffer to fill
    * @param c     The character to add
    * @param count The number of characters to add
    */
   public static void fill(StringBuffer sb, char c, int count) {
     for (int i = 0; i < count; i++) {
       sb.append(c);
     }
   }
 
   /**
    * Centers s in a line of "width" characters by adding spaces to its left.
    *
    * @param s     The string to center
    * @param width The width of the line in characters
    * @return      The padded version of s
    */
   public static String center(String s, int width) {
     int len = s.length();
     if (len < width) {
       len = (width - len) / 2;
       StringBuffer sb = new StringBuffer();
       fill(sb, ' ', len);
       sb.append(s);
       return sb.toString();
     } else {
       return s;
     }
   }
 
   /**
    * Prints s as a line in a box of "width" characters.
    *
    * @param sb    The output buffer
    * @param s     The string to "paint"
    * @param width The width of the box contents in characters
    */
   private static void paintBoxLine(StringBuffer sb, String s, int width) {
     if (s.equals("-")) {
       g1(sb);
       sb.append(acsmap[WCORNER]);
       fill(sb, acsmap[HLINE], width);
       sb.append(acsmap[ECORNER]);
       g0(sb);
     } else {
       acs(sb, VLINE, 1);
       sb.append(s);
       fill(sb, ' ', width - s.length());
       acs(sb, VLINE, 1);
     }
   }
 
   /**
    * Displays a bordered box in the console, with the specified title, contents and
    * width.
    *
    * @param title    The box title
    * @param contents The box contents
    * @param width    The box width in characters
    */
   public static void paintBox(String title, Object[] contents, int width) {
     StringBuffer sb = new StringBuffer();
 
     // Title line
     g1(sb);
     sb.append(acsmap[NWCORNER]).append(acsmap[HLINE]);
     g0(sb);
 
     sb.append(title);
 
     g1(sb);
     fill(sb, acsmap[HLINE], width - (title.length() + 1));
     sb.append(acsmap[NECORNER]);
     g0(sb);
     System.out.println(sb);
 
     // Box contents
     for (int i = 0; i < contents.length; i++) {
       if (contents[i] instanceof Field) {
         // A Field can contain an arbitrary number of lines
         String[] lines = ((Field)contents[i]).getContents();
         for (int j = 0; j < lines.length; j++) {
           sb.setLength(0);
           paintBoxLine(sb, lines[j], width);
           System.out.println(sb);
         }
       } else if (contents[i] != null) {
         sb.setLength(0);
         String s = contents[i].toString();
         paintBoxLine(sb, s, width);
         System.out.println(sb);
       }
     }
 
     // Bottom line
     sb.setLength(0);
     g1(sb);
     sb.append(acsmap[SWCORNER]);
     fill(sb, acsmap[HLINE], width);
     sb.append(acsmap[SECORNER]);
     g0(sb);
     System.out.println(sb);
   }
 
   //---------------------------------------------------------------------------
   // ANSI SUPPORT METHODS
 
   /**
    * Adds num characters to sb. The character to add is selected from the
    * active "Alternate Character Set" for line drawings, as specified in the
    * code parameter.
    *
    * @param sb   The buffer where characters are appended
    * @param code The index in the ACS map for the character to add
    * @param num  The number of characters to add
    */
   private static void acs(StringBuffer sb, int code, int num) {
     g1(sb);
     char c = acsmap[code];
     for (int i = 0; i < num; i++) {
       sb.append(c);
     }
     g0(sb);
   }
 
   /**
    * Prepares the console for text printing.
    * <p>
    * Depending on the execution platform, this can be achieved printing some
    * special control characters, so the buffer where the output is being written
    * is passed as a parameter.
    * <p>
    * On Windows, this method clears the specified buffer, as it needs to flush
    * its contents to the standard out stream before configuring the terminal
    * for text printing.
    *
    * @param sb The current buffer for text display
    */
   private static void g0(StringBuffer sb) {
     if (acsEnabled && ansiEnabled) {
       sb.append('\u000F');
     } else if (switchEncoding) {
       try {
         System.out.print(sb);
         System.out.flush();
         sb.setLength(0);
         System.setOut(new PrintStream(console, true, encodingName));
       } catch (Exception e) {
       }
     }
   }
 
   /**
    * Prepares the console for line drawing.
    * <p>
    * Depending on the execution platform, this can be achieved printing some
    * special control characters, so the buffer where the output is being written
    * is passed as a parameter.
    * <p>
    * On Windows, this method clears the specified buffer, as it needs to flush
    * its contents to the standard out stream before configuring the terminal
    * for line drawing.
    *
    * @param sb The current buffer for text display
    */
   private static void g1(StringBuffer sb) {
     if (acsEnabled && ansiEnabled) {
       sb.append('\u000E');
     } else if (switchEncoding) {
       try {
         System.out.print(sb);
         System.out.flush();
         sb.setLength(0);
         System.setOut(new PrintStream(console, true, "Cp1252"));
       } catch (Exception e) { }
     }
   }
 
   /**
    * Hides the text typed by a user in the console. It is not a true password
    * entry implementation, as it is not possible using pure java.
    *
    * @author <a href="mailto:rruiz@gridsystems.com">Rodrigo Ruiz Aguayo</a>
    * @version 1.0
    */
   private static class PasswordMasker extends Thread {
     /**
      * Execution end flag.
      */
     private volatile boolean stopped = false;
 
     /**
      * Default constructor.
      */
     public PasswordMasker() {
       super();
       setPriority(Thread.MAX_PRIORITY);
     }
 
     /**
      * Stops the thread execution.
      */
     public void setStopped() {
       this.stopped = true;
     }
 
     /**
      * Masks the current input.
      *
      * @see java.lang.Runnable#run()
      */
     public void run() {
       try {
         String s = "\b*";
         while (!stopped) {
           sleep(1);
           System.out.print(s);
           System.out.flush();
         }
       } catch (InterruptedException e) { }
     }
   }
 }