///
/// Copyright (c) 2013-2015 Sensus Metering Systems
///
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using TBF.Resources;

namespace TBF.Forms
{
	public partial class ResultsConfig : Form
	{
		/// <summary>
		/// Required access rights to make changes with this form
		/// </summary>
		const Grp.GID RequiredGroupMembership = Grp.GID.Metrologists;

		/// Arrangement of tests
		public enum TestsAre
		{
			Rows,
			Columns,
		}
		public TestsAre TestsArrangement;

		/// Arrangement of meters
		public enum Meters
		{
			Vertically,
			Horizontally,
		}
		public Meters MetersArrangement;

		public IList<ResultItemSpec> currentlyAvailableItems;
		public IList<ResultItemSpec> RsltItems_Screen_SingleWM;
		public IList<ResultItemSpec> RsltItems_Screen_CombinedWM;
		public IList<ResultItemSpec> RsltItems_Printer_SingleWM;
		public IList<ResultItemSpec> RsltItems_Printer_CombinedWM;
		public IList<ResultItemSpec> RsltItems_Disk_SingleWM;
		public IList<ResultItemSpec> RsltItems_Disk_CombinedWM;

		bool combined;				/// false = single meter items, true = combined meter items
		Entities.Device device;		/// Screen, Printer or Disk
		bool unlocked;				/// true = changes enabled

		public ResultsConfig()
		{
			InitializeComponent();

			combined = false;
			device = Entities.Device.Screen;
			unlocked = false;
			cancelButton.Visible = false;
		}

		void Localize()
		{
			Text = Strings.Configuration;
			testsArangementGroupBox.Text = Strings.Arrangement_of_tests;
			metersArangementGroupBox.Text = Strings.Arrangement_of_meters;
			testsRowsRadioButton.Text = Strings.Tests_are_rows;
			testsColumnsRadioButton.Text = Strings.Tests_are_columns;
			horizontallyRadioButton.Text = Strings.Horizontally;
			verticallyRadioButton.Text = Strings.Vertically;
			groupBox1.Text = Strings.Water_Meter;
			singleRadioButton.Text = Strings.SingleBtnText;
			combinedRadioButton.Text = Strings.CombinedBtnText;
			groupBox2.Text = Strings.Device;
			screenRadioButton.Text = Strings.ScreenBtnText;
			printerRadioButton.Text = Strings.PrinterBtnText;
			availableResultsLabel.Text = Strings.Available_results;
			selectedResultsLabel.Text = Strings.Selected_results;
			addButton.Text = Strings.Add;
			removeButton.Text = Strings.Remove;
			removeAllButton.Text = Strings.Remove_all;
			unlockButton.Text = Strings.UnlockBtnText;
			okButton.Text = Strings.CloseBtnText;
			cancelButton.Text = Strings.CancelBtnText;
		}

		void ResultsConfig_Load(object sender, EventArgs e)
		{
			Localize();

			testsRowsRadioButton.Checked = (TestsArrangement == TestsAre.Rows);
			testsColumnsRadioButton.Checked = (TestsArrangement == TestsAre.Columns);

			horizontallyRadioButton.Checked = (MetersArrangement == Meters.Horizontally);
			verticallyRadioButton.Checked = (MetersArrangement == Meters.Vertically);

			RedrawAvailable();
			RedrawSelected();
		}

		/// <summary>
		/// Gets the list of selected items based on watermeter type and device selections
		/// </summary>
		/// <returns>List of selected result items</returns>
		IList<ResultItemSpec> GetSelectedItems()
		{
			if (combined)
			{
				switch (device)
				{
					default:
					case Entities.Device.Screen:	return RsltItems_Screen_CombinedWM;
					case Entities.Device.Printer:	return RsltItems_Printer_CombinedWM;
					case Entities.Device.Disk:		return RsltItems_Disk_CombinedWM;
				}
			}
			else
			{
				switch (device)
				{
					default:
					case Entities.Device.Screen:	return RsltItems_Screen_SingleWM;
					case Entities.Device.Printer:	return RsltItems_Printer_SingleWM;
					case Entities.Device.Disk:		return RsltItems_Disk_SingleWM;
				}
			}
		}

		/// <summary>
		/// Redraw selected items (right hand side)
		/// </summary>
		void RedrawAvailable()
		{
			availableResultsListBox.Items.Clear();
			currentlyAvailableItems = new List<ResultItemSpec>();
			foreach (var item in ResultItemSpec.AllItems)
			{
				if (!GetSelectedItems().Contains(item) && (combined ? item.CanPrintCombined : item.CanPrintSingle))
				{
					currentlyAvailableItems.Add(item);
					availableResultsListBox.Items.Add(item.Name);
				}
			}
		}

