using System;
using System.Collections.Generic;
using System.Linq;
using System.Windows.Forms;
using Common;
using Config.Entities;
using Results.Resources;

namespace Results.Forms
{
    public partial class ManualEntryConfigCtrl : UserControl
    {
        /// <summary>
        /// ListViewEx columns
        /// </summary>
        enum Column
        {
            Item,
            Caption,
            Units,
			Count,
        }

        Control[] editors;		/// all editors except of units
		ComboBox unitsCB;		/// units combo box

        public IList<ManualEntryItemSpec> SelectedItems;
		public bool Unlocked
		{
			set
			{
				availableTabControl.Enabled = value;
				selectedResultsListViewEx.Enabled = value;
				addButton.Enabled = value;
				removeButton.Enabled = value;
				removeAllButton.Enabled = value;
				upButton.Enabled = value;
				downButton.Enabled = value;
				unlocked = value;
			}
			get { return unlocked; }
		}
		bool unlocked;


        public ManualEntryConfigCtrl()
		{
			InitializeComponent();
		}


		void Localize()
		{
			Text = Strings.Configuration;
            availableItemsLabel.Text = Strings.Available_items;
			availableTabControl.TabPages[0].Text = Strings.Quantity;
			availableTabControl.TabPages[1].Text = Strings.Category;
			availableTabControl.TabPages[2].Text = "A...Z";

			selectedItemsLabel.Text = Strings.Selected_items;

			addButton.Text = Strings.Add;
			removeButton.Text = Strings.Remove;
			removeAllButton.Text = Strings.Remove_all;
            upButton.Text = Strings.UpBtnText;
            downButton.Text = Strings.DownBtnText;
		}

		private void ManualEntryConfigCtrl_Load(object sender, EventArgs e)
		{
			Localize();

            /// Add columns to ListViewEx
            selectedResultsListViewEx.Columns.Add(new ColumnHeader { Text = Strings.Item, Width = 120 });
            selectedResultsListViewEx.Columns.Add(new ColumnHeader { Text = Strings.Caption });
            selectedResultsListViewEx.Columns.Add(new ColumnHeader { Text = Strings.Units });

            /// Create controls used by ListViewEx to edit items
            unitsCB = new ComboBox();

            ComboBox alignmentCB = new ComboBox();
            for (Alignment a = 0; a < Alignment.Count; a++)
            {
                alignmentCB.Items.Add(a.ToDescription());
            }

            editors = new Control[]
                {
                    null,
                    new TextBox(),		/// caption
                    unitsCB,
                };
            foreach (var edi in editors)
            {
                if (edi != null)
                {
                    edi.Visible = false;
                    Controls.Add(edi);
                }
            }

            selectedResultsListViewEx.SubItemClicked += new SubItemEventHandler(selectedResultsListViewEx_SubItemClicked);
            selectedResultsListViewEx.SubItemEndEditing += new SubItemEndEditingEventHandler(selectedResultsListViewEx_SubItemEndEditing);
			
			availableByQuantityTreeView.ShowNodeToolTips = true;
			availableByCategoryTreeView.ShowNodeToolTips = true;
			availableAlphabeticTreeView.ShowNodeToolTips = true;

            RedrawAvailable();
			RedrawSelected();
		}

        void selectedResultsListViewEx_SubItemClicked(object sender, SubItemEventArgs e)
        {
			if (e.SubItem == (int)Column.Units)
			{
                Config.Quantity quantity = (e.Item.Tag as ManualEntryItemSpec).Quantity;
				unitsCB.Items.Clear();
				unitsCB.Items.Add(Config.Unit.None.ToDescription());				/// "---"
				for (Config.Unit u = (Config.Unit)1; u < Config.Unit.Count; u++)
				{
					if (Config.Units.IsQuantity(u, quantity))  unitsCB.Items.Add(u.ToDescription());
				}
				selectedResultsListViewEx.StartEditing(unitsCB, e.Item, e.SubItem);
			}
            else if ((e.SubItem > 0) && (e.SubItem < (int)Column.Count))
            {
                selectedResultsListViewEx.StartEditing(editors[e.SubItem], e.Item, e.SubItem);
            }
        }

        void selectedResultsListViewEx_SubItemEndEditing(object sender, SubItemEndEditingEventArgs e)
        {
            ListViewItem lvi = e.Item;
            ManualEntryItemSpec item = lvi.Tag as ManualEntryItemSpec;

            switch ((Column)e.SubItem)
            {
                case Column.Caption:    item.Caption = e.DisplayText;   return;
                case Column.Units:
                    for (Config.Unit u = 0; u < Config.Unit.Count; u++)
                    {
						if (u.ToDescription().Equals(unitsCB.Text))
                        {
                            item.Units = u;
                            return;     /// OK
                        }
                    }
                    break;              /// Error
	
				default:
                    return;             /// OK
            }

            e.DisplayText = e.Item.SubItems[e.SubItem].Text;
            e.Cancel = true;
            return;
        }


