using System;

using System.Collections.Generic;

using System.Text;

using System.Windows.Forms;

using System.Drawing;

using Aga.Controls.Tree.NodeControls;

using System.Drawing.Imaging;

using System.Threading;

namespace Aga.Controls.Tree

{

	public partial class TreeViewAdv

	{

		#region Keys

		protected override bool IsInputChar(char charCode)

		{

			return true;

		}

		protected override bool IsInputKey(Keys keyData)

		{

			if (((keyData & Keys.Up) == Keys.Up)

				|| ((keyData & Keys.Down) == Keys.Down)

				|| ((keyData & Keys.Left) == Keys.Left)

				|| ((keyData & Keys.Right) == Keys.Right))

				return true;

			else

				return base.IsInputKey(keyData);

		}

		internal void ChangeInput()

		{

			if ((ModifierKeys & Keys.Shift) == Keys.Shift)

			{

				if (!(Input is InputWithShift))

					Input = new InputWithShift(this);

			}

			else if ((ModifierKeys & Keys.Control) == Keys.Control)

			{

				if (!(Input is InputWithControl))

					Input = new InputWithControl(this);

			}

			else

			{

				if (!(Input.GetType() == typeof(NormalInputState)))

					Input = new NormalInputState(this);

			}

		}

		protected override void OnKeyDown(KeyEventArgs e)

		{

			base.OnKeyDown(e);

			if (!e.Handled)

			{

				if (e.KeyCode == Keys.ShiftKey || e.KeyCode == Keys.ControlKey)

					ChangeInput();

				Input.KeyDown(e);

				if (!e.Handled)

				{

					foreach (NodeControlInfo item in GetNodeControls(CurrentNode))

					{

						item.Control.KeyDown(e);

						if (e.Handled)

							break;

					}

				}

			}

		}

		protected override void OnKeyUp(KeyEventArgs e)

		{

			base.OnKeyUp(e);

			if (!e.Handled)

			{

				if (e.KeyCode == Keys.ShiftKey || e.KeyCode == Keys.ControlKey)

					ChangeInput();

				if (!e.Handled)

				{

					foreach (NodeControlInfo item in GetNodeControls(CurrentNode))

					{

						item.Control.KeyUp(e);

						if (e.Handled)

							return;

					}

				}

			}

		}

		protected override void OnKeyPress(KeyPressEventArgs e)

		{

			base.OnKeyPress(e);

			if (!e.Handled)

				_search.Search(e.KeyChar);

		}

		#endregion

		#region Mouse

		private TreeNodeAdvMouseEventArgs CreateMouseArgs(MouseEventArgs e)

		{

			TreeNodeAdvMouseEventArgs args = new TreeNodeAdvMouseEventArgs(e);

			args.ViewLocation = new Point(e.X + OffsetX,

				e.Y + _rowLayout.GetRowBounds(FirstVisibleRow).Y - ColumnHeaderHeight);

			args.ModifierKeys = ModifierKeys;

			args.Node = GetNodeAt(e.Location);

			NodeControlInfo info = GetNodeControlInfoAt(args.Node, e.Location);

			args.ControlBounds = info.Bounds;

			args.Control = info.Control;

			return args;

		}

		protected override void OnMouseWheel(MouseEventArgs e)

		{

			_search.EndSearch();

			if (SystemInformation.MouseWheelScrollLines > 0)

			{

				int lines = e.Delta / 120 * SystemInformation.MouseWheelScrollLines;

				int newValue = _vScrollBar.Value - lines;

				newValue = Math.Min(_vScrollBar.Maximum - _vScrollBar.LargeChange + 1, newValue);

				newValue = Math.Min(_vScrollBar.Maximum, newValue);

				_vScrollBar.Value = Math.Max(_vScrollBar.Minimum, newValue);

			}

			base.OnMouseWheel(e);

		}

		protected override void OnMouseDown(MouseEventArgs e)

