getline.cs

//
// getline.cs: A command line editor
//
// Authors:
//   Miguel de Icaza (miguel@novell.com)
//
// Copyright 2008 Novell, Inc.
// Copyright 2016 Xamarin Inc
//
// Completion wanted:
//
//   * Enable bash-like completion window the window as an option for non-GUI people?
//
//   * Continue completing when Backspace is used?
//
//   * Should we keep the auto-complete on "."?
//
//   * Completion produces an error if the value is not resolvable, we should hide those errors
//
// Dual-licensed under the terms of the MIT X11 license or the
// Apache License 2.0
//
// USE -define:DEMO to build this as a standalone file and test it
//
// TODO:
//    Enter an error (a = 1);  Notice how the prompt is in the wrong line
//		This is caused by Stderr not being tracked by System.Console.
//    Completion support
//    Why is Thread.Interrupt not working?   Currently I resort to Abort which is too much.
//
// Limitations in System.Console:
//    Console needs SIGWINCH support of some sort
//    Console needs a way of updating its position after things have been written
//    behind its back (P/Invoke puts for example).
//    System.Console needs to get the DELETE character, and report accordingly.
//
// Bug:
//   About 8 lines missing, type "Con<TAB>" and not enough lines are inserted at the bottom.
// 
//
using System;
using System.Text;
using System.IO;
using System.Threading;
using System.Reflection;

namespace Mono.Terminal {

	public class LineEditor {

		public class Completion {
			public string [] Result;
			public string Prefix;

			public Completion (string prefix, string [] result)
			{
				Prefix = prefix;
				Result = result;
			}
		}
		
		public delegate Completion AutoCompleteHandler (string text, int pos);

		// null does nothing, "csharp" uses some heuristics that make sense for C#
		public string HeuristicsMode;
		
		//static StreamWriter log;
		
		// The text being edited.
		StringBuilder text;

		// The text as it is rendered (replaces (char)1 with ^A on display for example).
		StringBuilder rendered_text;

		// The prompt specified, and the prompt shown to the user.
		string prompt;
		string shown_prompt;
		
		// The current cursor position, indexes into "text", for an index
		// into rendered_text, use TextToRenderPos
		int cursor;

		// The row where we started displaying data.
		int home_row;

		// The maximum length that has been displayed on the screen
		int max_rendered;

		// If we are done editing, this breaks the interactive loop
		bool done = false;

		// The thread where the Editing started taking place
		Thread edit_thread;

		// Our object that tracks history
		History history;

		// The contents of the kill buffer (cut/paste in Emacs parlance)
		string kill_buffer = "";

		// The string being searched for
		string search;
		string last_search;

		// whether we are searching (-1= reverse; 0 = no; 1 = forward)
		int searching;

		// The position where we found the match.
		int match_at;
		
		// Used to implement the Kill semantics (multiple Alt-Ds accumulate)
		KeyHandler last_handler;

		// If we have a popup completion, this is not null and holds the state.
		CompletionState current_completion;

		// If this is set, it contains an escape sequence to reset the Unix colors to the ones that were used on startup
		static byte [] unix_reset_colors;

		// This contains a raw stream pointing to stdout, used to bypass the TermInfoDriver
		static Stream unix_raw_output;
		
		delegate void KeyHandler ();
		
		struct Handler {
			public ConsoleKeyInfo CKI;
			public KeyHandler KeyHandler;
			public bool ResetCompletion;
			
			public Handler (ConsoleKey key, KeyHandler h, bool resetCompletion = true)
			{
				CKI = new ConsoleKeyInfo ((char) 0, key, false, false, false);
				KeyHandler = h;
				ResetCompletion = resetCompletion;
			}

			public Handler (char c, KeyHandler h, bool resetCompletion = true)
			{
				KeyHandler = h;
				// Use the "Zoom" as a flag that we only have a character.
				CKI = new ConsoleKeyInfo (c, ConsoleKey.Zoom, false, false, false);
				ResetCompletion = resetCompletion;
			}

			public Handler (ConsoleKeyInfo cki, KeyHandler h, bool resetCompletion = true)
			{
				CKI = cki;
				KeyHandler = h;
				ResetCompletion = resetCompletion;
			}
			
			public static Handler Control (char c, KeyHandler h, bool resetCompletion = true)
			{
				return new Handler ((char) (c - 'A' + 1), h, resetCompletion);
			}

			public static Handler Alt (char c, ConsoleKey k, KeyHandler h)
			{
				ConsoleKeyInfo cki = new ConsoleKeyInfo ((char) c, k, false, true, false);
				return new Handler (cki, h);
			}
		}

