package org.vaadin.console;

 import java.io.ByteArrayOutputStream;

 import java.io.IOException;

 import java.io.OutputStream;

 import java.io.PrintStream;

 import java.io.Serializable;

 import java.util.ArrayList;

 import java.util.Collections;

 import java.util.HashMap;

 import java.util.HashSet;

 import java.util.List;

 import java.util.Map;

 import java.util.Set;

 import java.util.regex.Pattern;

 import org.vaadin.console.ansi.ANSICodeConverter;

 import org.vaadin.console.ansi.DefaultANSICodeConverter;

 import org.vaadin.rpc.ServerSideHandler;

 import org.vaadin.rpc.ServerSideProxy;

 import org.vaadin.rpc.client.Method;

 import com.vaadin.terminal.PaintException;

 import com.vaadin.terminal.PaintTarget;

 import com.vaadin.ui.AbstractComponent;

 import com.vaadin.ui.Component;

 /**

  * Server side component for the VTextConsole widget.

  *

  * @author Sami Ekblad / Vaadin

  *

  */

 @com.vaadin.ui.ClientWidget(org.vaadin.console.client.ui.VTextConsole.class)

 public class Console extends AbstractComponent implements Component.Focusable {

     private static final long serialVersionUID = 590258219352859644L;

     private Handler handler;

     private ANSICodeConverter ansiToCSSconverter;

     private boolean isConvertANSIToCSS = false;

     private final HashMap<String, Command> commands = new HashMap<String, Command>();

     private final Config config = new Config();

     private static final String DEFAULT_PS = "}> ";

     private static final String DEFAULT_GREETING = "Console ready.";

     private static final int DEFAULT_BUFFER = 0;

     private static final int DEFAULT_COLS = -1;

     private static final int DEFAULT_ROWS = -1;

     private static final boolean DEFAULT_WRAP = true;

     private static final boolean DEFAULT_PRINT_PROMPT_ON_INPUT = true;

     private static final boolean DEFAULT_SMART_SCROLL_TO_END = false;

     private static final int MAX_COLS = 500;

     private static final int MAX_ROWS = 200;

     public boolean isWrap() {

         return config.wrap;

     }

     public void setWrap(final boolean wrap) {

         config.wrap = wrap;

         client.call("setWrap", wrap);

     }

 	/**

 	 * @return true, if entered by user text immediately will print to console, false otherwise

 	 */

 	public boolean isPrintPromptOnInput() {

 		return config.isPrintPromptOnInput;

 	}

 	/**

 	 * @param isPrintPromptOnInput if true - entered by user text immediately will be printed to 

 	 * console, nothing happens otherwise

 	 */

 	public void setPrintPromptOnInput(final boolean isPrintPromptOnInput) {

 		config.isPrintPromptOnInput = isPrintPromptOnInput;

 		client.call("setPrintPromptOnInput", isPrintPromptOnInput);

 	}

 	/**

 	 * @return true, if method scrollToEnd will only work if last scroll state was "end" 

 	 * (like Linux KDE console emulator "Konsole"), false otherwise (by default)

 	 */

 	public boolean isSmartScrollToEnd() {

 		return config.isSmartScrollToEnd;

 	}

 	/**

 	 * @param isSmartScrollToEnd if true - method scrollToEnd will only work if last scroll 

 	 * state was "end" (like Linux KDE console emulator "Konsole"); false by default

 	 */

 	public void setSmartScrollToEnd(final boolean isSmartScrollToEnd) {

 		config.isSmartScrollToEnd = isSmartScrollToEnd;

 		client.call("setSmartScrollToEnd", isSmartScrollToEnd);

 	}

     private final ServerSideProxy client = new ServerSideProxy(

             new ClientCallback());

     /**

      * Inner class to handle client calls.

      *

      */

     public class ClientCallback implements ServerSideHandler {

         private static final long serialVersionUID = 3992611573500588703L;

         public void requestRepaint() {

             Console.this.requestRepaint();

         }

         public Object[] initRequestFromClient() {

             return new Object[] { 

             		config.cols, 

             		config.rows,

                     config.maxBufferSize, 

                     config.wrap, 

                     config.isPrintPromptOnInput, 

                     config.isSmartScrollToEnd, 

                     config.greeting, 

                     config.ps 

                     };

         }

         public void callFromClient(String method, Object[] params) {

             // TODO Auto-generated method stub

         }

     }

     /**

      * The tab order number of this field.

      */

     private int tabIndex = 0;

     @SuppressWarnings("unused")

     private Integer fontw;

     @SuppressWarnings("unused")

     private Integer fonth;

     private PrintStream printStream;

     private String lastSuggestInput;

     private List<CommandProvider> commandProviders;

     /**

      * An inner class for holding the configuration data.

      */

     public static class Config implements Serializable {

         private static final long serialVersionUID = -812601232248504108L;

         int maxBufferSize = DEFAULT_BUFFER;

         int cols = DEFAULT_COLS;

         int rows = DEFAULT_ROWS;

         boolean wrap = DEFAULT_WRAP;

         boolean isPrintPromptOnInput = DEFAULT_PRINT_PROMPT_ON_INPUT;

         boolean isSmartScrollToEnd = DEFAULT_SMART_SCROLL_TO_END;

         String ps = DEFAULT_PS;

         String greeting = DEFAULT_GREETING;

     }

     /**

      * Console Handler interface.

      *

      * Handler provides a hook to handle various console related events and

      * override the default processing.

      *

      */

     public interface Handler extends Serializable {

         /**

          * Called when user uses TAB to complete the command entered into the

          * Console input.

          *

          * @param console

          * @param lastInput

          * @return

          */

         Set<String> getSuggestions(Console console, String lastInput);

         /**

          * Called when user has entered input to the Console and presses enter

          * to execute it.

          *

          * @param console

          * @param lastInput

          */

         void inputReceived(Console console, String lastInput);

         /**

          * Handle an exception during a Command execution.

          *

          * @param console

          * @param e

          * @param cmd

          * @param argv

          */

         void handleException(Console console, Exception e, Command cmd,

                 String[] argv);

         /**

          * Handle situation where a command could not be found.

          *

          * @param console

          * @param argv

          */

         void commandNotFound(Console console, String[] argv);

     }

     /**

      * Commands that can be executed against the Component instance. They

      * provide convenient string to method mapping. Basically, a Command is a

      * method that that can be executed in Component. It can have parameters or

      * not.

      *

      */

     public interface Command extends Serializable {

         /**

          * Execute a Command with arguments.

          *

          * @param console

          * @param argv

          * @return

          * @throws Exception

          */

         public Object execute(Console console, String[] argv) throws Exception;

         /**

          * Get usage information about this command.

          *

          * @param console

          * @param argv

          * @return

          */

         public String getUsage(Console console, String[] argv);

     }

     /**

      * Interface for providing Commands to the console. One can register a

      * command providers to console instead of individual commands to provide a

      * lot of commands.

      *

      */

     public interface CommandProvider extends Serializable {

         /**

          * List all available command from this provider.

          *

          * @param console

          * @return

          */

         Set<String> getAvailableCommands(Console console);

         /**

          * Get Command instance based on command name.

          *

          * @param console

          * @param commandName

          * @return

          */

         Command getCommand(Console console, String commandName);

     }

     public void addCommandProvider(final CommandProvider commandProvider) {

         if (commandProviders == null) {

             commandProviders = new ArrayList<CommandProvider>();

         }

         commandProviders.add(commandProvider);

     }

     public void removeCommandProvider(final CommandProvider commandProvider) {

         if (commandProviders == null) {

             return;

         }

         commandProviders.remove(commandProvider);

     }

     public void removeAllCommandProviders() {

         if (commandProviders == null) {

             return;

         }

         commandProviders.clear();

     }

     public Console(final Console.Handler handler) {

         this();

         setHandler(handler);

     }

     public Console() {

         setImmediate(true);

         setHandler(new DefaultConsoleHandler());

         setANSIToCSSConverter(new DefaultANSICodeConverter());

         registerCallbacks();

     }

     private void registerCallbacks() {

         client.register("suggest", new Method() {

             public void invoke(String methodName, Object[] params) {

                 handleSuggest((String) params[0]);

             }

         });

         client.register("input", new Method() {

             public void invoke(String methodName, Object[] params) {

                 handleInput((String) params[0]);

             }

         });

     }

     @Override

     public void paintContent(final PaintTarget target) throws PaintException {

         super.paintContent(target);

         client.paintContent(target);

     }

     @Override

     public void changeVariables(final Object source,

             final Map<String, Object> variables) {

         super.changeVariables(source, variables);

         client.changeVariables(source, variables);

         if (variables.containsKey("width")) {

             setWidth((String) variables.get("width"));

         }

         if (variables.containsKey("height")) {

             setHeight((String) variables.get("height"));

         }

         if (variables.containsKey("fontw")) {

             fontw = (Integer) variables.get("fontw");

         }

         if (variables.containsKey("fonth")) {

             fonth = (Integer) variables.get("fonth");

         }

         if (variables.containsKey("cols")) {

             config.cols = (Integer) variables.get("cols");

         }

         if (variables.containsKey("rows")) {

             config.rows = (Integer) variables.get("rows");

         }

     }

     /**

      * Overridden to filter client-side calculation/changes and avoid loops.

      *

      */

     @Override

     public void setWidth(float width, int unit) {

         if (width != getWidth() || unit != getWidthUnits()) {

             super.setWidth(width, unit);

         }

     }

     /**

      * Overridden to filter client-side calculation/changes and avoid loops.

      *

      */

     @Override

     public void setHeight(float height, int unit) {

         if (height != getHeight() || unit != getHeightUnits()) {

             super.setHeight(height, unit);

         }

     }

     protected void handleSuggest(final String input) {

         final boolean cancelIfNotASingleMatch = (input != null && !input

                 .equals(lastSuggestInput));

         lastSuggestInput = input;

         final Set<String> matches = handler.getSuggestions(this, input);

         if (matches == null || matches.size() == 0) {

             bell();

             return;

         }

         // Output the original

         final String prefix = parseCommandPrefix(input);

         String output = input.substring(0, input.lastIndexOf(prefix));

         if (matches.size() == 1) {

             // Output the only match

             output += matches.iterator().next() + " "; // append the single

             // match

         } else {

             // We output until the common prefix

             StringBuilder commonPrefix = new StringBuilder(prefix);

             final int maxLen = matches.iterator().next().length();

             for (int i = prefix.length(); i < maxLen; i++) {

                 char c = 0;

                 boolean charMatch = true;

                 for (final String m : matches) {

                     if (c == 0) {

                         c = m.charAt(i);

                     } else if (i < m.length()) {

                         charMatch &= m.charAt(i) == c;

                         if (!charMatch) {

                             break;

                         }

                     } else {

                         charMatch = false;

                         break;

                     }

                 }

                 if (charMatch) {

                     commonPrefix.append(c);

                 }

             }

             output += commonPrefix.toString();

             if (prefix.equals(commonPrefix.toString())

                     && !cancelIfNotASingleMatch) {

                 final StringBuffer suggestions = new StringBuffer("\n");

                 for (final String m : matches) {

                     suggestions.append(" " + m);

                 }

                 print(suggestions.toString());

             } else {

                 bell();

                 lastSuggestInput = output; // next suggest will not beep

             }

         }

         prompt(output);

         focus();

     }

     public void bell() {

         client.call("bell");

     }

     protected void handleInput(final String input) {

         // Ask registered handler

         handler.inputReceived(this, input);

     }

     protected void parseAndExecuteCommand(final String input) {

         final String[] argv = parseInput(input);

         if (argv != null && argv.length > 0) {

             final Command c = getCommand(argv[0]);

             if (c != null) {

                 final String result = executeCommand(c, argv);

                 if (result != null) {

                     print(result);

                 }

             } else {

                 handler.commandNotFound(this, argv);

             }

         }

     }

     protected String executeCommand(final Command cmd, final String[] argv) {

         try {

             final Object r = cmd.execute(this, argv);

             return r != null ? "" + r : null;

         } catch (final Exception e) {

             handler.handleException(this, e, cmd, argv);

         }

         return null;

     }

     protected String parseCommandPrefix(final String input) {

         if (input == null) {

             return null;

         }

         if (!input.endsWith(" ")) {

             final String[] argv = parseInput(input);

             if (argv != null && argv.length > 0) {

                 return argv[argv.length - 1];

             }

         }

         return "";

     }

     protected static String[] parseInput(final String input) {

         if (input != null && !"".equals(input.trim())) {

             final String[] temp = input.split(" ");

             if (temp != null && temp.length > 0) {

                 final List<String> parsed = new ArrayList<String>(temp.length);

                 String current = null;

                 for (final String element : temp) {

                     final int quotCount = count(element, '\"');

                     if (quotCount > 0 && quotCount % 2 != 0) {

                         // uneven number of quotes star or end combining params

                         if (current != null) {

                             parsed.add(current + " "

                                     + element.replaceAll("\"", "")); // end

                             current = null;

                         } else {

                             current = element.replaceAll("\"", ""); // start

                         }

                     } else if (current != null) {

                         current += " " + element.replaceAll("\"", "");

                     } else {

                         parsed.add(element.replaceAll("\"", ""));

                     }

                 }

                 // TODO: actually this is not quite right: We have an open quote

                 // somewhere. Exception maybe?

                 if (current != null) {

                     parsed.add(current.replaceAll("\"", ""));

                 }

                 return parsed.toArray(new String[] {});

             }

         }

         return new String[] {};

     }

     protected static int count(final String sourceString, final char lookFor) {

         if (sourceString == null) {

             return -1;

         }

         int count = 0;

         for (int i = 0; i < sourceString.length(); i++) {

             final char c = sourceString.charAt(i);

             if (c == lookFor) {

                 count++;

             }

         }

         return count;

     }

     public void print(final String output) {

     	if(isConvertANSIToCSS){

     		client.call("print", "");

     		appendWithProcessingANSICodes(output);

     	} else

     		client.call("print", output);

     }

 	/**

 	 * Print text with predefined in theme CSS class.

 	 *  

 	 * @param output

 	 * @param className CSS class name for string

 	 */

 	public void print(final String output, final String className) {

 		client.call("print", output, className);

 	}

     public String getGreeting() {

         return config.greeting;

     }

     public String getPs() {

         return config.ps;

     }

     public int getMaxBufferSize() {

         return config.maxBufferSize;

     }

     public int getRows() {

         return config.rows;

     }

     public void setGreeting(final String greeting) {

         config.greeting = greeting;

         client.call("setGreeting", greeting);

     }

     public void setPs(final String ps) {

         config.ps = ps == null ? DEFAULT_PS : ps;

         client.call("setPs", config.ps);

     }

     public void setMaxBufferSize(final int lines) {

         config.maxBufferSize = lines > 0 ? lines : 0;

         client.call("setMaxBufferSize", config.maxBufferSize);

     }

     public void setRows(final int rows) {

         config.rows = rows;

         if (config.rows < 1) {

             config.rows = 1;

         }

         if (config.rows > MAX_ROWS) {

             config.rows = MAX_ROWS;

         }

         client.call("setRows", rows);

     }

     public int getCols() {

         return config.cols;

     }

     public void setCols(final int cols) {

         config.cols = cols;

         if (config.cols < 1) {

             config.cols = 1;

         }

         if (config.cols > MAX_COLS) {

             config.cols = MAX_COLS;

         }

         client.call("setCols", config.cols);

     }

     public void prompt() {

         client.call("prompt");

     }

     public void prompt(final String initialInput) {

         client.call("prompt", initialInput);

     }

     public void println(final String string) {

     	if(isConvertANSIToCSS){

     		client.call("print", "");

     		appendWithProcessingANSICodes(string + "\n");

     	} else

     		client.call("println", string);

     }

 	/**

 	 * Print text with predefined in theme CSS class.

 	 * 

 	 * @param string

 	 * @param className CSS class name for string

 	 */

 	public void println(final String string, final String className) {

 		client.call("println", string, className);

 	}

     /**

      * @param string text to append to the last printed line

      * @return this Console object

      */

     public Console append(final String string) {

     	if(isConvertANSIToCSS)

     		appendWithProcessingANSICodes(string);

     	else

     		client.call("append", string);

     	return this;

     }

 	private void appendWithProcessingANSICodes(String sOutput) {

 		String splitted[] = sOutput.split(ANSICodeConverter.ANSI_PATTERN);

 		String notPrintedYet = new String(sOutput);

 		for(int i = 0; i < splitted.length; i++){

 			String nextStr = splitted[i];

 			if(i == 0 && nextStr.length() == 0)

 				continue;

 			String cssClasses = "";

 			Pattern firstAnsi = Pattern.compile("^(" + ANSICodeConverter.ANSI_PATTERN + ")+\\Q" + nextStr + "\\E.*", Pattern.DOTALL);

 			if(firstAnsi.matcher(notPrintedYet).matches()){

 				while(firstAnsi.matcher(notPrintedYet).matches()){									

 					String ansi = notPrintedYet.replaceAll("\\Q" + notPrintedYet.replaceAll("^(" + ANSICodeConverter.ANSI_PATTERN + "){1}", "") + "\\E", "");

 					cssClasses += ansiToCSSconverter.convertANSIToCSS(ansi) + " ";

 					notPrintedYet = notPrintedYet.replaceAll("^(" + ANSICodeConverter.ANSI_PATTERN + "){1}", "");

 				}

 				notPrintedYet = notPrintedYet.replaceAll("^\\Q" + nextStr + "\\E", "");

 			} else

 				notPrintedYet = notPrintedYet.replaceFirst("\\Q" + nextStr + "\\E", "");

 			cssClasses = cssClasses.trim();

 			if(cssClasses.length() > 0)

 				client.call("append", nextStr, cssClasses);

 			else

 				client.call("append", nextStr);

 		}

     }

 	/**

 	 * Append text with predefined in theme CSS class.

 	 * 

 	 * @param string text to append to the last printed line

 	 * @param className CSS class name for string

 	 * @return this Console object

 	 */

 	public Console append(final String string, final String className) {

 		client.call("append", string, className);

 		return this;

 	}

     public void newLine() {

         client.call("newLine");

     }

 	/**

 	 * Print new line only if new line not exists at the end of console

 	 */

 	public void newLineIfNotEndsWithNewLine() {

 		client.call("newLineIfNotEndsWithNewLine");

 	}

     public void reset() {

         client.call("reset");

     }

     public void clear() {

         formFeed();

     }

     public void formFeed() {

         client.call("ff");

     }

     public void carriageReturn() {

         client.call("cr");

     }

     public void lineFeed() {

         client.call("lf");

     }

     public void clearCommandHistory() {

         client.call("clearHistory");

     }

     public void clearBuffer() {

         client.call("clearBuffer");

     }

     public void scrollToEnd() {

         client.call("scrollToEnd");

     }

     /**

      * Focus input element of console.

      */

     public void focusInput() {

     	client.call("focusInput");

     }

     /**

      * Gets the Tabulator index of this Focusable component.

      *

      * @see com.vaadin.ui.Component.Focusable#getTabIndex()

      */

     public int getTabIndex() {

         return tabIndex;

     }

     /**

      * Sets the Tabulator index of this Focusable component.

      *

      * @see com.vaadin.ui.Component.Focusable#setTabIndex(int)

      */

     public void setTabIndex(final int tabIndex) {

         this.tabIndex = tabIndex;

     }

     /**

      * {@inheritDoc}

      */

     @Override

     public void focus() {

         super.focus();

     }

     /* PrintStream implementation for console output. */

     public PrintStream getPrintStream() {

         if (printStream == null) {

             printStream = new PrintStream(new OutputStream() {

                 ByteArrayOutputStream buffer = new ByteArrayOutputStream();

                 @Override

                 public void write(final int b) throws IOException {

                     buffer.write(b);

                     // Line buffering

                     if (13 == b) {

                         flush();

                     }

                 }

                 @Override

                 public void flush() throws IOException {

                     super.flush();

                     buffer.flush();

                     Console.this.print(buffer.toString());

                     buffer.reset();

                 }

             }, true);

         }

         return printStream;

     }

     /* Generic command handling */

     /**

      * Add a Command to this Console.

      *

      * This will override the any commands of the same name available via

      * {@link CommandProvider}.

      */

     public void addCommand(final String name, final Command cmd) {

         commands.put(name, cmd);

     }

     /**

      * Remove a command from this console.

      *

      * This does not remove Command available from {@link CommandProvider}.

      *

      * @param cmdName

      */

     public void removeCommand(final String cmdName) {

         commands.remove(cmdName);

     }

     /**

      * Get a Command by its name.

      *

      * @param cmdName

      * @return

      */

     public Command getCommand(final String cmdName) {

         // Try directly registered command first

         Command cmd = commands.get(cmdName);

         if (cmd != null) {

             return cmd;

         }

         // Ask from the providers

         if (commandProviders != null) {

             for (final CommandProvider cp : commandProviders) {

                 cmd = cp.getCommand(this, cmdName);

                 if (cmd != null) {

                     return cmd;

                 }

             }

         }

         // Not found

         return null;

     }

     /**

      * Get the current Console Handler.

      *

      * @return

      */

     public Handler getHandler() {

         return handler;

     }

     /**

      * Set the handler for this console.

      *

      * @see Handler

      * @param handler

      */

     public void setHandler(final Handler handler) {

         this.handler = handler != null ? handler : new DefaultConsoleHandler();

     }

     public ANSICodeConverter getANSIToCSSConverter() {

 		return ansiToCSSconverter;

 	}

 	public void setANSIToCSSConverter(ANSICodeConverter converter) {

 		this.ansiToCSSconverter = converter != null? converter : new DefaultANSICodeConverter();

 	}

 	/**

 	 * Converting raw output with ANSI escape sequences to output with CSS-classes.

 	 *

 	 * @return

 	 */

 	public boolean isConvertANSIToCSS() {

 		return isConvertANSIToCSS;

 	}

 	/**

 	 * Converting raw output with ANSI escape sequences to output with CSS-classes.

 	 *

 	 * @param isConvertANSIToCSS

 	 */

 	public void setConvertANSIToCSS(boolean isConvertANSIToCSS) {

 		this.isConvertANSIToCSS = isConvertANSIToCSS;

 	}

 	/**

      * Get map of available commands in this Console.

      *

      * @return

      */

     public Set<String> getCommands() {

         final Set<String> res = new HashSet<String>();

         if (commandProviders != null) {

             for (final CommandProvider cp : commandProviders) {

             	if(cp.getAvailableCommands(this) != null)

             		res.addAll(cp.getAvailableCommands(this));

             }

         }

         res.addAll(commands.keySet());

         return Collections.unmodifiableSet(res);

     }

 }