		/// <summary>
		/// Redraw selected items (right hand side)
		/// </summary>
		void RedrawSelected()
		{
			selectedResultsListBox.Items.Clear();
			foreach (var item in GetSelectedItems())
			{
				selectedResultsListBox.Items.Add(item.Name);
			}
		}

		void unlockButton_Click(object sender, EventArgs e)
		{
			if (!unlocked)
			{
				if (!Entities.User.CurrentUser.IsMemberOf(RequiredGroupMembership))
				{
					if ((new LoginDlg(RequiredGroupMembership)).ShowDialog() != DialogResult.OK) return;
				}
				else if (Program.LocalSettings.AlwaysAskPasswdWhenUnlocking)
				{
					if ((new LoginDlg(Entities.User.CurrentUser.Name, RequiredGroupMembership)).ShowDialog() != DialogResult.OK) return;
				}

				unlocked = true;

				///
				/// Unlock user interface controls
				/// 
				unlockButton.Enabled = false;
				okButton.Text = Strings.OkBtnText;
				cancelButton.Visible = true;
				testsRowsRadioButton.Enabled = true;
				testsColumnsRadioButton.Enabled = true;
				verticallyRadioButton.Enabled = true;
				horizontallyRadioButton.Enabled = true;
				availableResultsListBox.Enabled = true;
				selectedResultsListBox.Enabled = true;
				addButton.Enabled = true;
				removeButton.Enabled = true;
				removeAllButton.Enabled = true;
			}
		}

		void okButton_Click(object sender, EventArgs e)
		{
			if (testsColumnsRadioButton.Checked) TestsArrangement = TestsAre.Columns;
			else TestsArrangement = TestsAre.Rows;

			if (horizontallyRadioButton.Checked) MetersArrangement = Meters.Horizontally;
			else MetersArrangement = Meters.Vertically;

			DialogResult = DialogResult.OK;
			Close();
		}

		void availableResultsListBox_DoubleClick(object sender, EventArgs e)
		{
			/// Double click works when just one item is selected
			IList<ResultItemSpec> itemsToRemove = new List<ResultItemSpec>();
			if (availableResultsListBox.SelectedIndices.Count == 1)
			{
				var item = currentlyAvailableItems[availableResultsListBox.SelectedIndices[0]];
				GetSelectedItems().Add(item);
				RedrawAvailable();
				RedrawSelected();
			}
		}

		void addButton_Click(object sender, EventArgs e)
		{
			/// Append at the end, this code supports multiple selected items,
			/// although ListBox control settings may limit the max.number of selected items to one.

			for (int i = availableResultsListBox.SelectedIndices.Count - 1; i >= 0; i--)
			{
				var item = currentlyAvailableItems[availableResultsListBox.SelectedIndices[i]];
				GetSelectedItems().Add(item);
			}
			RedrawAvailable();
			RedrawSelected();
		}

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

			if (selectedResultsListBox.SelectedIndices.Count == 1)
			{
				GetSelectedItems().RemoveAt(selectedResultsListBox.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 = selectedResultsListBox.SelectedIndices.Count - 1; i >= 0; i--)
			{
				GetSelectedItems().RemoveAt(selectedResultsListBox.SelectedIndices[i]);
			}
			RedrawAvailable();
			RedrawSelected();
		}

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

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

		private void singleRadioButton_CheckedChanged(object sender, EventArgs e)
		{
		}

		private void combinedRadioButton_CheckedChanged(object sender, EventArgs e)
		{
			combined = combinedRadioButton.Checked;
			RedrawAvailable();
			RedrawSelected();
		}

		private void screenRadioButton_CheckedChanged(object sender, EventArgs e)
		{
			if (screenRadioButton.Checked) device = Entities.Device.Screen;
			RedrawAvailable();
			RedrawSelected();
		}

		private void printerRadioButton_CheckedChanged(object sender, EventArgs e)
		{
			if (printerRadioButton.Checked) device = Entities.Device.Printer;
			RedrawAvailable();
			RedrawSelected();
		}

		private void diskRadioButton_CheckedChanged(object sender, EventArgs e)
		{
			if (diskRadioButton.Checked) device = Entities.Device.Disk;
			RedrawAvailable();
			RedrawSelected();
		}
	}
}