		/// <summary>
		///   Invoked when the user requests auto-completion using the tab character
		/// </summary>
		/// <remarks>
		///    The result is null for no values found, an array with a single
		///    string, in that case the string should be the text to be inserted
		///    for example if the word at pos is "T", the result for a completion
		///    of "ToString" should be "oString", not "ToString".
		///
		///    When there are multiple results, the result should be the full
		///    text
		/// </remarks>
		public AutoCompleteHandler AutoCompleteEvent;

		static Handler [] handlers;

		public LineEditor (string name) : this (name, 10) { }
		
		public LineEditor (string name, int histsize)
		{
			handlers = new Handler [] {
				new Handler (ConsoleKey.Home,       CmdHome),
				new Handler (ConsoleKey.End,        CmdEnd),
				new Handler (ConsoleKey.LeftArrow,  CmdLeft),
				new Handler (ConsoleKey.RightArrow, CmdRight),
				new Handler (ConsoleKey.UpArrow,    CmdUp, resetCompletion: false),
				new Handler (ConsoleKey.DownArrow,  CmdDown, resetCompletion: false),
				new Handler (ConsoleKey.Enter,      CmdDone, resetCompletion: false),
				new Handler (ConsoleKey.Backspace,  CmdBackspace, resetCompletion: false),
				new Handler (ConsoleKey.Delete,     CmdDeleteChar),
				new Handler (ConsoleKey.Tab,        CmdTabOrComplete, resetCompletion: false),
				
				// Emacs keys
				Handler.Control ('A', CmdHome),
				Handler.Control ('E', CmdEnd),
				Handler.Control ('B', CmdLeft),
				Handler.Control ('F', CmdRight),
				Handler.Control ('P', CmdUp, resetCompletion: false),
				Handler.Control ('N', CmdDown, resetCompletion: false),
				Handler.Control ('K', CmdKillToEOF),
				Handler.Control ('Y', CmdYank),
				Handler.Control ('D', CmdDeleteChar),
				Handler.Control ('L', CmdRefresh),
				Handler.Control ('R', CmdReverseSearch),
				Handler.Control ('G', delegate {} ),
				Handler.Alt ('B', ConsoleKey.B, CmdBackwardWord),
				Handler.Alt ('F', ConsoleKey.F, CmdForwardWord),
				
				Handler.Alt ('D', ConsoleKey.D, CmdDeleteWord),
				Handler.Alt ((char) 8, ConsoleKey.Backspace, CmdDeleteBackword),
				
				// DEBUG
				//Handler.Control ('T', CmdDebug),

				// quote
				Handler.Control ('Q', delegate { HandleChar (Console.ReadKey (true).KeyChar); })
			};

			rendered_text = new StringBuilder ();
			text = new StringBuilder ();

			history = new History (name, histsize);

			GetUnixConsoleReset ();
			//if (File.Exists ("log"))File.Delete ("log");
			//log = File.CreateText ("log"); 
		}

		// On Unix, there is a "default" color which is not represented by any colors in
		// ConsoleColor and it is not possible to set is by setting the ForegroundColor or
		// BackgroundColor properties, so we have to use the terminfo driver in Mono to
		// fetch these values

		void GetUnixConsoleReset ()
		{
			//
			// On Unix, we want to be able to reset the color for the pop-up completion
			//
			int p = (int) Environment.OSVersion.Platform;
			var is_unix = (p == 4) || (p == 128);
			if (!is_unix)
				return;

			// Sole purpose of this call is to initialize the Terminfo driver
			var x = Console.CursorLeft;
			
			try {
				var terminfo_driver = Type.GetType ("System.ConsoleDriver")?.GetField ("driver", BindingFlags.Static | BindingFlags.NonPublic)?.GetValue (null);
				if (terminfo_driver == null)
					return;

				var unix_reset_colors_str = (terminfo_driver?.GetType ()?.GetField ("origPair", BindingFlags.Instance | BindingFlags.NonPublic))?.GetValue (terminfo_driver) as string;
				
				if (unix_reset_colors_str != null)
					unix_reset_colors = Encoding.UTF8.GetBytes ((string)unix_reset_colors_str);
				unix_raw_output = Console.OpenStandardOutput ();
			} catch (Exception e){
				Console.WriteLine ("Error: " + e);
			}
		}
		

		void CmdDebug ()
		{
			history.Dump ();
			Console.WriteLine ();
			Render ();
		}

