/// <summary>
 /// Applies a highlighting color to a visual line element.
 /// </summary>
 protected virtual void ApplyColorToElement(VisualLineElement element, HighlightingColor color)
 {
     if (color.Foreground != null)
     {
         Brush b = color.Foreground.GetBrush(CurrentContext);
         if (b != null)
             element.TextRunProperties.SetForegroundBrush(b);
     }
     if (color.Background != null)
     {
         Brush b = color.Background.GetBrush(CurrentContext);
         if (b != null)
             element.TextRunProperties.SetBackgroundBrush(b);
     }
     if (color.FontStyle != null || color.FontWeight != null)
     {
         Typeface tf = element.TextRunProperties.Typeface;
         element.TextRunProperties.SetTypeface(new Typeface(
             tf.FontFamily,
             color.FontStyle ?? tf.Style,
             color.FontWeight ?? tf.Weight,
             tf.Stretch
         ));
     }
 }

		internal RichText(string text, int[] offsets, HighlightingColor[] states)
		{
			this.text = text;
			Debug.Assert(offsets[0] == 0);
			Debug.Assert(offsets.Last() <= text.Length);
			this.stateChangeOffsets = offsets;
			this.stateChanges = states;
		}

		static void OnThemeUpdated() {
			var theme = dntheme.Themes.Theme;
			CodeBreakpointHighlightingColor = theme.GetColor(dntheme.ColorType.BreakpointStatement).TextInheritedColor;
			CodeBreakpointDisabledHighlightingColor = theme.GetColor(dntheme.ColorType.DisabledBreakpointStatement).TextInheritedColor;
			StackFrameCurrentHighlightingColor = theme.GetColor(dntheme.ColorType.CurrentStatement).TextInheritedColor;
			StackFrameReturnHighlightingColor = theme.GetColor(dntheme.ColorType.ReturnStatement).TextInheritedColor;
			StackFrameSelectedHighlightingColor = theme.GetColor(dntheme.ColorType.SelectedReturnStatement).TextInheritedColor;
		}

		void OnThemeUpdated(IThemeManager themeManager) {
			var theme = themeManager.Theme;
			CodeBreakpointHighlightingColor = theme.GetTextColor(ColorType.BreakpointStatement).ToHighlightingColor();
			CodeBreakpointDisabledHighlightingColor = theme.GetTextColor(ColorType.DisabledBreakpointStatement).ToHighlightingColor();
			StackFrameCurrentHighlightingColor = theme.GetTextColor(ColorType.CurrentStatement).ToHighlightingColor();
			StackFrameReturnHighlightingColor = theme.GetTextColor(ColorType.ReturnStatement).ToHighlightingColor();
			StackFrameSelectedHighlightingColor = theme.GetTextColor(ColorType.SelectedReturnStatement).ToHighlightingColor();
		}

 public HighlightingDefinition AddRule(string expression, HighlightingColor color)
 {
     var rule = new HighlightingRule
     {
         Regex = expression.ToRegex(),
         Color = color
     };
     return AddRule(rule);
 }

		/// <summary>
		/// Writes the HTML attribute for the style to the text writer.
		/// </summary>
		public virtual void WriteStyleAttributeForColor(TextWriter writer, HighlightingColor color)
		{
			if (writer == null)
				throw new ArgumentNullException("writer");
			if (color == null)
				throw new ArgumentNullException("color");
			writer.Write(" style=\"");
			WebUtility.HtmlEncode(color.ToCss(), writer);
			writer.Write('"');
		}

		public SearchResultMatch(FileName fileName, Location startLocation, Location endLocation, int offset, int length, HighlightedInlineBuilder builder, HighlightingColor defaultTextColor)
		{
			this.fileName = fileName;
			this.startLocation = startLocation;
			this.endLocation = endLocation;
			this.offset = offset;
			this.length = length;
			this.builder = builder;
			this.defaultTextColor = defaultTextColor;
		}

        protected HighlightingColor GetColor()
        {
            var color = new HighlightingColor();

            color.Foreground = GetForeground();
            color.FontWeight = GetFontWeight();
            color.FontStyle = GetFontStyle();
            color.Name = Name;

            return color;
        }

		public SearchResultMatch(FileName fileName, TextLocation startLocation, TextLocation endLocation, int offset, int length, RichText displayText, HighlightingColor defaultTextColor)
		{
			if (fileName == null)
				throw new ArgumentNullException("fileName");
			this.fileName = fileName;
			this.startLocation = startLocation;
			this.endLocation = endLocation;
			this.offset = offset;
			this.length = length;
			this.displayText = displayText;
			this.defaultTextColor = defaultTextColor;
		}

 /// <summary>
 /// Converts <paramref name="self"/> to a <see cref="HighlightingColor"/> instance or null
 /// if input is null
 /// </summary>
 /// <param name="self">This</param>
 /// <returns></returns>
 public static HighlightingColor ToHighlightingColor(this IThemeColor self)
 {
     if (self == null)
         return null;
     var hl = new HighlightingColor {
         Name = self.Name,
         FontWeight = self.FontWeight,
         FontStyle = self.FontStyle,
         Underline = null,
         Foreground = MyHighlightingBrush.Create(self.Foreground),
         Background = MyHighlightingBrush.Create(self.Background),
     };
     hl.Freeze();
     return hl;
 }

		/// <summary>
		/// Applies the properties from the HighlightingColor to the specified text segment.
		/// </summary>
		public void SetHighlighting(int offset, int length, HighlightingColor color)
		{
			if (color == null)
				throw new ArgumentNullException("color");
			int startIndex = GetIndexForOffset(offset);
			int endIndex = GetIndexForOffset(offset + length);
			for (int i = startIndex; i < endIndex; i++) {
				HighlightingState state = stateChanges[i];
				if (color.Foreground != null)
					state.Foreground = color.Foreground.GetBrush(null);
				if (color.FontStyle != null)
					state.Style = color.FontStyle;
				if (color.FontWeight != null)
					state.Weight = color.FontWeight;
			}
		}

		/// <summary>
		/// Applies the properties from the HighlightingColor to the specified text segment.
		/// </summary>
		public void SetHighlighting(int offset, int length, HighlightingColor color)
		{
			if (color == null)
				throw new ArgumentNullException("color");
			if (color.Foreground == null && color.FontStyle == null && color.FontWeight == null) {
				// Optimization: don't split the HighlightingState when we're not changing
				// any property. For example, the "Punctuation" color in C# is
				// empty by default.
				return;
			}
			int startIndex = GetIndexForOffset(offset);
			int endIndex = GetIndexForOffset(offset + length);
			for (int i = startIndex; i < endIndex; i++) {
				HighlightingState state = stateChanges[i];
				if (color.Foreground != null)
					state.Foreground = color.Foreground.GetBrush(null);
				if (color.FontStyle != null)
					state.Style = color.FontStyle;
				if (color.FontWeight != null)
					state.Weight = color.FontWeight;
			}
		}

 private void ApplyColorToElement(VisualLineElement element, HighlightingColor color)
 {
   if (color.Foreground != null)
   {
     Brush brush = color.Foreground.GetBrush(base.CurrentContext);
     if (brush != null)
     {
       element.TextRunProperties.SetForegroundBrush(brush);
     }
   }
   if (color.Background != null)
   {
     Brush brush2 = color.Background.GetBrush(base.CurrentContext);
     if (brush2 != null)
     {
       element.TextRunProperties.SetBackgroundBrush(brush2);
     }
   }
   if (color.FontStyle.HasValue || color.FontWeight.HasValue)
   {
     Typeface typeface = element.TextRunProperties.Typeface;
     element.TextRunProperties.SetTypeface(new Typeface(typeface.FontFamily, color.FontStyle ?? typeface.Style, color.FontWeight ?? typeface.Weight, typeface.Stretch));
   }
 }

		/// <summary>
		/// Applies the HighlightingColor to the specified range of text.
		/// If the color specifies <c>null</c> for some properties, existing highlighting is preserved.
		/// </summary>
		public void ApplyHighlighting(int offset, int length, HighlightingColor color)
		{
			if (color == null || color.IsEmptyForMerge) {
				// Optimization: don't split the HighlightingState when we're not changing
				// any property. For example, the "Punctuation" color in C# is
				// empty by default.
				return;
			}
			int startIndex = GetIndexForOffset(offset);
			int endIndex = GetIndexForOffset(offset + length);
			for (int i = startIndex; i < endIndex; i++) {
				stateChanges[i].MergeWith(color);
			}
		}

		/// <summary>
		/// Appends another RichTextModel after this one.
		/// </summary>
		internal void Append(int offset, int[] newOffsets, HighlightingColor[] newColors)
		{
			Debug.Assert(newOffsets.Length == newColors.Length);
			Debug.Assert(newOffsets[0] == 0);
			// remove everything before offset:
			while (stateChangeOffsets.Count > 0 && stateChangeOffsets.Last() <= offset) {
				stateChangeOffsets.RemoveAt(stateChangeOffsets.Count - 1);
				stateChanges.RemoveAt(stateChanges.Count - 1);
			}
			// Append the new segments
			for (int i = 0; i < newOffsets.Length; i++) {
				stateChangeOffsets.Add(offset + newOffsets[i]);
				stateChanges.Add(newColors[i]);
			}
		}

 internal static void ApplyColorToElement(VisualLineElement element, HighlightingColor color, ITextRunConstructionContext context)
 {
     if (color.Foreground != null) {
         Brush b = color.Foreground.GetBrush(context);
         if (b != null)
             element.TextRunProperties.SetForegroundBrush(b);
     }
     if (color.Background != null) {
         Brush b = color.Background.GetBrush(context);
         if (b != null)
             element.BackgroundBrush = b;
     }
     if (color.FontStyle != null || color.FontWeight != null) {
         Typeface tf = element.TextRunProperties.Typeface;
         element.TextRunProperties.SetTypeface(new Typeface(
             tf.FontFamily,
             color.FontStyle ?? tf.Style,
             color.FontWeight ?? tf.Weight,
             tf.Stretch
         ));
     }
     if(color.Underline ?? false)
        element.TextRunProperties.SetTextDecorations(TextDecorations.Underline);
 }

 /// <summary>
 /// Gets whether the color is empty (has no effect on a VisualLineTextElement).
 /// For example, the C# "Punctuation" is an empty color.
 /// </summary>
 internal static bool IsEmptyColor(HighlightingColor color)
 {
     if (color == null)
         return true;
     return color.Background == null && color.Foreground == null
         && color.FontStyle == null && color.FontWeight == null
         && color.Underline == null;
 }

		internal static HighlightingColor CustomizeColor(HighlightingColor color, IEnumerable<CustomizedHighlightingColor> customizations)
		{
			if (color == null || color.Name == null)
				return color;
			return CustomizeColor(color.Name, customizations) ?? color;
		}

        /// <summary>
        /// Creates a new CodeLanguage Implementation for AHK v 1.1
        /// </summary>
        public CodeLanguageAHKv1()
            : base("ahk-v1.1")
        {
            Name = "AHK v 1.1";

            SELFREF_CAN_BE_OMITTED = false;
            SUPPORTS_STARTUP_CODEDOCUMENT = true;

            if(File.Exists(_settingsFilePath)){
                _settings = SerializerHelper.DeserializeObjectFromFile<AHKSettings>(_settingsFilePath);
                _settings.SettingsSerialisationPath = _settingsFilePath;
            }else{
                // load default settings
                _settings = new AHKSettings(_settingsFilePath);
                _settings.Save();
            }

            var viewmodelMapping = ServiceLocator.Instance.Resolve<IWorkBenchService>().MappingService;

            viewmodelMapping.RegisterMapping(typeof(CodeLanguageSettingsViewModel), typeof(CodeLanguageSettingsView));

            #region Define Language Syntax
            // todo
            // those data is actually thougt to be read out of confic files
            //

            this.LanguageKeywords.AddRange(new CodeKeyWord[]
                {
                    new CodeKeyWord("if"), new CodeKeyWord("else"),
                    new CodeKeyWord("class"), new CodeKeyWord("new"), new CodeKeyWord("this"),new CodeKeyWord("base"), new CodeKeyWord("extends"),
                    new CodeKeyWord("return"), new CodeKeyWord("break"), new CodeKeyWord("continue"),
                    new CodeKeyWord("global"), new CodeKeyWord("static"), new CodeKeyWord("local"), new CodeKeyWord("byref"),
                     new CodeKeyWord("GoTo"), new CodeKeyWord("GoSub"),
                    new CodeKeyWord("loop"), new CodeKeyWord("for"), new CodeKeyWord("while"), new CodeKeyWord("in")
                });

            this.LanguageDirectives.AddRange(CodeLanguageAHKBuildinMethods.GetDirectives());

            var buildins = CodeLanguageAHKBuildinMethods.ReadMembers();
            BuildInMembers.AddRange(buildins);

            #endregion

            #region Load Syntax Definition of AHK

            IHighlightingDefinition customHighlighting;

            Brush b = new SolidColorBrush(Colors.GreenYellow);
            var greenYellowBrush = new HighlightingBrushStaticColor(b);
            var orangeBrush = new HighlightingBrushStaticColor(new SolidColorBrush(Colors.Orange));

            var sr = new StreamReader(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Syntax\\Autohotkey.xshd"));
            using(var reader = new XmlTextReader(sr)) {
                customHighlighting = ICSharpCode.AvalonEdit.Highlighting.Xshd.
                    HighlightingLoader.Load(reader, HighlightingManager.Instance);
            }

            var commandColor = new HighlightingColor()
                {
                    Foreground = orangeBrush,
                    FontWeight = FontWeights.Bold
                };
            var directiveColor = new HighlightingColor()
                {
                    Foreground = greenYellowBrush
                };

            string regexstr = "";
            foreach(var m in buildins) {
                var command = m as CodeMemberMethodExAHK;
                if(command != null && command.IsTraditionalCommand && !command.IsFlowCommand) {
                    //regexstr += command.Name.ToLowerInvariant() + "|";
                    // Add custom but static highligning rule
                    customHighlighting.MainRuleSet.Rules.Add(new HighlightingRule()
                    {
                        Color = commandColor,
                        Regex = GetRegexForCommand(command.Name.ToLowerInvariant())
                    });
                }
            }

            HighlightingManager.Instance.RegisterHighlighting("ahk-v1.1", new string[] { ".ahk" }, customHighlighting);

            #endregion

            _emptyTemplate = new ProjectTemplateEmpty(this);
            _templates = new ProjectTemplate[] { _emptyTemplate, new ProjectTemplateDemo(this) };
        }

		/// <inheritdoc/>
		public override void BeginSpan(HighlightingColor highlightingColor)
		{
			WriteIndentationAndSpace();
			if (options.ColorNeedsSpanForStyling(highlightingColor)) {
				htmlWriter.Write("<span");
				options.WriteStyleAttributeForColor(htmlWriter, highlightingColor);
				htmlWriter.Write('>');
				endTagStack.Push("</span>");
			} else {
				endTagStack.Push(null);
			}
		}