using System;

using System.Collections.Generic;

using System.Text;

using System.Drawing;

using System.Windows.Forms;

using System.Reflection;

using System.ComponentModel;

namespace Aga.Controls.Tree.NodeControls

{

	public abstract class BaseTextControl : EditableControl

	{

		private TextFormatFlags _baseFormatFlags;

        private TextFormatFlags _formatFlags;

        private Pen _focusPen;

		private StringFormat _format;

		#region Properties

		private Font _font = null;

		public Font Font

		{

			get

			{

				if (_font == null)

					return Control.DefaultFont;

				else

					return _font;

			}

			set

			{

				if (value == Control.DefaultFont)

					_font = null;

				else

					_font = value;

			}

		}

		protected bool ShouldSerializeFont()

		{

			return (_font != null);

		}

		private HorizontalAlignment _textAlign = HorizontalAlignment.Left;

		[DefaultValue(HorizontalAlignment.Left)]

		public HorizontalAlignment TextAlign

		{

			get { return _textAlign; }

			set 

			{ 

				_textAlign = value;

				SetFormatFlags();

			}

		}

		private StringTrimming _trimming = StringTrimming.None;

		[DefaultValue(StringTrimming.None)]

		public StringTrimming Trimming

		{

			get { return _trimming; }

			set 

			{ 

				_trimming = value;

				SetFormatFlags();

			}

		}

		private bool _displayHiddenContentInToolTip = true;

		[DefaultValue(true)]

		public bool DisplayHiddenContentInToolTip

		{

			get { return _displayHiddenContentInToolTip; }

			set { _displayHiddenContentInToolTip = value; }

		}

		private bool _useCompatibleTextRendering = false;

		[DefaultValue(false)]

		public bool UseCompatibleTextRendering

		{

			get { return _useCompatibleTextRendering; }

			set { _useCompatibleTextRendering = value; }

		}

		[DefaultValue(false)]

		public bool TrimMultiLine

		{

			get;

			set;

		}

		#endregion

		protected BaseTextControl()

		{

			IncrementalSearchEnabled = true;

			_focusPen = new Pen(Color.Black);

			_focusPen.DashStyle = System.Drawing.Drawing2D.DashStyle.Dot;

			_format = new StringFormat(StringFormatFlags.LineLimit | StringFormatFlags.NoClip | StringFormatFlags.FitBlackBox | StringFormatFlags.MeasureTrailingSpaces);

			_baseFormatFlags = TextFormatFlags.PreserveGraphicsClipping |

						   TextFormatFlags.PreserveGraphicsTranslateTransform;

			SetFormatFlags();

			LeftMargin = 3;

		}

		private void SetFormatFlags()

		{

			_format.Alignment = TextHelper.TranslateAligment(TextAlign);

			_format.Trimming = Trimming;

			_formatFlags = _baseFormatFlags | TextHelper.TranslateAligmentToFlag(TextAlign)

				| TextHelper.TranslateTrimmingToFlag(Trimming);

		}

		public override Size MeasureSize(TreeNodeAdv node, DrawContext context)

		{

			return GetLabelSize(node, context);

		}

		protected Size GetLabelSize(TreeNodeAdv node, DrawContext context)

		{

			return GetLabelSize(node, context, GetLabel(node));

		}

		protected Size GetLabelSize(TreeNodeAdv node, DrawContext context, string label)

		{

			PerformanceAnalyzer.Start("GetLabelSize");

			CheckThread();

			Font font = GetDrawingFont(node, context, label);

			Size s = Size.Empty;

			if (UseCompatibleTextRendering)

				s = TextRenderer.MeasureText(label, font);

			else

			{

				SizeF sf = context.Graphics.MeasureString(label, font);

				s = new Size((int)Math.Ceiling(sf.Width), (int)Math.Ceiling(sf.Height));

			}

			PerformanceAnalyzer.Finish("GetLabelSize");

			if (!s.IsEmpty)

				return s;

			else

				return new Size(10, Font.Height);

		}

		protected Font GetDrawingFont(TreeNodeAdv node, DrawContext context, string label)

		{

			Font font = context.Font;

			if (DrawTextMustBeFired(node))

			{

				DrawEventArgs args = new DrawEventArgs(node, this, context, label);

				args.Font = context.Font;

				OnDrawText(args);

				font = args.Font;

			}

			return font;

		}

		protected void SetEditControlProperties(Control control, TreeNodeAdv node)

		{

			string label = GetLabel(node);

			DrawContext context = new DrawContext();

			context.Font = control.Font;

			control.Font = GetDrawingFont(node, context, label);

		}