		void Render ()
		{
			Console.Write (shown_prompt);
			Console.Write (rendered_text);

			int max = System.Math.Max (rendered_text.Length + shown_prompt.Length, max_rendered);
			
			for (int i = rendered_text.Length + shown_prompt.Length; i < max_rendered; i++)
				Console.Write (' ');
			max_rendered = shown_prompt.Length + rendered_text.Length;

			// Write one more to ensure that we always wrap around properly if we are at the
			// end of a line.
			Console.Write (' ');

			UpdateHomeRow (max);
		}

		void UpdateHomeRow (int screenpos)
		{
			int lines = 1 + (screenpos / Console.WindowWidth);

			home_row = Console.CursorTop - (lines - 1);
			if (home_row < 0)
				home_row = 0;
		}
		

		void RenderFrom (int pos)
		{
			int rpos = TextToRenderPos (pos);
			int i;
			
			for (i = rpos; i < rendered_text.Length; i++)
				Console.Write (rendered_text [i]);

			if ((shown_prompt.Length + rendered_text.Length) > max_rendered)
				max_rendered = shown_prompt.Length + rendered_text.Length;
			else {
				int max_extra = max_rendered - shown_prompt.Length;
				for (; i < max_extra; i++)
					Console.Write (' ');
			}
		}

		void ComputeRendered ()
		{
			rendered_text.Length = 0;

			for (int i = 0; i < text.Length; i++){
				int c = (int) text [i];
				if (c < 26){
					if (c == '\t')
						rendered_text.Append ("    ");
					else {
						rendered_text.Append ('^');
						rendered_text.Append ((char) (c + (int) 'A' - 1));
					}
				} else
					rendered_text.Append ((char)c);
			}
		}

		int TextToRenderPos (int pos)
		{
			int p = 0;

			for (int i = 0; i < pos; i++){
				int c;

				c = (int) text [i];
				
				if (c < 26){
					if (c == 9)
						p += 4;
					else
						p += 2;
				} else
					p++;
			}

			return p;
		}

		int TextToScreenPos (int pos)
		{
			return shown_prompt.Length + TextToRenderPos (pos);
		}
		
		string Prompt {
			get { return prompt; }
			set { prompt = value; }
		}

		int LineCount {
			get {
				return (shown_prompt.Length + rendered_text.Length)/Console.WindowWidth;
			}
		}
		
		void ForceCursor (int newpos)
		{
			cursor = newpos;

			int actual_pos = shown_prompt.Length + TextToRenderPos (cursor);
			int row = home_row + (actual_pos/Console.WindowWidth);
			int col = actual_pos % Console.WindowWidth;

			if (row >= Console.BufferHeight)
				row = Console.BufferHeight-1;
			Console.SetCursorPosition (col, row);
			
			//log.WriteLine ("Going to cursor={0} row={1} col={2} actual={3} prompt={4} ttr={5} old={6}", newpos, row, col, actual_pos, prompt.Length, TextToRenderPos (cursor), cursor);
			//log.Flush ();
		}

		void UpdateCursor (int newpos)
		{
			if (cursor == newpos)
				return;

			ForceCursor (newpos);
		}

		void InsertChar (char c)
		{
			int prev_lines = LineCount;
			text = text.Insert (cursor, c);
			ComputeRendered ();
			if (prev_lines != LineCount){

				Console.SetCursorPosition (0, home_row);
				Render ();
				ForceCursor (++cursor);
			} else {
				RenderFrom (cursor);
				ForceCursor (++cursor);
				UpdateHomeRow (TextToScreenPos (cursor));
			}
		}

		static void SaveExcursion (Action code)
		{
			var saved_col = Console.CursorLeft;
			var saved_row = Console.CursorTop;
			var saved_fore = Console.ForegroundColor;
			var saved_back = Console.BackgroundColor;
			
			code ();
			
			Console.CursorLeft = saved_col;
			Console.CursorTop = saved_row;
			if (unix_reset_colors != null){
				unix_raw_output.Write (unix_reset_colors, 0, unix_reset_colors.Length);
			} else {
				Console.ForegroundColor = saved_fore;
				Console.BackgroundColor = saved_back;
			}
		}
		
		class CompletionState {
			public string Prefix;
			public string [] Completions;
			public int Col, Row, Width, Height;
			int selected_item, top_item;

