///
/// Copyright (c) 2016 Sensus Metering Systems
///
using System;
using System.Collections.Generic;
using System.Drawing;
using System.IO;
using System.Windows.Forms;
using log4net;
using TBF.Resources;

namespace TBF.BenchControl.DataEntry.HeatMeters6
{
	public partial class CycleBeginningForm : Form, GenericDevices.IHasCompleted
    {
		private static readonly ILog log = LogManager.GetLogger(typeof(CycleBeginningForm));

        readonly Results.Entities.WaterMeter[] WaterMeters;

		/// <summary> Number of water meters </summary>
        public readonly int WaterMetersCount;
        public readonly bool AtTheEnd;
        public readonly bool SensusExtensions;

		/// To be retrieved after the form is closed
		public string PurchaseOrder;
		public string[] SNText;
		public bool[] Disabled;

        public string IdNumber;
        public string SnPrefix;
        public string SnSuffix;
        public string Remark;

		/// Set to 'true' when the form closes
        public bool Completed { get { return completed; } }
		bool completed;

		/// <summary> Number of text boxes for serial numbers </summary>
		int textBoxesCount;
		Label[] labels;
		ComboBox[] comboBoxes;
		CheckBox[] checkBoxes;
        PictureBox[] pictureBoxes;
		IList<ComboBox> enabledComboBoxes;


		/// <summary> Parameterless constructor for common functionality </summary>
		public CycleBeginningForm()
		{
			InitializeComponent();
			ControlBox = false;
			
			labels = new Label[] { label1,  label2,  label3,  label4,  label5,  label6 };
			comboBoxes = new ComboBox[] { comboBox1,  comboBox2,  comboBox3,  comboBox4,  comboBox5,  comboBox6 };
			checkBoxes = new CheckBox[] { checkBox1,  checkBox2,  checkBox3,  checkBox4,  checkBox5,  checkBox6 };
            pictureBoxes = new PictureBox[] { pictureBox1, pictureBox2, pictureBox3, pictureBox4,  pictureBox5,  pictureBox6 };

            if (labels.Length != comboBoxes.Length || labels.Length != checkBoxes.Length) throw new Exception("Error in CycleBeginningForm()");

            textBoxesCount = labels.Length;

			enabledComboBoxes = new List<ComboBox>();

			completed = false;
			StartForceCloseHandler();
		}

        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="waterMetersCount">Number of text boxes for serial numbers</param>
        public CycleBeginningForm(Results.Entities.WaterMeter[] waterMeters, bool atTheEnd, bool sensusExtensions)
			: this()
        {
            this.WaterMeters = waterMeters;
            this.WaterMetersCount = waterMeters.Length;
            this.AtTheEnd = atTheEnd;
            this.SensusExtensions = sensusExtensions;
            SNText = new string[WaterMetersCount];
			Disabled = new bool[WaterMetersCount];

			ShuffleTextBoxes(Config.Data.WMsCount, Config.Data.LineSize);

            foreach (var wm in WaterMeters) if (wm != null) wm.Passed = wm.PassedFromTests();

            Height = 147 + WaterMetersCount * 45;   /// Adjust the window size

            if (sensusExtensions)
            {
                if (Height < 605) Height = 605;     /// Minimum height for the extensionsGroupBox
            }
            else
            {
                /// Hide extensionsGroupBox, etc.
                int delta = extensionsGroupBox.Width + 45;
                okButton.Left -= delta;
                clearButton.Left -= delta;
                Width -= delta;
                extensionsGroupBox.Visible = false;
                autoSNButton.Visible = false;
            }
        }

		/// <summary>
		/// Make sure the layout of labels/text boxes on the screen
		/// corresponds to the layout of watermeters of the test bench.
		/// </summary>
		/// <param name="wmsCount">Number of watermeters</param>
		/// <param name="lineSize">Number of watermeters in one line</param>
		void ShuffleTextBoxes(int wmsCount, int lineSize)
		{
			if (wmsCount < textBoxesCount && lineSize > 0)
			{
				int nrLines = (wmsCount + lineSize - 1) / lineSize;
				int gap = (textBoxesCount - wmsCount) / nrLines;

				int dest = 0;
				for (int l = 0; l < nrLines; l++)
				{
					for (int i = 0; i < lineSize; i++)
					{
						labels[dest] = labels[l * lineSize + l * gap + i];
						comboBoxes[dest] = comboBoxes[l * lineSize + l * gap + i];
						checkBoxes[dest] = checkBoxes[l * lineSize + l * gap + i];
                        pictureBoxes[dest] = pictureBoxes[l * lineSize + l * gap + i];
                        dest++;
					}
				}
				textBoxesCount = wmsCount;
			}
		}

