using System;

using System.Collections.Generic;

using System.Text;

using System.Drawing;

using System.Windows.Forms;

using System.Reflection;

using System.ComponentModel;

using System.Drawing.Design;

namespace Aga.Controls.Tree.NodeControls

{

	public class NodeComboBox : BaseTextControl

	{

		#region Properties

		private int _editorWidth = 100;

		[DefaultValue(100)]

		public int EditorWidth

		{

			get { return _editorWidth; }

			set { _editorWidth = value; }

		}

		private int _editorHeight = 100;

		[DefaultValue(100)]

		public int EditorHeight

		{

			get { return _editorHeight; }

			set { _editorHeight = value; }

		}

		private List<object> _dropDownItems;

		[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1002:DoNotExposeGenericLists")]

		[Editor(typeof(StringCollectionEditor), typeof(UITypeEditor)), DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]

		public List<object> DropDownItems

		{

			get { return _dropDownItems; }

		}

		#endregion

		public event EventHandler<EditEventArgs> CreatingEditor;

		public NodeComboBox()

		{

			_dropDownItems = new List<object>();

		}

		protected override Size CalculateEditorSize(EditorContext context)

		{

			if (Parent.UseColumns)

			{

				if (context.Editor is CheckedListBox)

					return new Size(context.Bounds.Size.Width, EditorHeight);

				else

					return context.Bounds.Size;

			}

			else

			{

				if (context.Editor is CheckedListBox)

					return new Size(EditorWidth, EditorHeight);

				else

					return new Size(EditorWidth, context.Bounds.Height);

			}

		}

		protected override Control CreateEditor(TreeNodeAdv node)

		{

			Control c;

			object value = GetValue(node);

			if (IsCheckedListBoxRequired(node))

				c = CreateCheckedListBox(node);

			else

				c = CreateCombo(node);

			OnCreatingEditor(new EditEventArgs(node, c));

			return c;

		}

		protected override void DisposeEditor(Control editor)

		{

		}

		protected virtual void OnCreatingEditor(EditEventArgs args)

		{

			if (CreatingEditor != null)

				CreatingEditor(this, args);

		}

		protected virtual bool IsCheckedListBoxRequired(TreeNodeAdv node)

		{

			object value = GetValue(node);

			if (value != null)

			{

				Type t = value.GetType();

				object[] arr = t.GetCustomAttributes(typeof(FlagsAttribute), false);

				return (t.IsEnum && arr.Length == 1);

			}

			return false;

		}

		private Control CreateCombo(TreeNodeAdv node)

		{

			ComboBox comboBox = new ComboBox();

			if (DropDownItems != null)

				comboBox.Items.AddRange(DropDownItems.ToArray());

			comboBox.SelectedItem = GetValue(node);

			comboBox.DropDownStyle = ComboBoxStyle.DropDownList;

			comboBox.DropDownClosed += new EventHandler(EditorDropDownClosed);

			SetEditControlProperties(comboBox, node);

			return comboBox;

		}

		private Control CreateCheckedListBox(TreeNodeAdv node)

		{

			CheckedListBox listBox = new CheckedListBox();

			listBox.CheckOnClick = true;

			object value = GetValue(node);

			Type enumType = GetEnumType(node);

			foreach (object obj in Enum.GetValues(enumType))

			{

				object[] attributes = enumType.GetField(obj.ToString()).GetCustomAttributes(typeof(BrowsableAttribute), false);

				if (attributes.Length == 0 || ((BrowsableAttribute)attributes[0]).Browsable)

					listBox.Items.Add(obj, IsContain(value, obj));

			}

			SetEditControlProperties(listBox, node);

			if (CreatingEditor != null)

				CreatingEditor(this, new EditEventArgs(node, listBox));

			return listBox;

		}

		protected virtual Type GetEnumType(TreeNodeAdv node)

		{

			object value = GetValue(node);

			return value.GetType();

		}

		private bool IsContain(object value, object enumElement)

		{

			if (value == null || enumElement == null)

				return false;

			if (value.GetType().IsEnum)

			{

				int i1 = (int)value;

				int i2 = (int)enumElement;

				return (i1 & i2) == i2;

			}

			else

			{

				var arr = value as object[];

				foreach (object obj in arr)

					if ((int)obj == (int)enumElement)

						return true;

				return false;

			}

		}

		protected override string FormatLabel(object obj)

		{

			var arr = obj as object[];

			if (arr != null)

			{

				StringBuilder sb = new StringBuilder();

				foreach (object t in arr)

				{

					if (sb.Length > 0)

						sb.Append(", ");

					sb.Append(t);

				}

				return sb.ToString();

			}

			else

				return base.FormatLabel(obj);

		}

		void EditorDropDownClosed(object sender, EventArgs e)

		{

			EndEdit(true);

		}

		public override void UpdateEditor(Control control)

		{

			if (control is ComboBox)

				(control as ComboBox).DroppedDown = true;

		}

		protected override void DoApplyChanges(TreeNodeAdv node, Control editor)

		{

			var combo = editor as ComboBox;

			if (combo != null)

			{

				if (combo.DropDownStyle == ComboBoxStyle.DropDown)

					SetValue(node, combo.Text);

				else

					SetValue(node, combo.SelectedItem);

			}

			else

			{

				var listBox = editor as CheckedListBox;

				Type type = GetEnumType(node);

				if (IsFlags(type))

				{

					int res = 0;

					foreach (object obj in listBox.CheckedItems)

						res |= (int)obj;

					object val = Enum.ToObject(type, res);

					SetValue(node, val);

				}

				else

				{

					List<object> list = new List<object>();

					foreach (object obj in listBox.CheckedItems)

						list.Add(obj);

					SetValue(node, list.ToArray());

				}

			}

		}

		private bool IsFlags(Type type)

		{

			object[] atr = type.GetCustomAttributes(typeof(FlagsAttribute), false);

			return atr.Length == 1;

		}

		public override void MouseUp(TreeNodeAdvMouseEventArgs args)

		{

			if (args.Node != null && args.Node.IsSelected) //Workaround of specific ComboBox control behavior

				base.MouseUp(args);

		}

	}

}