			public CompletionState (int col, int row, int width, int height)
			{
				Col = col;
				Row = row;
				Width = width;
				Height = height;

				if (Col < 0)
					throw new ArgumentException ("Cannot be less than zero" + Col, "Col");
				if (Row < 0)
					throw new ArgumentException ("Cannot be less than zero", "Row");
				if (Width < 1)
					throw new ArgumentException ("Cannot be less than one", "Width");
				if (Height < 1)
					throw new ArgumentException ("Cannot be less than one", "Height");
				
			}
			
			void DrawSelection ()
			{
				for (int r = 0; r < Height; r++){
					int item_idx = top_item + r;
					bool selected = (item_idx == selected_item);
					
					Console.ForegroundColor = selected ? ConsoleColor.Black : ConsoleColor.Gray;
					Console.BackgroundColor = selected ? ConsoleColor.Cyan : ConsoleColor.Blue;

					var item = Prefix + Completions [item_idx];
					if (item.Length > Width)
						item = item.Substring (0, Width);

					Console.CursorLeft = Col;
					Console.CursorTop = Row + r;
					Console.Write (item);
					for (int space = item.Length; space <= Width; space++)
						Console.Write (" ");
				}
			}

			public string Current {
				get {
					return Completions [selected_item];
				}
			}
			
			public void Show ()
			{
				SaveExcursion (DrawSelection);
			}

			public void SelectNext ()
			{
				if (selected_item+1 < Completions.Length){
					selected_item++;
					if (selected_item - top_item >= Height)
						top_item++;
					SaveExcursion (DrawSelection);
				}
			}

			public void SelectPrevious ()
			{
				if (selected_item > 0){
					selected_item--;
					if (selected_item < top_item)
						top_item = selected_item;
					SaveExcursion (DrawSelection);
				}
			}

			void Clear ()
			{
				for (int r = 0; r < Height; r++){
					Console.CursorLeft = Col;
					Console.CursorTop = Row + r;
					for (int space = 0; space <= Width; space++)
						Console.Write (" ");
				}
			}
			
			public void Remove ()
			{
				SaveExcursion (Clear);
			}
		}

		void ShowCompletions (string prefix, string [] completions)
		{
			// Ensure we have space, determine window size
			int window_height = System.Math.Min (completions.Length, Console.WindowHeight/5);
			int target_line = Console.WindowHeight-window_height-1;
			if (Console.CursorTop > target_line){
				var saved_left = Console.CursorLeft;
				var delta = Console.CursorTop-target_line;
				Console.CursorLeft = 0;
				Console.CursorTop = Console.WindowHeight-1;
				for (int i = 0; i < delta+1; i++){
					for (int c = Console.WindowWidth; c > 0; c--)
						Console.Write (" "); // To debug use ("{0}", i%10);
				}
				Console.CursorTop = target_line;
				Console.CursorLeft = 0;
				Render ();
			}

			const int MaxWidth = 50;
			int window_width = 12;
			int plen = prefix.Length;
			foreach (var s in completions)
				window_width = System.Math.Max (plen + s.Length, window_width);
			window_width = System.Math.Min (window_width, MaxWidth);

			if (current_completion == null){
				int left = Console.CursorLeft-prefix.Length;
				
				if (left + window_width + 1 >= Console.WindowWidth)
					left = Console.WindowWidth-window_width-1;
				
				current_completion = new CompletionState (left, Console.CursorTop+1, window_width, window_height) {
					Prefix = prefix,
					Completions = completions,
				};
			} else {
				current_completion.Prefix = prefix;
				current_completion.Completions = completions;
			}
			current_completion.Show ();
			Console.CursorLeft = 0;
		}

		void HideCompletions ()
		{
			if (current_completion == null)
				return;
			current_completion.Remove ();
			current_completion = null;
		}

		//
		// Triggers the completion engine, if insertBestMatch is true, then this will
		// insert the best match found, this behaves like the shell "tab" which will
		// complete as much as possible given the options.
		//
		void Complete ()
		{
			Completion completion = AutoCompleteEvent (text.ToString (), cursor);
			string [] completions = completion.Result;
			if (completions == null){
				HideCompletions ();
				return;
			}
					
			int ncompletions = completions.Length;
			if (ncompletions == 0){
				HideCompletions ();
				return;
			}
					
			if (completions.Length == 1){
				InsertTextAtCursor (completions [0]);
				HideCompletions ();
			} else {
				int last = -1;

				for (int p = 0; p < completions [0].Length; p++){
					char c = completions [0][p];


					for (int i = 1; i < ncompletions; i++){
						if (completions [i].Length < p)
							goto mismatch;
							
						if (completions [i][p] != c){
							goto mismatch;
						}
					}
					last = p;
				}
			mismatch:
				var prefix = completion.Prefix;
				if (last != -1){
					InsertTextAtCursor (completions [0].Substring (0, last+1));

					// Adjust the completions to skip the common prefix
					prefix += completions [0].Substring (0, last+1);
					for (int i = 0; i < completions.Length; i++)
						completions [i] = completions [i].Substring (last+1);
				}
				ShowCompletions (prefix, completions);
				Render ();
				ForceCursor (cursor);
			}
		}