		{

			if (CurrentEditorOwner != null)

			{

				CurrentEditorOwner.EndEdit(true);

				return;

			}

			if (!Focused)

				Focus();

			_search.EndSearch();

			if (e.Button == MouseButtons.Left)

			{

				TreeColumn c;

				c = GetColumnDividerAt(e.Location);

				if (c != null)

				{

					Input = new ResizeColumnState(this, c, e.Location);

					return;

				}

				c = GetColumnAt(e.Location);

				if (c != null)

				{

					Input = new ClickColumnState(this, c, e.Location);

					UpdateView();

					return;

				}

			}

			ChangeInput();

			TreeNodeAdvMouseEventArgs args = CreateMouseArgs(e);

			if (args.Node != null && args.Control != null)

				args.Control.MouseDown(args);

			if (!args.Handled)

				Input.MouseDown(args);

			base.OnMouseDown(e);

		}

		protected override void OnMouseClick(MouseEventArgs e)

		{

			//TODO: Disable when click on plusminus icon

			TreeNodeAdvMouseEventArgs args = CreateMouseArgs(e);

			if (args.Node != null)

				OnNodeMouseClick(args);

			base.OnMouseClick(e);

		}

		protected override void OnMouseDoubleClick(MouseEventArgs e)

		{

			TreeNodeAdvMouseEventArgs args = CreateMouseArgs(e);

			if (args.Node != null && args.Control != null)

				args.Control.MouseDoubleClick(args);

			if (!args.Handled)

			{

				if (args.Node != null)

					OnNodeMouseDoubleClick(args);

				else

					Input.MouseDoubleClick(args);

				if (!args.Handled)

				{

					if (args.Node != null && args.Button == MouseButtons.Left)

						args.Node.IsExpanded = !args.Node.IsExpanded;

				}

			}

			base.OnMouseDoubleClick(e);

		}

		protected override void OnMouseUp(MouseEventArgs e)

		{

			TreeNodeAdvMouseEventArgs args = CreateMouseArgs(e);

			if (Input is ResizeColumnState)

				Input.MouseUp(args);

			else

			{

				if (args.Node != null && args.Control != null)

					args.Control.MouseUp(args);

				if (!args.Handled)

					Input.MouseUp(args);

				base.OnMouseUp(e);

			}

		}

		protected override void OnMouseMove(MouseEventArgs e)

		{

			if (Input.MouseMove(e))

				return;

			base.OnMouseMove(e);

			SetCursor(e);

			UpdateToolTip(e);

			if (ItemDragMode && Dist(e.Location, ItemDragStart) > ItemDragSensivity

				&& CurrentNode != null && CurrentNode.IsSelected)

			{

				ItemDragMode = false;

				_toolTip.Active = false;

				OnItemDrag(e.Button, Selection.ToArray());

			}

		}

		protected override void OnMouseLeave(EventArgs e)

		{

			_hotColumn = null;

			UpdateHeaders();

			base.OnMouseLeave(e);

		}

		private void SetCursor(MouseEventArgs e)

		{

			TreeColumn col;

			col = GetColumnDividerAt(e.Location);

			if (col == null)

				_innerCursor = null;

			else

			{

				if (col.Width == 0)

					_innerCursor = ResourceHelper.DVSplitCursor;

				else

					_innerCursor = Cursors.VSplit;

			}

			col = GetColumnAt(e.Location);

			if (col != _hotColumn)

			{

				_hotColumn = col;

				UpdateHeaders();

			}

		}

		internal TreeColumn GetColumnAt(Point p)

		{

			if (p.Y > ColumnHeaderHeight)

				return null;

			int x = -OffsetX;

			foreach (TreeColumn col in Columns)

			{

				if (col.IsVisible)

				{

					Rectangle rect = new Rectangle(x, 0, col.Width, ColumnHeaderHeight);

					x += col.Width;

					if (rect.Contains(p))

						return col;

				}

			}

			return null;

		}

		internal int GetColumnX(TreeColumn column)

		{

			int x = -OffsetX;

			foreach (TreeColumn col in Columns)

			{

				if (col.IsVisible)

				{

					if (column == col)

						return x;

					else

						x += col.Width;

				}

			}

			return x;

		}