        private void CycleBeginningForm_Load(object sender, EventArgs e)
        {
			Localize();
			
			PrepareOrderCombo(orderComboBox);

			for (int i = 0; i < textBoxesCount; i++)
			{
				if (Program.LocalSettings.LastSNTextsCount == textBoxesCount)
				{
                    comboBoxes[i].Items.Add((Program.LocalSettings.LastSNTexts[i] == null) ? string.Empty : Program.LocalSettings.LastSNTexts[i]);
                }
                labels[i].Visible = comboBoxes[i].Visible = checkBoxes[i].Visible = true;
                enabledComboBoxes.Add(comboBoxes[i]);
                if (AtTheEnd)
                {
                    pictureBoxes[i].Visible = true;
                }
			}

            UpdateIcons();

            if (SensusExtensions)
            {
                idNumberTextBox.Text = (Program.LocalSettings.LastText1 == null) ? string.Empty : Program.LocalSettings.LastText1;
                snPrefixTextBox.Text = (Program.LocalSettings.LastText2 == null) ? string.Empty : Program.LocalSettings.LastText2;
                snSuffixTextBox.Text = (Program.LocalSettings.LastText3 == null) ? string.Empty : Program.LocalSettings.LastText3;
                remarkTextBox.Text = (Program.LocalSettings.LastRemark == null) ? string.Empty : Program.LocalSettings.LastRemark;
            }
		}

		void Localize()
		{
			Text = Strings.Data;
			orderGroupBox.Text = Strings.Purchase_order;
			for (int i = 0; i < textBoxesCount; i++)
			{
				labels[i].Text = Strings.Serial_Number + " " + (i + 1).ToString();
			}
			okButton.Text = Strings.OkBtnText;
			clearButton.Text = Strings.ClearBtnText;
		}

		/// <summary>
		/// Load Purchase order combo box items from the LocalSettings PurchaseOrderHistory array
		/// </summary>
		/// <param name="orderComboBox">Puchase order ComboBox</param>
		void PrepareOrderCombo(ComboBox orderComboBox)
		{
			for (int i = 0; i < Program.LocalSettings.PurchaseOrderHistoryCount; i++)
			{
				orderComboBox.Items.Add(Program.LocalSettings.PurchaseOrderHistory[i]);
			}

			if (orderComboBox.Items.Count > 0)
			{
				orderComboBox.Text = orderComboBox.Items[0].ToString();
			}
		}

        void UpdateIcons()
        {
            Image imgP = null;
            Image imgF = null;
            Image imgP2 = null;
            Image imgF2 = null;

            int nrRedone = 0;
            if (SensusExtensions)
            {
                if (!int.TryParse(ext1TextBox.Text, out nrRedone) || nrRedone < 0 || nrRedone > WaterMetersCount)
                {
                    nrRedone = 0;
                }
            }

            for (int i = 0; i < WaterMetersCount; i++)
            {
                Results.Entities.WaterMeter wm = WaterMeters[i];
                if (wm == null)
                {
                    checkBoxes[i].Checked = true;
                }
                else if (AtTheEnd)
                {
                    if (imgP == null || imgF == null || imgP2 == null || imgF2 == null)
                    {
                        imgP = Properties.Resources.TestPassedImage;      /// Passed
                        imgF = Properties.Resources.TestFailedImage;      /// Failed
                        imgP2 = Properties.Resources.TestPassedImage2;    /// Passed after re-work
                        imgF2 = Properties.Resources.TestFailedImage2;    /// Failed after re-work
                    }

                    pictureBoxes[i].Image = (WaterMetersCount - i > nrRedone) ? (wm.Passed ? imgP : imgF) : (wm.Passed ? imgP2 : imgF2);
                }
            }
        }