		//
		// When the user has triggered a completion window, this will try to update
		// the contents of it.   The completion window is assumed to be hidden at this
		// point
		// 
		void UpdateCompletionWindow ()
		{
			if (current_completion != null)
				throw new Exception ("This method should only be called if the window has been hidden");
			
			Completion completion = AutoCompleteEvent (text.ToString (), cursor);
			string [] completions = completion.Result;
			if (completions == null)
				return;
					
			int ncompletions = completions.Length;
			if (ncompletions == 0)
				return;
			
			ShowCompletions (completion.Prefix, completion.Result);
			Render ();
			ForceCursor (cursor);
		}
		
		
		//
		// Commands
		//
		void CmdDone ()
		{
			if (current_completion != null){
				InsertTextAtCursor (current_completion.Current);
				HideCompletions ();
				return;
			}
			done = true;
		}

		void CmdTabOrComplete ()
		{
			bool complete = false;

			if (AutoCompleteEvent != null){
				if (TabAtStartCompletes)
					complete = true;
				else {
					for (int i = 0; i < cursor; i++){
						if (!Char.IsWhiteSpace (text [i])){
							complete = true;
							break;
						}
					}
				}

				if (complete)
					Complete ();
				else
					HandleChar ('\t');
			} else
				HandleChar ('t');
		}
		
		void CmdHome ()
		{
			UpdateCursor (0);
		}

		void CmdEnd ()
		{
			UpdateCursor (text.Length);
		}
		
		void CmdLeft ()
		{
			if (cursor == 0)
				return;

			UpdateCursor (cursor-1);
		}

		void CmdBackwardWord ()
		{
			int p = WordBackward (cursor);
			if (p == -1)
				return;
			UpdateCursor (p);
		}

		void CmdForwardWord ()
		{
			int p = WordForward (cursor);
			if (p == -1)
				return;
			UpdateCursor (p);
		}

		void CmdRight ()
		{
			if (cursor == text.Length)
				return;

			UpdateCursor (cursor+1);
		}

		void RenderAfter (int p)
		{
			ForceCursor (p);
			RenderFrom (p);
			ForceCursor (cursor);
		}
		
		void CmdBackspace ()
		{
			if (cursor == 0)
				return;

			bool completing = current_completion != null;
			HideCompletions ();
			
			text.Remove (--cursor, 1);
			ComputeRendered ();
			RenderAfter (cursor);
			if (completing)
				UpdateCompletionWindow ();
		}

		void CmdDeleteChar ()
		{
			// If there is no input, this behaves like EOF
			if (text.Length == 0){
				done = true;
				text = null;
				Console.WriteLine ();
				return;
			}
			
			if (cursor == text.Length)
				return;
			text.Remove (cursor, 1);
			ComputeRendered ();
			RenderAfter (cursor);
		}

		int WordForward (int p)
		{
			if (p >= text.Length)
				return -1;

			int i = p;
			if (Char.IsPunctuation (text [p]) || Char.IsSymbol (text [p]) || Char.IsWhiteSpace (text[p])){
				for (; i < text.Length; i++){
					if (Char.IsLetterOrDigit (text [i]))
					    break;
				}
				for (; i < text.Length; i++){
					if (!Char.IsLetterOrDigit (text [i]))
					    break;
				}
			} else {
				for (; i < text.Length; i++){
					if (!Char.IsLetterOrDigit (text [i]))
					    break;
				}
			}
			if (i != p)
				return i;
			return -1;
		}

		int WordBackward (int p)
		{
			if (p == 0)
				return -1;

			int i = p-1;
			if (i == 0)
				return 0;
			
			if (Char.IsPunctuation (text [i]) || Char.IsSymbol (text [i]) || Char.IsWhiteSpace (text[i])){
				for (; i >= 0; i--){
					if (Char.IsLetterOrDigit (text [i]))
						break;
				}
				for (; i >= 0; i--){
					if (!Char.IsLetterOrDigit (text[i]))
						break;
				}
			} else {
				for (; i >= 0; i--){
					if (!Char.IsLetterOrDigit (text [i]))
						break;
				}
			}
			i++;
			
			if (i != p)
				return i;

			return -1;
		}
		