		/// <summary>
		/// Redraw available items (right hand side)
		/// </summary>
		void RedrawAvailable()
		{
			RedrawByQuantity(availableByQuantityTreeView);
			RedrawByCategory(availableByCategoryTreeView);
			RedrawInAlphabeticOrder(availableAlphabeticTreeView);
		}


		void RedrawInAlphabeticOrder(TreeView treeView)
		{
			treeView.Nodes.Clear();

            IList<ManualEntryItemSpec> alphabeticlList = ManualEntryItemSpec.AllItems.OrderBy(x => x.Name).ToList();
			///
			foreach (var item in alphabeticlList)
			{
				TreeNode node = new TreeNode(item.Name);
				node.Tag = item;
				node.ToolTipText = item.ToolTipText;
				treeView.Nodes.Add(node);
			}
		}


		void RedrawByQuantity(TreeView treeView)
		{
			treeView.Nodes.Clear();

			IList<Config.Quantity> quantities = new List<Config.Quantity>();
			for (Config.Quantity q = 0; q < Config.Quantity.Count; q++) quantities.Add(q);

			IList<Config.Quantity> sortedQuantities = quantities.OrderBy(x => x.ToDescription()).ToList();

			foreach (var q in sortedQuantities)
			{
				int n = 0;
                foreach (var ri in ManualEntryItemSpec.AllItems)
				{
					if (ri.Quantity == q) n++;
				}

				if (n > 0)
				{
					TreeNode[] array = new TreeNode[n];
					int i = 0;
                    foreach (var ri in ManualEntryItemSpec.AllItems)
					{
						if (ri.Quantity == q)
						{
							TreeNode node = new TreeNode(ri.Name);
							node.Tag = ri;
							node.ToolTipText = ri.ToolTipText;
							array[i++] = node;
						}
					}

					treeView.Nodes.Add(new TreeNode(q.ToDescription(), array));
				}
			}
		}


		void RedrawByCategory(TreeView treeView)
		{
			treeView.Nodes.Clear();

			IList<ItemCategory> categories = new List<ItemCategory>();
			for (ItemCategory c = 0; c < ItemCategory.Count; c++) categories.Add(c);

			IList<ItemCategory> sortedCategories = categories.OrderBy(x => x.ToDescription()).ToList();

			foreach (var c in sortedCategories)
			{
				int n = 0;
                foreach (var ri in ManualEntryItemSpec.AllItems)
				{
					if (ri.Category == c) n++;
				}

				if (n > 0)
				{
					TreeNode[] array = new TreeNode[n];
					int i = 0;
                    foreach (var ri in ManualEntryItemSpec.AllItems)
					{
						if (ri.Category == c)
						{
							TreeNode node = new TreeNode(ri.Name);
							node.Tag = ri;
							node.ToolTipText = ri.ToolTipText;
							array[i++] = node;
						}
					}

					treeView.Nodes.Add(new TreeNode(c.ToDescription(), array));
				}
			}
		}


		/// <summary>
		/// Redraw selected items (right hand side)
		/// </summary>
		void RedrawSelected()
		{
			selectedResultsListViewEx.Items.Clear();

			if (SelectedItems == null) return;

			foreach (var item in SelectedItems)
			{
                ListViewItem lvi = new ListViewItem(item.Name);     /// Item
                lvi.Tag = item;
                lvi.SubItems.Add(item.Caption);                     /// Header
                lvi.SubItems.Add(item.Units.ToDescription());		/// Units
				selectedResultsListViewEx.Items.Add(lvi);
			}
		}

        void UpdateSelectedFromView()
        {
        }


		void addButton_Click(object sender, EventArgs e)
		{
			switch (availableTabControl.SelectedIndex)
			{
				case 0:
					availableByQuantityTreeView_DoubleClick(this, null);
					break;
				case 1:
					availableByCategoryTreeView_DoubleClick(this, null);
					break;
				case 2:
					availableAlphabeticTreeView_DoubleClick(this, null);
					break;
				default:
					break;
			}
		}

		private void availableByQuantityTreeView_DoubleClick(object sender, EventArgs e)
		{
			if (availableByQuantityTreeView.SelectedNode != null &&
                availableByQuantityTreeView.SelectedNode.Tag is ManualEntryItemSpec)
			{
                AddItem(availableByQuantityTreeView.SelectedNode.Tag as ManualEntryItemSpec);
			}
		}