		private void okButton_Click(object sender, EventArgs e)
        {
			PurchaseOrder = orderComboBox.Text;
			Program.LocalSettings.UpdateHistory(orderComboBox.Text,
												ref Program.LocalSettings.PurchaseOrderHistory
#if FUZHOU_150 || FUZHOU_300
												, 20
#endif
												);

			Program.LocalSettings.LastSNTexts = SNText;

			for (int i = 0; i < Math.Min(WaterMetersCount, textBoxesCount); i++)
			{
				SNText[i] = comboBoxes[i].Text;
				Disabled[i] = !checkBoxes[i].Checked;
			}

            if (SensusExtensions)
            {
                int nrRedone = 0;
                if (SensusExtensions)
                {
                    if (!int.TryParse(ext1TextBox.Text, out nrRedone) || nrRedone < 0 || nrRedone > WaterMetersCount)
                    {
                        nrRedone = 0;
                    }
                }

                Program.LocalSettings.LastText1 = IdNumber = string.IsNullOrEmpty(idNumberTextBox.Text) ? null : idNumberTextBox.Text;
                Program.LocalSettings.LastText2 = SnPrefix = string.IsNullOrEmpty(snPrefixTextBox.Text) ? null : snPrefixTextBox.Text;
                Program.LocalSettings.LastText3 = SnSuffix = string.IsNullOrEmpty(snSuffixTextBox.Text) ? null : snSuffixTextBox.Text;
                Program.LocalSettings.LastRemark = Remark = string.IsNullOrEmpty(remarkTextBox.Text) ? null : remarkTextBox.Text;

                for (int i = 0; i < WaterMetersCount; i++)
                {
                    Results.Entities.WaterMeter wm = WaterMeters[i];
                    {
                        if (wm != null)
                        {
                            bool pressureTestPassed = false;
                            foreach (var mtr in wm.MeterTestRslts)
                            {
                                if ((mtr.Method().Equals("PMax-Test") || mtr.Method().Equals("Leak-Test")) && mtr.Passed)
                                {
                                    pressureTestPassed = true;
                                    break;
                                }
                            }
                            wm.WaterMeterData.Text1 = IdNumber;
                            wm.WaterMeterData.Text2 = SnPrefix;
                            wm.WaterMeterData.Text3 = SnSuffix;
                            wm.Batch.Remark = Remark;
                            wm.ResultCode = 32 + (wm.Passed ? 0 : 1) + (pressureTestPassed ? 64 : 0) + ((WaterMetersCount - i <= nrRedone) ? 128 : 0);
                        }
                    }
                }
            }

            completed = true;
            Close();
        }

		/// <summary>
		/// When one combo box is updated using drop-down menu, all combo boxes
		/// are updated by this function.
		/// </summary>
		private void UpdateAllCombos()
		{
			for (int i = 0; i < Math.Min(WaterMetersCount, textBoxesCount); i++)
			{
				comboBoxes[i].Text = Program.LocalSettings.LastSNTexts[i];
				checkBoxes[i].Checked = !string.IsNullOrEmpty(comboBoxes[i].Text);
			}
		}

		private void clearButton_Click(object sender, EventArgs e)
		{
			for (int i = 0; i < Math.Min(WaterMetersCount, textBoxesCount); i++)
			{			
				comboBoxes[i].Text = string.Empty;
				checkBoxes[i].Checked = false;
			}
		}


		private void comboBox1_TextChanged(object sender, EventArgs e) { checkBox1.Checked = true; }
		private void comboBox1_SelectedIndexChanged(object sender, EventArgs e)
		{
			if (Program.LocalSettings.LastSNTextsCount == WaterMetersCount)
			{
				if (comboBox1.Text.Equals(comboBox1.Items[0])) UpdateAllCombos();
			}
		}

		private void comboBox2_TextChanged(object sender, EventArgs e) { checkBox2.Checked = true; }
		private void comboBox2_SelectedIndexChanged(object sender, EventArgs e)
		{
			if (Program.LocalSettings.LastSNTextsCount == WaterMetersCount)
			{
				if (comboBox2.Text.Equals(comboBox2.Items[0])) UpdateAllCombos();
			}
		}

		private void comboBox3_TextChanged(object sender, EventArgs e) { checkBox3.Checked = true; }
		private void comboBox3_SelectedIndexChanged(object sender, EventArgs e)
		{
			if (Program.LocalSettings.LastSNTextsCount == WaterMetersCount)
			{
				if (comboBox3.Text.Equals(comboBox3.Items[0])) UpdateAllCombos();
			}
		}