		internal TreeColumn GetColumnDividerAt(Point p)

		{

			if (p.Y > ColumnHeaderHeight)

				return null;

			int x = -OffsetX;

			TreeColumn prevCol = null;

			Rectangle left, right;

			foreach (TreeColumn col in Columns)

			{

				if (col.IsVisible)

				{

					if (col.Width > 0)

					{

						left = new Rectangle(x, 0, DividerWidth / 2, ColumnHeaderHeight);

						right = new Rectangle(x + col.Width - (DividerWidth / 2), 0, DividerWidth / 2, ColumnHeaderHeight);

						if (left.Contains(p) && prevCol != null)

							return prevCol;

						else if (right.Contains(p))

							return col;

					}

					prevCol = col;

					x += col.Width;

				}

			}

			left = new Rectangle(x, 0, DividerWidth / 2, ColumnHeaderHeight);

			if (left.Contains(p) && prevCol != null)

				return prevCol;

			return null;

		}

		TreeColumn _tooltipColumn;

		private void UpdateToolTip(MouseEventArgs e)

		{

			TreeColumn col = GetColumnAt(e.Location);

			if (col != null)

			{

				if (col != _tooltipColumn)

					SetTooltip(col.TooltipText);

			}

			else

				DisplayNodesTooltip(e);

			_tooltipColumn = col;

		}

		TreeNodeAdv _hotNode;

		NodeControl _hotControl;

		private void DisplayNodesTooltip(MouseEventArgs e)

		{

			if (ShowNodeToolTips)

			{

				TreeNodeAdvMouseEventArgs args = CreateMouseArgs(e);

				if (args.Node != null && args.Control != null)

				{

					if (args.Node != _hotNode || args.Control != _hotControl)

						SetTooltip(GetNodeToolTip(args));

				}

				else

					_toolTip.SetToolTip(this, null);

				_hotControl = args.Control;

				_hotNode = args.Node;

			}

			else

				_toolTip.SetToolTip(this, null);

		}

		private void SetTooltip(string text)

		{

			if (!String.IsNullOrEmpty(text))

			{

				_toolTip.Active = false;

				_toolTip.SetToolTip(this, text);

				_toolTip.Active = true;

			}

			else

				_toolTip.SetToolTip(this, null);

		}

		private string GetNodeToolTip(TreeNodeAdvMouseEventArgs args)

		{

			string msg = args.Control.GetToolTip(args.Node);

			BaseTextControl btc = args.Control as BaseTextControl;

			if (btc != null && btc.DisplayHiddenContentInToolTip && String.IsNullOrEmpty(msg))

			{

				Size ms = btc.GetActualSize(args.Node, _measureContext);

				if (ms.Width > args.ControlBounds.Size.Width || ms.Height > args.ControlBounds.Size.Height

					|| args.ControlBounds.Right - OffsetX > DisplayRectangle.Width)

					msg = btc.GetLabel(args.Node);

			}

			if (String.IsNullOrEmpty(msg) && DefaultToolTipProvider != null)

				msg = DefaultToolTipProvider.GetToolTip(args.Node, args.Control);

			return msg;

		}

		#endregion

		#region DragDrop

		private bool _dragAutoScrollFlag = false;

		private Bitmap _dragBitmap = null;

		private System.Threading.Timer _dragTimer;

		private void StartDragTimer()

		{

			if (_dragTimer == null)

				_dragTimer = new System.Threading.Timer(new TimerCallback(DragTimerTick), null, 0, 100);

		}

		private void StopDragTimer()

		{

			if (_dragTimer != null)

			{

				_dragTimer.Dispose();

				_dragTimer = null;

			}

		}

		private void SetDropPosition(Point pt)