		private void availableByCategoryTreeView_DoubleClick(object sender, EventArgs e)
		{
			if (availableByCategoryTreeView.SelectedNode != null &&
                availableByCategoryTreeView.SelectedNode.Tag is ManualEntryItemSpec)
			{
                AddItem(availableByCategoryTreeView.SelectedNode.Tag as ManualEntryItemSpec);
			}
		}

		private void availableAlphabeticTreeView_DoubleClick(object sender, EventArgs e)
		{
			if (availableAlphabeticTreeView.SelectedNode != null &&
                availableAlphabeticTreeView.SelectedNode.Tag is ManualEntryItemSpec)
			{
                AddItem(availableAlphabeticTreeView.SelectedNode.Tag as ManualEntryItemSpec);
			}
		}

        void AddItem(ManualEntryItemSpec item)
		{
            ManualEntryItemSpec newItem = item.Clone();
			newItem.Caption = newItem.Name;
			SelectedItems.Add(newItem);
			RedrawSelected();

			/// Select the last item
			selectedResultsListViewEx.Focus();
			selectedResultsListViewEx.Items[SelectedItems.Count - 1].Selected = true;
			selectedResultsListViewEx.Items[SelectedItems.Count - 1].EnsureVisible();
		}


		private void selectedResultsListViewEx_DoubleClick(object sender, EventArgs e)
		{
			/// Double click works when just one item is selected

			if (selectedResultsListViewEx.SelectedIndices.Count == 1)
			{
				SelectedItems.RemoveAt(selectedResultsListViewEx.SelectedIndices[0]);
				RedrawAvailable();
				RedrawSelected();
			}
		}

		void removeButton_Click(object sender, EventArgs e)
		{
			/// Remove from the list (the last selected item first so that the indexes are not affected)

			for (int i = selectedResultsListViewEx.SelectedIndices.Count - 1; i >= 0; i--)
			{
				SelectedItems.RemoveAt(selectedResultsListViewEx.SelectedIndices[i]);
			}
			RedrawAvailable();
			RedrawSelected();
		}

		void removeAllButton_Click(object sender, EventArgs e)
		{
			/// Remove all items from 'Selected' list

			SelectedItems.Clear();
			RedrawAvailable();
			RedrawSelected();
		}

        //void okButton_Click(object sender, EventArgs e)
        //{
        //    DialogResult = DialogResult.OK;
        //    Close();
        //}

        private void ManualEntryConfigCtrl_KeyPress(object sender, KeyPressEventArgs e)
        {
            e.Handled = true;
        }

        private void upButton_Click(object sender, EventArgs e)
        {
            if (selectedResultsListViewEx.SelectedIndices.Count != 1) return;

            int selIdx = selectedResultsListViewEx.SelectedIndices[0];
            if (selIdx == 0)
            {
                /// Cannot move up
                selectedResultsListViewEx.Focus();
                selectedResultsListViewEx.Items[0].Selected = true;
                return;
            }

            ManualEntryItemSpec tmp = SelectedItems[selIdx - 1];
            SelectedItems[selIdx - 1] = SelectedItems[selIdx];
            SelectedItems[selIdx] = tmp;

            RedrawSelected();

            selectedResultsListViewEx.Focus();
            selectedResultsListViewEx.Items[selIdx - 1].Selected = true;
            selectedResultsListViewEx.Items[selIdx - 1].EnsureVisible();
        }

        private void downButton_Click(object sender, EventArgs e)
        {
            if (selectedResultsListViewEx.SelectedIndices.Count != 1) return;

            int selIdx = selectedResultsListViewEx.SelectedIndices[0];
            if (selIdx == SelectedItems.Count - 1)
            {
                /// Cannot move down
                selectedResultsListViewEx.Focus();
                selectedResultsListViewEx.Items[SelectedItems.Count - 1].Selected = true;
                return;
            }

            ManualEntryItemSpec tmp = SelectedItems[selIdx + 1];
            SelectedItems[selIdx + 1] = SelectedItems[selIdx];
            SelectedItems[selIdx] = tmp;
            
            RedrawSelected();

            selectedResultsListViewEx.Focus();
            selectedResultsListViewEx.Items[selIdx + 1].Selected = true;
            selectedResultsListViewEx.Items[selIdx + 1].EnsureVisible();
        }

        //private void cancelButton_Click(object sender, EventArgs e)
        //{
        //    DialogResult = DialogResult.Cancel;
        //    Close();
        //}

		private void availableByCategoryTreeView_NodeMouseHover2(object sender, TreeNodeMouseHoverEventArgs e)
		{
			ToolTip toolTip = new ToolTip();
			toolTip.SetToolTip(this, e.Node.ToolTipText); 
		}
    }
}