		void CmdDeleteWord ()
		{
			int pos = WordForward (cursor);

			if (pos == -1)
				return;

			string k = text.ToString (cursor, pos-cursor);
			
			if (last_handler == CmdDeleteWord)
				kill_buffer = kill_buffer + k;
			else
				kill_buffer = k;
			
			text.Remove (cursor, pos-cursor);
			ComputeRendered ();
			RenderAfter (cursor);
		}
		
		void CmdDeleteBackword ()
		{
			int pos = WordBackward (cursor);
			if (pos == -1)
				return;

			string k = text.ToString (pos, cursor-pos);
			
			if (last_handler == CmdDeleteBackword)
				kill_buffer = k + kill_buffer;
			else
				kill_buffer = k;
			
			text.Remove (pos, cursor-pos);
			ComputeRendered ();
			RenderAfter (pos);
		}
		
		//
		// Adds the current line to the history if needed
		//
		void HistoryUpdateLine ()
		{
			history.Update (text.ToString ());
		}
		
		void CmdHistoryPrev ()
		{
			if (!history.PreviousAvailable ())
				return;

			HistoryUpdateLine ();
			
			SetText (history.Previous ());
		}

		void CmdHistoryNext ()
		{
			if (!history.NextAvailable())
				return;

			history.Update (text.ToString ());
			SetText (history.Next ());
			
		}

		void CmdUp ()
		{
			if (current_completion == null)
				CmdHistoryPrev ();
			else
				current_completion.SelectPrevious ();
		}

		void CmdDown ()
		{
			if (current_completion == null)
				CmdHistoryNext ();
			else
				current_completion.SelectNext ();
		}
		
		void CmdKillToEOF ()
		{
			kill_buffer = text.ToString (cursor, text.Length-cursor);
			text.Length = cursor;
			ComputeRendered ();
			RenderAfter (cursor);
		}

		void CmdYank ()
		{
			InsertTextAtCursor (kill_buffer);
		}

		void InsertTextAtCursor (string str)
		{
			int prev_lines = LineCount;
			text.Insert (cursor, str);
			ComputeRendered ();
			if (prev_lines != LineCount){
				Console.SetCursorPosition (0, home_row);
				Render ();
				cursor += str.Length;
				ForceCursor (cursor);
			} else {
				RenderFrom (cursor);
				cursor += str.Length;
				ForceCursor (cursor);
				UpdateHomeRow (TextToScreenPos (cursor));
			}
		}
		
		void SetSearchPrompt (string s)
		{
			SetPrompt ("(reverse-i-search)`" + s + "': ");
		}

		void ReverseSearch ()
		{
			int p;

			if (cursor == text.Length){
				// The cursor is at the end of the string
				
				p = text.ToString ().LastIndexOf (search);
				if (p != -1){
					match_at = p;
					cursor = p;
					ForceCursor (cursor);
					return;
				}
			} else {
				// The cursor is somewhere in the middle of the string
				int start = (cursor == match_at) ? cursor - 1 : cursor;
				if (start != -1){
					p = text.ToString ().LastIndexOf (search, start);
					if (p != -1){
						match_at = p;
						cursor = p;
						ForceCursor (cursor);
						return;
					}
				}
			}

			// Need to search backwards in history
			HistoryUpdateLine ();
			string s = history.SearchBackward (search);
			if (s != null){
				match_at = -1;
				SetText (s);
				ReverseSearch ();
			}
		}
		
		void CmdReverseSearch ()
		{
			if (searching == 0){
				match_at = -1;
				last_search = search;
				searching = -1;
				search = "";
				SetSearchPrompt ("");
			} else {
				if (search == ""){
					if (last_search != "" && last_search != null){
						search = last_search;
						SetSearchPrompt (search);

						ReverseSearch ();
					}
					return;
				}
				ReverseSearch ();
			} 
		}

		void SearchAppend (char c)
		{
			search = search + c;
			SetSearchPrompt (search);

			//
			// If the new typed data still matches the current text, stay here
			//
			if (cursor < text.Length){
				string r = text.ToString (cursor, text.Length - cursor);
				if (r.StartsWith (search))
					return;
			}

			ReverseSearch ();
		}
		
		void CmdRefresh ()
		{
			Console.Clear ();
			max_rendered = 0;
			Render ();
			ForceCursor (cursor);
		}