		public override void Draw(TreeNodeAdv node, DrawContext context)

		{

			if (context.CurrentEditorOwner == this && node == Parent.CurrentNode)

				return;

			PerformanceAnalyzer.Start("BaseTextControl.Draw");

			string label = GetLabel(node);

			Rectangle bounds = GetBounds(node, context);

			Rectangle focusRect = new Rectangle(bounds.X, context.Bounds.Y,	

				bounds.Width, context.Bounds.Height);

			Brush backgroundBrush;

			Color textColor;

			Font font;

			CreateBrushes(node, context, label, out backgroundBrush, out textColor, out font, ref label);

			if (backgroundBrush != null)

				context.Graphics.FillRectangle(backgroundBrush, focusRect);

			if (context.DrawFocus)

			{

				focusRect.Width--;

				focusRect.Height--;

				if (context.DrawSelection == DrawSelectionMode.None)

					_focusPen.Color = SystemColors.ControlText;

				else

					_focusPen.Color = SystemColors.InactiveCaption;

				context.Graphics.DrawRectangle(_focusPen, focusRect);

			}

			PerformanceAnalyzer.Start("BaseTextControl.DrawText");

			if (UseCompatibleTextRendering)

				TextRenderer.DrawText(context.Graphics, label, font, bounds, textColor, _formatFlags);

			else

				context.Graphics.DrawString(label, font, GetFrush(textColor), bounds, _format);

			PerformanceAnalyzer.Finish("BaseTextControl.DrawText");

			PerformanceAnalyzer.Finish("BaseTextControl.Draw");

		}

		private static Dictionary<Color, Brush> _brushes = new Dictionary<Color,Brush>();

		private static Brush GetFrush(Color color)

		{

			Brush br;

			if (_brushes.ContainsKey(color))

				br = _brushes[color];

			else

			{

				br = new SolidBrush(color);

				_brushes.Add(color, br);

			}

			return br;

		}

		private void CreateBrushes(TreeNodeAdv node, DrawContext context, string text, out Brush backgroundBrush, out Color textColor, out Font font, ref string label)

		{

			textColor = SystemColors.ControlText;

			backgroundBrush = null;

			font = context.Font;

			if (context.DrawSelection == DrawSelectionMode.Active)

			{

				textColor = SystemColors.HighlightText;

                backgroundBrush = SystemBrushes.Highlight;

			}

			else if (context.DrawSelection == DrawSelectionMode.Inactive)

			{

				textColor = SystemColors.ControlText;

                backgroundBrush = SystemBrushes.InactiveBorder;

			}

			else if (context.DrawSelection == DrawSelectionMode.FullRowSelect)

				textColor = SystemColors.ControlText;

			if (!context.Enabled)

				textColor = SystemColors.GrayText;

			if (DrawTextMustBeFired(node))

			{

				DrawEventArgs args = new DrawEventArgs(node, this, context, text);

				args.Text = label;

				args.TextColor = textColor;

				args.BackgroundBrush = backgroundBrush;

				args.Font = font;

				OnDrawText(args);

				textColor = args.TextColor;

				backgroundBrush = args.BackgroundBrush;

				font = args.Font;

				label = args.Text;

			}

		}

		public string GetLabel(TreeNodeAdv node)

		{

			if (node != null && node.Tag != null)

			{

				object obj = GetValue(node);

				if (obj != null)

					return FormatLabel(obj);

			}

			return string.Empty;

		}

		protected virtual string FormatLabel(object obj)

		{

			var res = obj.ToString();

			if (TrimMultiLine && res != null)

			{

				string[] parts = res.Split('\n');

				if (parts.Length > 1)

					return parts[0] + "...";

			}

			return res;

		}

		public void SetLabel(TreeNodeAdv node, string value)

		{

			SetValue(node, value);

		}

		protected override void Dispose(bool disposing)

		{

			base.Dispose(disposing);

			if (disposing)

			{

				_focusPen.Dispose();

				_format.Dispose();

			}

		}

		/// <summary>

		/// Fires when control is going to draw a text. Can be used to change text or back color

		/// </summary>

		public event EventHandler<DrawEventArgs> DrawText;

		protected virtual void OnDrawText(DrawEventArgs args)

		{

			TreeViewAdv tree = args.Node.Tree;

			if (tree != null)

				tree.FireDrawControl(args);

			if (DrawText != null)

				DrawText(this, args);

		}

		protected virtual bool DrawTextMustBeFired(TreeNodeAdv node)

		{

			return DrawText != null || (node.Tree != null && node.Tree.DrawControlMustBeFired());

		}

	}

}