// ext may be null, but then parameter completion don't work
		public static bool ShowWindow (CompletionTextEditorExtension ext, char firstChar, ICompletionDataList list, ICompletionWidget completionWidget, CodeCompletionContext completionContext)
		{
			try {
				if (ext != null) {
					int inserted = ext.document.Editor.EnsureCaretIsNotVirtual ();
					if (inserted > 0)
						completionContext.TriggerOffset = ext.document.Editor.Caret.Offset;
				}
				if (wnd == null) {
					wnd = new CompletionListWindow ();
					wnd.WordCompleted += HandleWndWordCompleted;
				}
				wnd.Extension = ext;
				try {
					if (!wnd.ShowListWindow (firstChar, list, completionWidget, completionContext)) {
						if (list is IDisposable)
							((IDisposable)list).Dispose ();
						HideWindow ();
						return false;
					}
					
					if (ForceSuggestionMode)
						wnd.AutoSelect = false;
					wnd.Show ();
					DesktopService.RemoveWindowShadow (wnd);
					OnWindowShown (EventArgs.Empty);
					return true;
				} catch (Exception ex) {
					LoggingService.LogError (ex.ToString ());
					return false;
				}
			} finally {
				ParameterInformationWindowManager.UpdateWindow (ext, completionWidget);
			}
		}

		public static bool ShowWindow (char firstChar, ICompletionDataList list, ICompletionWidget completionWidget, CodeCompletionContext completionContext, System.Action closedDelegate)
		{
			try {
				if (wnd == null) {
					wnd = new CompletionListWindow ();
					wnd.WordCompleted += HandleWndWordCompleted;
				}
				try {
					if (!wnd.ShowListWindow (firstChar, list, completionWidget, completionContext, closedDelegate)) {
						if (list is IDisposable)
							((IDisposable)list).Dispose ();
						DestroyWindow ();
						return false;
					}
					
					if (ForceSuggestionMode)
						wnd.AutoSelect = false;
					
					OnWindowShown (EventArgs.Empty);
					return true;
				} catch (Exception ex) {
					LoggingService.LogError (ex.ToString ());
					return false;
				}
			} finally {
				ParameterInformationWindowManager.UpdateWindow (completionWidget);
			}
		}

        public void InsertCompletionText(ICompletionWidget widget, CodeCompletionContext context)
        {
            // insert add/remove event handler code after +=/-=
            editor.Replace (initialOffset, editor.Caret.Offset - initialOffset, this.DisplayText + ";");

            // Search opening bracket of member
            int pos = editor.Document.LocationToOffset (callingMember.BodyRegion.Start.Line - 1, callingMember.BodyRegion.Start.Column - 1);
            while (pos < editor.Document.Length && editor.Document.GetCharAt (pos) != '{') {
                pos++;
            }

            // Search closing bracket of member
            pos = editor.Document.GetMatchingBracketOffset (pos) + 1;

            pos = Math.Max (0, Math.Min (pos, editor.Document.Length - 1));

            // Insert new event handler after closing bracket
            string indent = editor.Document.GetLine (callingMember.Location.Line).GetIndentation (editor.Document);

            StringBuilder sb = new StringBuilder ();
            sb.AppendLine ();
            sb.AppendLine ();
            sb.Append (indent);
            if (callingMember.IsStatic)
                sb.Append ("static ");
            sb.Append ("void ");sb.Append (this.DisplayText);sb.Append (' ');sb.Append (this.parameterList);sb.AppendLine ();
            sb.Append (indent);sb.Append ("{");sb.AppendLine ();
            sb.Append (indent);sb.Append (TextEditorProperties.IndentString);
            int cursorPos = pos + sb.Length;
            sb.AppendLine ();
            sb.Append (indent);sb.Append ("}");
            editor.Insert (pos, sb.ToString ());
            editor.Caret.Offset = cursorPos;
        }

		// Called when a key is pressed in the editor.
		// Returns false if the key press has to continue normal processing.
		internal static bool ProcessKeyEvent (CompletionTextEditorExtension ext, ICompletionWidget widget, KeyDescriptor descriptor)
		{
			if (methods.Count == 0)
				return false;

			MethodData cmd = methods [methods.Count - 1];

			if (descriptor.SpecialKey == SpecialKey.Down) {
				if (cmd.MethodProvider.Count <= 1)
					return false;
				if (cmd.CurrentOverload < cmd.MethodProvider.Count - 1)
					cmd.CurrentOverload ++;
				else
					cmd.CurrentOverload = 0;
				window.ChangeOverload ();
				UpdateWindow (ext, widget);
				return true;
			} else if (descriptor.SpecialKey == SpecialKey.Up) {
				if (cmd.MethodProvider.Count <= 1)
					return false;
				if (cmd.CurrentOverload > 0)
					cmd.CurrentOverload --;
				else
					cmd.CurrentOverload = cmd.MethodProvider.Count - 1;
				window.ChangeOverload ();
				UpdateWindow (ext, widget);
				return true;
			}
			else if (descriptor.SpecialKey == SpecialKey.Escape) {
				HideWindow (ext, widget);
				return true;
			}
			return false;
		}

		public static void PostProcessKeyEvent (ICompletionWidget widget, Gdk.Key key, Gdk.ModifierType modifier)
		{
			// Called after the key has been processed by the editor
		
			if (methods.Count == 0)
				return;
				
			for (int n=0; n<methods.Count; n++) {
				// If the cursor is outside of any of the methods parameter list, discard the
				// information window for that method.
				
				MethodData md = methods [n];
				int pos = md.MethodProvider.GetCurrentParameterIndex (widget, md.CompletionContext);
				if (pos == -1) {
					methods.RemoveAt (n);
					n--;
				}
			}
			// If the user enters more parameters than the current overload has,
			// look for another overload with more parameters.
			UpdateOverload (widget);
			
			// Refresh.
			UpdateWindow (widget);
		}

		// Called when a key is pressed in the editor.
		// Returns false if the key press has to continue normal processing.
		public static bool ProcessKeyEvent (ICompletionWidget widget, Gdk.Key key, Gdk.ModifierType modifier)
		{
			if (methods.Count == 0)
				return false;

			MethodData cmd = methods [methods.Count - 1];
			
			if (key == Gdk.Key.Down) {
				if (cmd.MethodProvider.OverloadCount <= 1)
					return false;
				if (cmd.CurrentOverload < cmd.MethodProvider.OverloadCount - 1)
					cmd.CurrentOverload ++;
				else
					cmd.CurrentOverload = 0;
				UpdateWindow (widget);
				return true;
			}
			else if (key == Gdk.Key.Up) {
				if (cmd.MethodProvider.OverloadCount <= 1)
					return false;
				if (cmd.CurrentOverload > 0)
					cmd.CurrentOverload --;
				else
					cmd.CurrentOverload = cmd.MethodProvider.OverloadCount - 1;
				UpdateWindow (widget);
				return true;
			}
			else if (key == Gdk.Key.Escape) {
				HideWindow (widget);
				return true;
			}
			return false;
		}

		public static void ShowWindow (char firstChar, ICompletionDataProvider provider, ICompletionWidget completionWidget, ICodeCompletionContext completionContext, CompletionDelegate closedDelegate)
		{
			try {
				if (!wnd.ShowListWindow (firstChar, provider,  completionWidget, completionContext, closedDelegate)) {
					provider.Dispose ();
					return;
				}
				
				// makes control-space in midle of words to work
				string text = wnd.completionWidget.GetCompletionText (completionContext);
				if (text.Length == 0) {
					text = provider.DefaultCompletionString;
					if (text != null && text.Length > 0)
						wnd.SelectEntry (text);
					return;
				}
				
				wnd.PartialWord = text; 
				//if there is only one matching result we take it by default
				if (wnd.IsUniqueMatch && !wnd.IsChanging)
				{	
					wnd.UpdateWord ();
					wnd.Hide ();
				}
				
			} catch (Exception ex) {
				Console.WriteLine (ex);
			}
		}

		// Returns the index of the parameter where the cursor is currently positioned.
		// -1 means the cursor is outside the method parameter list
		// 0 means no parameter entered
		// > 0 is the index of the parameter (1-based)
		public int GetCurrentParameterIndex (ICompletionWidget widget, CodeCompletionContext ctx)
		{
			int cursor = widget.CurrentCodeCompletionContext.TriggerOffset;
			int i = ctx.TriggerOffset;
			if (i < 0 || i >= editor.Length || editor.GetCharAt (i) == ')')
				return -1;
			
			if (i > cursor)
				return -1;
			else if (i == cursor)
				return 0;
			
			int parameterIndex = 1;
			
			while (i++ < cursor) {
				if (i >= widget.TextLength)
					break;
				char ch = widget.GetChar (i);
				if (ch == ',')
					parameterIndex++;
				else if (ch == ')')
					return -1;
			}
			
			return parameterIndex;
		}

        public int GetCurrentParameterIndex(ICompletionWidget widget, CodeCompletionContext ctx)
        {
            if (showCompletion)
            {
                return 0;
            }

            return -1;
        }

        public ICompletionData[] GenerateCompletionData(ICompletionWidget widget, char charTyped)
        {
            CodeTemplateGroup templateGroup = CodeTemplateLoader.GetTemplateGroupPerFilename (fileName);
            if (templateGroup == null) {
                return null;
            }
            ArrayList completionData = new ArrayList();
            foreach (CodeTemplate template in templateGroup.Templates) {
                completionData.Add(new TemplateCompletionData(template));
            }

            return (ICompletionData[])completionData.ToArray(typeof(ICompletionData));
        }

		internal static bool OverloadDown (CompletionTextEditorExtension ext, ICompletionWidget widget)
		{
			if (currentMethodGroup == null)
				return false;
			if (currentMethodGroup.MethodProvider.Count <= 1)
				return false;
			if (currentMethodGroup.CurrentOverload < currentMethodGroup.MethodProvider.Count - 1)
				currentMethodGroup.CurrentOverload ++;
			else
				currentMethodGroup.CurrentOverload = 0;
			window.ChangeOverload ();
			UpdateWindow (ext, widget);
			return true;
		}

		public void ShowCompletion (ICompletionDataList completionList)
		{
			completionWidget = Document.GetContent <ICompletionWidget> ();
			currentCompletionContext = completionWidget.CreateCodeCompletionContext (Document.TextEditorData.Caret.Offset);
			int cpos, wlen;
			if (!GetCompletionCommandOffset (out cpos, out wlen)) {
				cpos = Document.TextEditorData.Caret.Offset;
				wlen = 0;
			}
			currentCompletionContext.TriggerOffset = cpos;
			currentCompletionContext.TriggerWordLength = wlen;
			
			CompletionWindowManager.ShowWindow ('\0', completionList, completionWidget, currentCompletionContext, OnCompletionWindowClosed);
		}

		internal static bool OverloadDown (CompletionTextEditorExtension ext, ICompletionWidget widget)
		{
			if (methods.Count == 0)
				return false;
			MethodData cmd = methods [methods.Count - 1];
			if (cmd.MethodProvider.Count <= 1)
				return false;
			if (cmd.CurrentOverload < cmd.MethodProvider.Count - 1)
				cmd.CurrentOverload ++;
			else
				cmd.CurrentOverload = 0;
			window.ChangeOverload ();
			UpdateWindow (ext, widget);
			return true;
		}

		// Called when a key is pressed in the editor.
		// Returns false if the key press has to continue normal processing.
		internal static bool ProcessKeyEvent (CompletionTextEditorExtension ext, ICompletionWidget widget, KeyDescriptor descriptor)
		{
			if (currentMethodGroup == null)
				return false;

			if (descriptor.SpecialKey == SpecialKey.Down) {
				return OverloadDown (ext, widget);
			} else if (descriptor.SpecialKey == SpecialKey.Up) {
				return OverloadUp (ext, widget);
			}
			else if (descriptor.SpecialKey == SpecialKey.Escape) {
				HideWindow (ext, widget);
				return true;
			}
			return false;
		}

        /*		int caretLineNumber;
        int caretColumn;

        string[][] commentTags = new string[][] {
            new string[] {"c", "marks text as code"},
            new string[] {"code", "marks text as code"},
            new string[] {"example", "A description of the code example\n(must have a <code> tag inside)"},
            new string[] {"exception cref=\"\"", "description to an exception thrown"},
            new string[] {"list type=\"\"", "A list"},
            new string[] {"listheader", "The header from the list"},
            new string[] {"item", "A list item"},
            new string[] {"term", "A term in a list"},
            new string[] {"description", "A description to a term in a list"},
            new string[] {"param name=\"\"", "A description for a parameter"},
            new string[] {"paramref name=\"\"", "A reference to a parameter"},
            new string[] {"permission cref=\"\"", ""},
            new string[] {"remarks", "Gives description for a member"},
            new string[] {"include file=\"\" path=\"\"", "Includes comments from other files"},
            new string[] {"returns", "Gives description for a return value"},
            new string[] {"see cref=\"\"", "A reference to a member"},
            new string[] {"seealso cref=\"\"", "A reference to a member in the seealso section"},
            new string[] {"summary", "A summary of the object"},
            new string[] {"value", "A description of a property"}
        };
        */
        public ICompletionData[] GenerateCompletionData(ICompletionWidget widget, char charTyped)
        {
            /*caretLineNumber = textArea.Caret.Line;
            caretColumn     = textArea.Caret.Column;
            LineSegment caretLine = textArea.Document.GetLineSegment(caretLineNumber);
            string lineText = textArea.Document.GetText(caretLine.Offset, caretLine.Length);
            if (!lineText.Trim().StartsWith("///")) {
                return null;
            }
            */
            ArrayList completionData = new ArrayList ();
            /*foreach (string[] tag in commentTags) {
                completionData.Add(new CommentCompletionData(tag[0], tag[1]));
            }*/
            return (ICompletionData[])completionData.ToArray (typeof (ICompletionData));
        }

        public ICompletionData[] GenerateCompletionData(ICompletionWidget widget, char charTyped)
        {
            completionData = new ArrayList();

            // the parser works with 1 based coordinates
            caretLineNumber      = widget.TriggerLine + 1;
            caretColumn          = widget.TriggerLineOffset + 1;
            //string expression    = TextUtilities.GetExpressionBeforeOffset (textArea, insertIter.Offset);
            ResolveResult results;

            IExpressionFinder expressionFinder = parserContext.GetExpressionFinder(fileName);
            string expression    = expressionFinder == null ? TextUtilities.GetExpressionBeforeOffset(widget, widget.TriggerOffset) : expressionFinder.FindExpression(widget.GetText (0, widget.TriggerOffset), widget.TriggerOffset - 2);
            if (expression == null) return null;
            Console.WriteLine ("Expr: |{0}|", expression);
            //FIXME: This chartyped check is a fucking *HACK*
            if (expression == "is" || expression == "as") {
                string expr = expressionFinder == null ? TextUtilities.GetExpressionBeforeOffset (widget, widget.TriggerOffset - 3) : expressionFinder.FindExpression (widget.GetText (0, widget.TriggerOffset), widget.TriggerOffset - 5);
                AddResolveResults (parserContext.IsAsResolve (expr, caretLineNumber, caretColumn, fileName, widget.GetText (0, widget.TextLength)));
                return (ICompletionData[])completionData.ToArray (typeof (ICompletionData));
            }
            if (ctrlspace && charTyped != '.') {
                AddResolveResults (parserContext.CtrlSpace (caretLineNumber, caretColumn, fileName));
                return (ICompletionData[])completionData.ToArray (typeof (ICompletionData));
            }
            if (charTyped == ' ') {
                if (expression == "using" || expression.EndsWith(" using") || expression.EndsWith("\tusing")|| expression.EndsWith("\nusing")|| expression.EndsWith("\rusing")) {
                    string[] namespaces = parserContext.GetNamespaceList ("", true, true);
                    AddResolveResults(new ResolveResult(namespaces));
                }
            } else {
                //FIXME: I added the null check, #D doesnt need it, why do we?
                if (fileName != null) {
                    results = parserContext.Resolve (expression, caretLineNumber, caretColumn, fileName, widget.GetText (0, widget.TextLength));
                    AddResolveResults(results);
                }
            }
            return (ICompletionData[]) completionData.ToArray (typeof (ICompletionData));
        }

		// ext may be null, but then parameter completion don't work
		internal static void PrepareShowWindow (CompletionTextEditorExtension ext, char firstChar, ICompletionWidget completionWidget, CodeCompletionContext completionContext)
		{
			isShowing = true;

			if (wnd == null) {
				wnd = new CompletionListWindow ();
				wnd.WordCompleted += HandleWndWordCompleted;
			}
			if (ext != null) {
				var widget = ext.Editor.GetNativeWidget<Gtk.Widget> ();
				wnd.TransientFor = widget?.Parent?.Toplevel as Gtk.Window;
			} else {
				var widget = completionWidget as Gtk.Widget;
				if (widget != null) {
					var window = widget.Toplevel as Gtk.Window;
					if (window != null)
						wnd.TransientFor = window;
				}
			}
			wnd.Extension = ext;

			wnd.InitializeListWindow (completionWidget, completionContext);
		}

        public int GetCurrentParameterIndex(ICompletionWidget widget, CodeCompletionContext ctx)
        {
            /*
            int cursor = widget.CurrentCodeCompletionContext.TriggerOffset;
            var loc=new CodeLocation(ctx.TriggerLineOffset,ctx.TriggerLine);

            if (args.IsTemplateInstanceArguments)
            {

            }
            else
            {
                var firstArgLocation = CodeLocation.Empty;

                if (args.ParsedExpression is PostfixExpression_MethodCall)
                    firstArgLocation = (args.ParsedExpression as PostfixExpression_MethodCall).Arguments[0].Location;
                else if (args.ParsedExpression is NewExpression)
                    firstArgLocation = (args.ParsedExpression as NewExpression).Arguments[0].Location;
                else
                    return -1;

                if (loc < firstArgLocation)
                    loc = firstArgLocation;

                var code = doc.Editor.Document.GetTextBetween(firstArgLocation.Line,firstArgLocation.Column, scopeMethod.EndLocation.Line, scopeMethod.EndLocation.Column);

                var tr = new StringReader(code);
                var parser = new DParser(new Lexer(tr));
                parser.Lexer.SetInitialLocation(firstArgLocation);
                parser.Step();

                var updatedArguments = parser.ArgumentList();
                tr.Close();

                var lastArg = updatedArguments[updatedArguments.Count - 1];

                for (int i = 0; i < updatedArguments.Count; i++)
                    if ((loc >= updatedArguments[i].Location && loc <= updatedArguments[i].EndLocation) ||
                        (i==updatedArguments.Count-1 && loc <= updatedArguments[i].EndLocation))
                        return i + 1;
            }
            */
            return args.CurrentlyTypedArgumentIndex;
        }

		// ext may be null, but then parameter completion don't work
		internal static bool ShowWindow (CompletionTextEditorExtension ext, char firstChar, ICompletionDataList list, ICompletionWidget completionWidget, CodeCompletionContext completionContext)
		{
			PrepareShowWindow (ext, firstChar, completionWidget, completionContext);
			return ShowWindow (list, completionContext);
		}

		public CodeCompletionContextEventArgs (ICompletionWidget widget, CodeCompletionContext codeCompletionContext, string completedWord)
		{
			this.Widget = widget;
			this.CodeCompletionContext = codeCompletionContext;
			this.CompletedWord = completedWord;
		}