		void InterruptEdit (object sender, ConsoleCancelEventArgs a)
		{
			// Do not abort our program:
			a.Cancel = true;

			// Interrupt the editor
			edit_thread.Abort();
		}

		//
		// Implements heuristics to show the completion window based on the mode
		//
		bool HeuristicAutoComplete (bool wasCompleting, char insertedChar)
		{
			if (HeuristicsMode == "csharp"){
				// csharp heuristics
				if (wasCompleting){
					if (insertedChar == ' '){
						return false;
					}
					return true;
				} 
				// If we were not completing, determine if we want to now
				if (insertedChar == '.'){
					// Avoid completing for numbers "1.2" for example
					if (cursor > 1 && Char.IsDigit (text[cursor-2])){
						for (int p = cursor-3; p >= 0; p--){
							char c = text[p];
							if (Char.IsDigit (c))
								continue;
							if (c == '_')
								return true;
							if (Char.IsLetter (c) || Char.IsPunctuation (c) || Char.IsSymbol (c) || Char.IsControl (c))
								return true;
						}
						return false;
					}
					return true;
				}
			}
			return false;
		}
		
		void HandleChar (char c)
		{
			if (searching != 0)
				SearchAppend (c);
			else {
				bool completing = current_completion != null;
				HideCompletions ();

				InsertChar (c);
				if (HeuristicAutoComplete (completing, c))
					UpdateCompletionWindow ();
			}
		}

		void EditLoop ()
		{
			ConsoleKeyInfo cki;

			while (!done){
				ConsoleModifiers mod;
				
				cki = Console.ReadKey (true);
				if (cki.Key == ConsoleKey.Escape){
					if (current_completion != null){
						HideCompletions ();
						continue;
					} else {
						cki = Console.ReadKey (true);
						
						mod = ConsoleModifiers.Alt;
					}
				} else
					mod = cki.Modifiers;
				
				bool handled = false;

				foreach (Handler handler in handlers){
					ConsoleKeyInfo t = handler.CKI;

					if (t.Key == cki.Key && t.Modifiers == mod){
						handled = true;
						if (handler.ResetCompletion)
							HideCompletions ();
						handler.KeyHandler ();
						last_handler = handler.KeyHandler;
						break;
					} else if (t.KeyChar == cki.KeyChar && t.Key == ConsoleKey.Zoom){
						handled = true;
						if (handler.ResetCompletion)
							HideCompletions ();

						handler.KeyHandler ();
						last_handler = handler.KeyHandler;
						break;
					}
				}
				if (handled){
					if (searching != 0){
						if (last_handler != CmdReverseSearch){
							searching = 0;
							SetPrompt (prompt);
						}
					}
					continue;
				}

				if (cki.KeyChar != (char) 0){
					HandleChar (cki.KeyChar);
				}
			} 
		}

		void InitText (string initial)
		{
			text = new StringBuilder (initial);
			ComputeRendered ();
			cursor = text.Length;
			Render ();
			ForceCursor (cursor);
		}

		void SetText (string newtext)
		{
			Console.SetCursorPosition (0, home_row);
			InitText (newtext);
		}

		void SetPrompt (string newprompt)
		{
			shown_prompt = newprompt;
			Console.SetCursorPosition (0, home_row);
			Render ();
			ForceCursor (cursor);
		}
		
		public string Edit (string prompt, string initial)
		{
			edit_thread = Thread.CurrentThread;
			searching = 0;
			Console.CancelKeyPress += InterruptEdit;
						
			done = false;
			history.CursorToEnd ();
			max_rendered = 0;
			
			Prompt = prompt;
			shown_prompt = prompt;
			InitText (initial);
			history.Append (initial);

			do {
				try {
					EditLoop ();
				} catch (ThreadAbortException){
					searching = 0;
					Thread.ResetAbort ();
					Console.WriteLine ();
					SetPrompt (prompt);
					SetText ("");
				}
			} while (!done);
			Console.WriteLine ();
			
			Console.CancelKeyPress -= InterruptEdit;

			if (text == null){
				history.Close ();
				return null;
			}

			string result = text.ToString ();
			if (result != "")
				history.Accept (result);
			else
				history.RemoveLast ();

			return result;
		}
		
		public void SaveHistory ()
		{
			if (history != null) {
				history.Close ();
			}
		}

		public bool TabAtStartCompletes { get; set; }
			