		private void comboBox4_TextChanged(object sender, EventArgs e) { checkBox4.Checked = true; }
		private void comboBox4_SelectedIndexChanged(object sender, EventArgs e)
		{
			if (Program.LocalSettings.LastSNTextsCount == WaterMetersCount)
			{
				if (comboBox4.Text.Equals(comboBox4.Items[0])) UpdateAllCombos();
			}
		}
 
		private void comboBox5_TextChanged(object sender, EventArgs e) { checkBox5.Checked = true; }
		private void comboBox5_SelectedIndexChanged(object sender, EventArgs e)
		{
			if (Program.LocalSettings.LastSNTextsCount == WaterMetersCount)
			{
				if (comboBox5.Text.Equals(comboBox5.Items[0])) UpdateAllCombos();
			}
		}

		private void comboBox6_TextChanged(object sender, EventArgs e) { checkBox6.Checked = true; }
		private void comboBox6_SelectedIndexChanged(object sender, EventArgs e)
		{
			if (Program.LocalSettings.LastSNTextsCount == WaterMetersCount)
			{
				if (comboBox6.Text.Equals(comboBox6.Items[0])) UpdateAllCombos();
			}
		}

		#region Forced close handling

		public void StartForceCloseHandler()
		{
			UiBridge.Bridge.CloseModelessFormHandler += delegate(object sender, EventArgs args)
			{
				if (InvokeRequired) { Invoke(new EventHandler<EventArgs>(OnForceClose), sender, args); }
				else OnForceClose(sender, args);
			};
		}

		private void OnForceClose(object sender, EventArgs args)
		{
			DialogResult = DialogResult.Cancel;
			Close();
		}

		#endregion

		/// <summary>
		/// Process a key press within any enabled text boxe
		/// </summary>
		/// <param name="sender"></param>
		/// <param name="e"></param>
		/// <param name="currentFocusOwner">TextBox control which received the event</param>
		private void ProcKeyPress(object sender, KeyPressEventArgs e, ComboBox currentFocusOwner)
		{
			if (e.KeyChar == '+')
			{
				/// Process '+' key ..... Form completed
				okButton_Click(sender, e);
			}
			if (e.KeyChar == '\r')
			{
				/// Process <enter> key ..... Next text field
				if (enabledComboBoxes.Count < 2) return;		/// There is just one enabled textbox

				for (int i = 0; i < enabledComboBoxes.Count; i++)
				{
					if (enabledComboBoxes[i] == currentFocusOwner)
					{
						/// Change focus to the next enabled text box
						enabledComboBoxes[(i + 1) % enabledComboBoxes.Count].Focus();
						return;
					}
				}
			}
		}

		private void comboBox1_KeyPress(object sndr, KeyPressEventArgs e) { ProcKeyPress(sndr, e, comboBox1); }
		private void comboBox2_KeyPress(object sndr, KeyPressEventArgs e) { ProcKeyPress(sndr, e, comboBox2); }
		private void comboBox3_KeyPress(object sndr, KeyPressEventArgs e) { ProcKeyPress(sndr, e, comboBox3); }
		private void comboBox4_KeyPress(object sndr, KeyPressEventArgs e) { ProcKeyPress(sndr, e, comboBox4); }
		private void comboBox5_KeyPress(object sndr, KeyPressEventArgs e) { ProcKeyPress(sndr, e, comboBox5); }
		private void comboBox6_KeyPress(object sndr, KeyPressEventArgs e) { ProcKeyPress(sndr, e, comboBox6); }

        private void autoSNButton_Click(object sender, EventArgs e)
        {
            try
            {
                bool snFound = false;
                int sn = 1;

                for (int i = 0; i < textBoxesCount; i++)
                {
                    if (!AtTheEnd || WaterMeters[i].Passed)
                    {
                        if (!snFound)
                        {
                            sn = int.Parse(comboBoxes[i].Text);         /// S/N from the first combo box
                            snFound = true;
                        }
                        else
                        {
                            sn++;
                            comboBoxes[i].Text = sn.ToString();     /// Update combo boxes of other 'good' water meters
                        }
                    }
                }
            }
            catch
            {
                /// Don't do anything if int.Parse fails
            }
        }

        private void ext1TextBox_TextChanged(object sender, EventArgs e)
        {
            UpdateIcons();
        }
   }
}