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

namespace Results.Forms
{
    public partial class ResultsConfigCtrl : UserControl
    {
        /// <summary>
        /// ListViewEx columns
        /// </summary>
        enum Column
        {
            Item,
            Caption,
            Units,
            Format,
            Precision,
            Width,
            Alignment,
			TestID,
			Count,
        }

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

		public MetersKind MetersKind;
		public IList<WMeterRsltItemSpec> SelectedItems;
        public bool SupressTestIDColumn;
		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 ResultsConfigCtrl(bool supressTestIDColumn)
			: this()
		{
			this.SupressTestIDColumn = supressTestIDColumn;
		}

        public ResultsConfigCtrl()
		{
			InitializeComponent();
		}


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

			selectedResultsLabel.Text = Strings.Selected_results;

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

		private void ResultsConfigCtrl_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 });
            selectedResultsListViewEx.Columns.Add(new ColumnHeader { Text = Strings.Format });
            selectedResultsListViewEx.Columns.Add(new ColumnHeader { Text = Strings.Precision });
            selectedResultsListViewEx.Columns.Add(new ColumnHeader { Text = Strings.Width });
            selectedResultsListViewEx.Columns.Add(new ColumnHeader { Text = Strings.Alignment });
			if (!SupressTestIDColumn)
			{
				selectedResultsListViewEx.Columns.Add(new ColumnHeader { Text = Strings.Test_ID });
			}

            /// 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,
                    new TextBox(),		/// format
                    new TextBox(),		/// precision
                    new TextBox(),		/// width
                    alignmentCB,
                    new TextBox(),		/// testID
                };
            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)
			{
				Quantity quantity = (e.Item.Tag as WMeterRsltItemSpec).Quantity;
				unitsCB.Items.Clear();
				unitsCB.Items.Add(Unit.None.ToDescription());				/// "---"
				for (Unit u = (Unit)1; u < Unit.Count; u++)
				{
					if (Units.IsQuantity(u, quantity))  unitsCB.Items.Add(u.ToDescription());
				}
				selectedResultsListViewEx.StartEditing(unitsCB, e.Item, e.SubItem);
			}
            else if ((e.SubItem > 0) && (e.SubItem < (int)(SupressTestIDColumn ? Column.TestID : Column.Count)))
            {
                selectedResultsListViewEx.StartEditing(editors[e.SubItem], e.Item, e.SubItem);
            }
        }

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

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

				case Column.Format: item.Format = e.DisplayText; return;
				case Column.Precision: item.Precision = e.DisplayText; return;
				case Column.Width:
					{
						int width;
						if (Int32.TryParse(editors[e.SubItem].Text, out width) && width >= 0)
						{
							item.Width = width;
							return;     /// OK
						}
						break;          /// Error
					}

                case Column.Alignment:
                    for (Alignment a = 0; a < Alignment.Count; a++)
                    {
                        if (a.ToDescription().Equals(editors[e.SubItem].Text))
                        {
                            item.Alignment = a;
                            return;
                        }
                    }
                    break;              /// Error

				case Column.TestID: item.TestID = e.DisplayText; return;
	
				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<WMeterRsltItemSpec> alphabeticlList = WMeterRsltItemSpec.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<Quantity> quantities = new List<Quantity>();
			for (Quantity q = 0; q < Quantity.Count; q++) quantities.Add(q);

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

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

				if (n > 0)
				{
					TreeNode[] array = new TreeNode[n];
					int i = 0;
					foreach (var ri in WMeterRsltItemSpec.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 WMeterRsltItemSpec.AllItems)
				{
					if (ri.Category == c) n++;
				}

				if (n > 0)
				{
					TreeNode[] array = new TreeNode[n];
					int i = 0;
					foreach (var ri in WMeterRsltItemSpec.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
                lvi.SubItems.Add(item.Format);                      /// Format
                lvi.SubItems.Add(item.Precision);                   /// Precision
                lvi.SubItems.Add(item.Width.ToString());            /// Width
                lvi.SubItems.Add(item.Alignment.ToDescription());   /// Alignment
				if (!SupressTestIDColumn)
				{
					lvi.SubItems.Add(item.TestID);                  /// TestID
				}

				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 WMeterRsltItemSpec)
			{
				AddItem(availableByQuantityTreeView.SelectedNode.Tag as WMeterRsltItemSpec);
			}
		}

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

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

		void AddItem(WMeterRsltItemSpec item)
		{
			WMeterRsltItemSpec 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 ResultsConfigCtrl_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;
            }

            WMeterRsltItemSpec 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;
            }

            WMeterRsltItemSpec 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); 
		}
    }
}