		//
		// Emulates the bash-like behavior, where edits done to the
		// history are recorded
		//
		class History {
			string [] history;
			int head, tail;
			int cursor, count;
			string histfile;
			
			public History (string app, int size)
			{
				if (size < 1)
					throw new ArgumentException ("size");

				if (app != null){
					string dir = Environment.GetFolderPath (Environment.SpecialFolder.ApplicationData);
					//Console.WriteLine (dir);
					if (!Directory.Exists (dir)){
						try {
							Directory.CreateDirectory (dir);
						} catch {
							app = null;
						}
					}
					if (app != null)
						histfile = Path.Combine (dir, app) + ".history";
				}
				
				history = new string [size];
				head = tail = cursor = 0;

				if (File.Exists (histfile)){
					using (StreamReader sr = File.OpenText (histfile)){
						string line;
						
						while ((line = sr.ReadLine ()) != null){
							if (line != "")
								Append (line);
						}
					}
				}
			}

			public void Close ()
			{
				if (histfile == null)
					return;

				try {
					using (StreamWriter sw = File.CreateText (histfile)){
						int start = (count == history.Length) ? head : tail;
						for (int i = start; i < start+count; i++){
							int p = i % history.Length;
							sw.WriteLine (history [p]);
						}
					}
				} catch {
					// ignore
				}
			}
			
			//
			// Appends a value to the history
			//
			public void Append (string s)
			{
				//Console.WriteLine ("APPENDING {0} head={1} tail={2}", s, head, tail);
				history [head] = s;
				head = (head+1) % history.Length;
				if (head == tail)
					tail = (tail+1 % history.Length);
				if (count != history.Length)
					count++;
				//Console.WriteLine ("DONE: head={1} tail={2}", s, head, tail);
			}

			//
			// Updates the current cursor location with the string,
			// to support editing of history items.   For the current
			// line to participate, an Append must be done before.
			//
			public void Update (string s)
			{
				history [cursor] = s;
			}

			public void RemoveLast ()
			{
				head = head-1;
				if (head < 0)
					head = history.Length-1;
			}
			
			public void Accept (string s)
			{
				int t = head-1;
				if (t < 0)
					t = history.Length-1;
				
				history [t] = s;
			}
			
			public bool PreviousAvailable ()
			{
				//Console.WriteLine ("h={0} t={1} cursor={2}", head, tail, cursor);
				if (count == 0)
					return false;
				int next = cursor-1;
				if (next < 0)
					next = count-1;

				if (next == head)
					return false;

				return true;
			}

			public bool NextAvailable ()
			{
				if (count == 0)
					return false;
				int next = (cursor + 1) % history.Length;
				if (next == head)
					return false;
				return true;
			}
			
			
			//
			// Returns: a string with the previous line contents, or
			// nul if there is no data in the history to move to.
			//
			public string Previous ()
			{
				if (!PreviousAvailable ())
					return null;

				cursor--;
				if (cursor < 0)
					cursor = history.Length - 1;

				return history [cursor];
			}

			public string Next ()
			{
				if (!NextAvailable ())
					return null;

				cursor = (cursor + 1) % history.Length;
				return history [cursor];
			}

			public void CursorToEnd ()
			{
				if (head == tail)
					return;

				cursor = head;
			}

			public void Dump ()
			{
				Console.WriteLine ("Head={0} Tail={1} Cursor={2} count={3}", head, tail, cursor, count);
				for (int i = 0; i < history.Length;i++){
					Console.WriteLine (" {0} {1}: {2}", i == cursor ? "==>" : "   ", i, history[i]);
				}
				//log.Flush ();
			}

			public string SearchBackward (string term)
			{
				for (int i = 0; i < count; i++){
					int slot = cursor-i-1;
					if (slot < 0)
						slot = history.Length+slot;
					if (slot >= history.Length)
						slot = 0;
					if (history [slot] != null && history [slot].IndexOf (term) != -1){
						cursor = slot;
						return history [slot];
					}
				}

				return null;
			}
			
		}
	}

#if DEMO
	class Demo {
		static void Main ()
		{
			LineEditor le = new LineEditor ("foo") {
				HeuristicsMode = "csharp"
			};
			le.AutoCompleteEvent += delegate (string a, int pos){
				string prefix = "";
				var completions = new string [] { "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine", "Ten" };
				return new Mono.Terminal.LineEditor.Completion (prefix, completions);
			};
			
			string s;
			
			while ((s = le.Edit ("shell> ", "")) != null){
				Console.WriteLine ("----> [{0}]", s);
			}
		}
	}
#endif
}