		{

			TreeNodeAdv node = GetNodeAt(pt);

			OnDropNodeValidating(pt, ref node);

			_dropPosition.Node = node;

			if (node != null)

			{

				Rectangle first = _rowLayout.GetRowBounds(FirstVisibleRow);

				Rectangle bounds = _rowLayout.GetRowBounds(node.Row);

				float pos = (pt.Y + first.Y - ColumnHeaderHeight - bounds.Y) / (float)bounds.Height;

				if (pos < TopEdgeSensivity)

					_dropPosition.Position = NodePosition.Before;

				else if (pos > (1 - BottomEdgeSensivity))

					_dropPosition.Position = NodePosition.After;

				else

					_dropPosition.Position = NodePosition.Inside;

			}

		}

		private void DragTimerTick(object state)

		{

			_dragAutoScrollFlag = true;

		}

		private void DragAutoScroll()

		{

			_dragAutoScrollFlag = false;

			Point pt = PointToClient(MousePosition);

			if (pt.Y < 20 && _vScrollBar.Value > 0)

				_vScrollBar.Value--;

			else if (pt.Y > Height - 20 && _vScrollBar.Value <= _vScrollBar.Maximum - _vScrollBar.LargeChange)

				_vScrollBar.Value++;

		}

		public void DoDragDropSelectedNodes(DragDropEffects allowedEffects)

		{

			if (SelectedNodes.Count > 0)

			{

				TreeNodeAdv[] nodes = new TreeNodeAdv[SelectedNodes.Count];

				SelectedNodes.CopyTo(nodes, 0);

				DoDragDrop(nodes, allowedEffects);

			}

		}

		private void CreateDragBitmap(IDataObject data)

		{

			if (UseColumns || !DisplayDraggingNodes)

				return;

			TreeNodeAdv[] nodes = data.GetData(typeof(TreeNodeAdv[])) as TreeNodeAdv[];

			if (nodes != null && nodes.Length > 0)

			{

				Rectangle rect = DisplayRectangle;

				Bitmap bitmap = new Bitmap(rect.Width, rect.Height);

				using (Graphics gr = Graphics.FromImage(bitmap))

				{

					gr.Clear(BackColor);

					DrawContext context = new DrawContext();

					context.Graphics = gr;

					context.Font = Font;

					context.Enabled = true;

					int y = 0;

					int maxWidth = 0;

					foreach (TreeNodeAdv node in nodes)

					{

						if (node.Tree == this)

						{

							int x = 0;

							int height = _rowLayout.GetRowBounds(node.Row).Height;

							foreach (NodeControl c in NodeControls)

							{

								Size s = c.GetActualSize(node, context);

								if (!s.IsEmpty)

								{

									int width = s.Width;

									rect = new Rectangle(x, y, width, height);

									x += (width + 1);

									context.Bounds = rect;

									c.Draw(node, context);

								}

							}

							y += height;

							maxWidth = Math.Max(maxWidth, x);

						}

					}

					if (maxWidth > 0 && y > 0)

					{

						_dragBitmap = new Bitmap(maxWidth, y, PixelFormat.Format32bppArgb);

						using (Graphics tgr = Graphics.FromImage(_dragBitmap))

							tgr.DrawImage(bitmap, Point.Empty);

						BitmapHelper.SetAlphaChanelValue(_dragBitmap, 150);

					}

					else

						_dragBitmap = null;

				}

			}

		}

		protected override void OnDragOver(DragEventArgs drgevent)

		{

			ItemDragMode = false;

			Point pt = PointToClient(new Point(drgevent.X, drgevent.Y));

			if (_dragAutoScrollFlag)

				DragAutoScroll();

			SetDropPosition(pt);

			UpdateView();

			base.OnDragOver(drgevent);

		}

		protected override void OnDragEnter(DragEventArgs drgevent)

		{

			_search.EndSearch();

			DragMode = true;

			CreateDragBitmap(drgevent.Data);

			base.OnDragEnter(drgevent);

		}

		protected override void OnDragLeave(EventArgs e)

		{

			DragMode = false;

			UpdateView();

			base.OnDragLeave(e);

		}

		protected override void OnDragDrop(DragEventArgs drgevent)

		{

			DragMode = false;

			UpdateView();

			base.OnDragDrop(drgevent);

		}

		#endregion

	}

}