///
/// Copyright (c) 2013-2017 Sensus Metering Systems
///
using System;
using System.Collections.Generic;
using System.Drawing;
using System.Windows.Forms;
using log4net;
using Config.Entities;
using TBF.UiBridge;
using TBF.Resources;

namespace TBF.UiControls
{
    public partial class BenchControlPanel : UserControl
    {
		static readonly ILog log = LogManager.GetLogger(typeof(BenchControlPanel));

		public string TestName;

		// Original (enabled) colors of buttons and empty bench
        Color colorStopEn;
		Color colorTestsEn;
		Color colorCycleEn;
		Color colorPurgeEn;
		Color colorAcceptEn;
		Color colorDrainEn;
		Color colorOtherEn;

		Color colorBenchEmpty;

		// Colors of disabled buttons
		Color colorStopDis;
		Color colorTestsDis;
		Color colorCycleDis;
		Color colorPurgeDis;
		Color colorAcceptDis;
		Color colorDrainDis;
		Color colorOtherDis;

		// Colors of Highlighted buttons
		Color colorDrainHi;


		bool drain1Highlighted;
		bool drain2Highlighted;
		bool drain3Highlighted;


        public int BalancesCount
        {
            set
            {
                if (value <= 2)
                {
                    emptyTank1Btn.Size = new Size(92, 35);
                    emptyTank2Btn.Size = new Size(92, 35);
                    emptyTank2Btn.Location = new Point(106, 26);
                    emptyTank3Btn.Visible = false;
                }
            }
        }


        public BenchControlPanel()
        {
            InitializeComponent();

			drain1Highlighted = false;
			drain2Highlighted = false;
			drain3Highlighted = false;

            Bridge.ButtonsEtcHandler += delegate(object sender, ButtonsEtcEventArgs args)
            {
                if (InvokeRequired)
                {
                    Invoke(new EventHandler<ButtonsEtcEventArgs>(OnButtonsEtc), sender, args);
                }
                else OnButtonsEtc(sender, args);
            };

            Bridge.ProcedureSelectedHandler += delegate(object sender, ProcedureSelectedEventArgs args)
            {
                if (InvokeRequired)
                {
                    Invoke(new EventHandler<ProcedureSelectedEventArgs>(OnProcedureSelected), sender, args);
                }
                else OnProcedureSelected(sender, args);
            };

			Bridge.TestSelectedHandler += delegate(object sender, TestSelectedEventArgs args)
			{
                if (InvokeRequired)
                {
    				Invoke(new EventHandler<TestSelectedEventArgs>(OnTestSelected), sender, args);
                }
                else OnTestSelected(sender, args);
            };

#if DEBUG
            nextButton.Visible = true;
            nextButton.Enabled = true;
#endif
		}

		/// This is to calculate an RGB component of a lighter color
		int Lghtr(int component)
		{
			return 255 - (255 - component) / 2;
		}

		/// This is to calculate an RGB component of a darker color
		int Drkr(int component)
		{
			return component / 2;
		}
		

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

			// Original (enabled) colors of buttons 
			colorStopEn = stopBtn.BackColor;
            colorTestsEn = startTestBtn.BackColor;
			colorCycleEn = startCycleBtn.BackColor;
			colorPurgeEn = purgeBeginBtn.BackColor;
			colorAcceptEn = acceptResultsBtn.BackColor;
			colorDrainEn = emptyTank1Btn.BackColor;
			colorOtherEn = breakBtn.BackColor;

			colorBenchEmpty = emptyGroupBox.BackColor;

			/// Colors of disabled buttons
			//colorStopDis = Color.FromArgb(Lghtr(colorStopEn.R), Lghtr(colorStopEn.G), Lghtr(colorStopEn.B));
			//colorTestsDis = Color.FromArgb(Lghtr(colorTestsEn.R), Lghtr(colorTestsEn.G), Lghtr(colorTestsEn.B));
			//colorCycleDis = Color.FromArgb(Lghtr(colorCycleEn.R), Lghtr(colorCycleEn.G), Lghtr(colorCycleEn.B));
			//colorPurgeDis = Color.FromArgb(Lghtr(colorPurgeEn.R), Lghtr(colorPurgeEn.G), Lghtr(colorPurgeEn.B));
			//colorAcceptDis = Color.FromArgb(Lghtr(colorAcceptEn.R), Lghtr(colorAcceptEn.G), Lghtr(colorAcceptEn.B));
			//colorDrainDis = Color.FromArgb(Lghtr(colorDrainEn.R), Lghtr(colorDrainEn.G), Lghtr(colorDrainEn.B));
			//colorOtherDis = Color.FromArgb(Lghtr(colorOtherEn.R), Lghtr(colorOtherEn.G), Lghtr(colorOtherEn.B));
			colorStopDis = System.Drawing.SystemColors.Control;
			colorTestsDis = System.Drawing.SystemColors.Control;
			colorCycleDis = System.Drawing.SystemColors.Control;
			colorPurgeDis = System.Drawing.SystemColors.Control;
			colorAcceptDis = System.Drawing.SystemColors.Control;
			colorDrainDis = System.Drawing.SystemColors.Control;
			colorOtherDis = System.Drawing.SystemColors.Control;

			colorDrainHi = Color.FromArgb(Drkr(colorDrainEn.R), Drkr(colorDrainEn.G), Drkr(colorDrainEn.B));
		}

        void Localize()
        {
            testGroupBox.Text = Strings.Session;
            emptyGroupBox.Text = Strings.Drain;
        }

		/// <summary>
		/// Read the database and re-initialize testComboBox items.
		/// Try to preserve the original selection.
		/// </summary>
        public void ReloadTests()
		{
            if (Program.MainWnd.SelectedProcedure == null || string.IsNullOrEmpty(Program.MainWnd.SelectedProcedure.Name)) return;

			string oriTestName = testComboBox.Text;

            IList<Procedure> procedures = Config.FluentCommon.CreateSession(Program.MainWnd.SelectedProcedure.DBKind)
                                                             .QueryOver<Procedure>()
                                                             .Where(x => (x.ProcedureState == ProcedureState.Active))
                                                             .And(x => (x.Name == Program.MainWnd.SelectedProcedure.Name))
                                                             .List();
			if (procedures.Count != 1)
			{
				testComboBox.Text = string.Empty;
				TestName = null;
                Program.MainWnd.CurrentProcedure = null;
				return;
			}

            Program.MainWnd.CurrentProcedure = procedures[0];

			testComboBox.Items.Clear();
			foreach (var test in procedures[0].Tests)
			{
				for (int i = 1; i <= test.Repeats; i++)
				{
					testComboBox.Items.Add(Utils.TestTitle(test, i));
				}
			}

			if (testComboBox.Items.Contains(oriTestName))
			{
				testComboBox.Text = oriTestName;
				TestName = oriTestName;
			}
			else if (procedures[0].Tests.Count > 0)
			{
				Test test = procedures[0].Tests[0];
				string title;
				if (test.Repeats == 1)
				{
					if (test.Part == 0)
						title = test.Name;												/// Single test
					else
						title = string.Format("{0} ({1})", test.Name, test.Part);		/// A part of a single test
				}
				else
				{
					title = string.Format("{0} ({1}/{2})", test.Name, 1, test.Repeats);	/// More test repetitions
				}

				testComboBox.Text = title;
				TestName = title;
			}
			else
			{
				testComboBox.Text = string.Empty;
				TestName = null;
			}
		}

		private void testComboBox_SelectedIndexChanged(object sender, EventArgs e)
		{
			TestName = testComboBox.Text;
			startTestBtn.Select();
		}


		private void startTestBtn_Click(object sender, EventArgs e)		 { Bridge.Ui2Bench(UI2BenchCmd.StartTest);       }
		private void startQ1Btn_Click(object sender, EventArgs e)		 { Bridge.Ui2Bench(UI2BenchCmd.StartQ1);         }
		private void startQ2Btn_Click(object sender, EventArgs e)		 { Bridge.Ui2Bench(UI2BenchCmd.StartQ2);         }
		private void startQ3Btn_Click(object sender, EventArgs e)		 { Bridge.Ui2Bench(UI2BenchCmd.StartQ3);         }
		private void startCycleBtn_Click(object sender, EventArgs e)	 { Bridge.Ui2Bench(UI2BenchCmd.StartCycle);      }
		private void stopBtn_Click(object sender, EventArgs e)			 { Bridge.Ui2Bench(UI2BenchCmd.Stop);            }
		private void purgeBeginBtn_Click(object sender, EventArgs e)	 { Bridge.Ui2Bench(UI2BenchCmd.PurgeBegin);      }
		private void purgeEndBtn_Click(object sender, EventArgs e)		 { Bridge.Ui2Bench(UI2BenchCmd.PurgeEnd);        }		
        private void resetResultsBtn_Click(object sender, EventArgs e)	 { Bridge.Ui2Bench(UI2BenchCmd.ResetResults);    }
		private void acceptResultsBtn_Click(object sender, EventArgs e)  { Bridge.Ui2Bench(UI2BenchCmd.AcceptResults);   }
		private void cameraTestBtn_Click(object sender, EventArgs e)	 { Bridge.Ui2Bench(UI2BenchCmd.CameraTest);      }
		private void sensitivityTestBtn_Click(object sender, EventArgs e){ Bridge.Ui2Bench(UI2BenchCmd.SensitivityTest); }
		private void button1_Click(object sender, EventArgs e)           { Bridge.Ui2Bench(UI2BenchCmd.B1);              }
		private void button2_Click(object sender, EventArgs e)			 { Bridge.Ui2Bench(UI2BenchCmd.B2);              }
        private void nextButton_Click(object sender, EventArgs e)        { Bridge.Ui2Bench(UI2BenchCmd.Next);            }
        private void customButton_Click(object sender, EventArgs e)      { Bridge.Ui2Bench(UI2BenchCmd.Custom);          }

        private void breakBtn_Click(object sender, EventArgs e)
        {
            if (MessageBox.Show(Strings.Do_you_really_want_to_abort_this_session + Environment.NewLine + Strings.Test_results_will_be_lost,
                                Strings.Warning,
                                MessageBoxButtons.YesNo,
                                MessageBoxIcon.Exclamation) == DialogResult.Yes)
            {
                Bridge.Ui2Bench(UI2BenchCmd.Break);
            }
        }
		
		private void emptyTank1Btn_Click(object sender, EventArgs e)
		{
#if TURA_IPERL || TURA_IPERL_NEW
            /// Prevent 'Stop draining' by password
            if (drain1Highlighted && !Users.GlobalData.CurrentUser.IsMemberOf(Users.Grp.GID.TestingSpecialists))
            {
                if ((new Users.Forms.LoginDlg(new Users.Grp.GID[] { Users.Grp.GID.TestingSpecialists })).ShowDialog() != DialogResult.OK)
					return;

    			if (Program.MainWnd != null) Program.MainWnd.UpdateUser();
                Bridge.Ui2Bench(UI2BenchCmd.StopDrainingTank1);
                return;
            }
#endif
			Bridge.Ui2Bench(drain1Highlighted ? UI2BenchCmd.StopDrainingTank1 : UI2BenchCmd.DrainTank1);
		}
		
		private void emptyTank2Btn_Click(object sender, EventArgs e)
		{
#if TURA_IPERL || TURA_IPERL_NEW
            /// Prevent 'Stop draining' by password
            if (drain1Highlighted && !Users.GlobalData.CurrentUser.IsMemberOf(Users.Grp.GID.TestingSpecialists))
            {
                if ((new Users.Forms.LoginDlg(new Users.Grp.GID[] { Users.Grp.GID.TestingSpecialists })).ShowDialog() != DialogResult.OK)
                    return;

                if (Program.MainWnd != null) Program.MainWnd.UpdateUser();
                Bridge.Ui2Bench(UI2BenchCmd.StopDrainingTank2);
                return;
            }
#endif
            Bridge.Ui2Bench(drain2Highlighted ? UI2BenchCmd.StopDrainingTank2 : UI2BenchCmd.DrainTank2);
		}
		
		private void emptyTank3Btn_Click(object sender, EventArgs e)
		{
#if TURA_IPERL || TURA_IPERL_NEW
            /// Prevent 'Stop draining' by password
            if (drain1Highlighted && !Users.GlobalData.CurrentUser.IsMemberOf(Users.Grp.GID.TestingSpecialists))
            {
                if ((new Users.Forms.LoginDlg(new Users.Grp.GID[] { Users.Grp.GID.TestingSpecialists })).ShowDialog() != DialogResult.OK)
                    return;

                if (Program.MainWnd != null) Program.MainWnd.UpdateUser();
                Bridge.Ui2Bench(UI2BenchCmd.StopDrainingTank3);
                return;
            }
#endif
            Bridge.Ui2Bench(drain3Highlighted ? UI2BenchCmd.StopDrainingTank3 : UI2BenchCmd.DrainTank3);
		}


        /// <summary>
        /// Processes a pressed keys.
        /// </summary>
        /// <param name="key">key (char)</param>
        /// <returns>true when the key is handled, otherwise false</returns>
        public bool ProcessKey(char key)
        {
            switch (key)
            {
                case '0': if (stopBtn.Enabled)       { Bridge.Ui2Bench(UI2BenchCmd.Stop); }       return true;
                case '1': if (startQ1Btn.Enabled)    { Bridge.Ui2Bench(UI2BenchCmd.StartQ1); }    return true;
                case '2': if (startQ2Btn.Enabled)    { Bridge.Ui2Bench(UI2BenchCmd.StartQ2); }    return true;
                case '3': if (startQ3Btn.Enabled)    { Bridge.Ui2Bench(UI2BenchCmd.StartQ3); }    return true;
                case '4': if (startTestBtn.Enabled)  { Bridge.Ui2Bench(UI2BenchCmd.StartTest); }  return true;
                case '5': if (startCycleBtn.Enabled) { Bridge.Ui2Bench(UI2BenchCmd.StartCycle); } return true;
                case '6': if (purgeBeginBtn.Enabled) { Bridge.Ui2Bench(UI2BenchCmd.PurgeBegin); } return true;
                case '7': if (purgeEndBtn.Enabled)   { Bridge.Ui2Bench(UI2BenchCmd.PurgeEnd); }   return true;
				case '8':
					if (emptyTank1Btn.Enabled)
					{
						Bridge.Ui2Bench(drain1Highlighted ? UI2BenchCmd.StopDrainingTank1 : UI2BenchCmd.DrainTank1);
					}
					return true;
				case '9':
					if (emptyTank2Btn.Enabled)
					{
						Bridge.Ui2Bench(drain2Highlighted ? UI2BenchCmd.StopDrainingTank2 : UI2BenchCmd.DrainTank2);
					}
					return true;
                default:
                    return false;
            }
        }


        public void OnProcedureSelected(object sender, ProcedureSelectedEventArgs args)
        {
            ReloadTests();
        }

		public void OnTestSelected(object sender, TestSelectedEventArgs args)
		{
			testComboBox.Text = args.Test.Name;
		}


        public void OnButtonsEtc(object sender, ButtonsEtcEventArgs args)
        {
            if ((args.Flags & ButtonsEtc.ShowBenchEmpty) != 0)
            {
                purgeGroupBox.BackColor = colorBenchEmpty;
                return;
            }
            else if ((args.Flags & ButtonsEtc.ShowBenchFilled) != 0)
            {
                purgeGroupBox.BackColor = Color.RoyalBlue;
                return;
            }

            testComboBox.Enabled = ((args.Flags & ButtonsEtc.TestCmbBoxEn) != 0);

            stopBtn.Enabled = ((args.Flags & ButtonsEtc.StopBtnEn) != 0);
            stopBtn.BackColor = stopBtn.Enabled ? colorStopEn : colorStopDis;

            startTestBtn.Enabled = ((args.Flags & ButtonsEtc.StartTestBtnsEn) != 0);
			startTestBtn.BackColor = startTestBtn.Enabled ? colorTestsEn : colorTestsDis;

            startQ1Btn.Enabled = ((args.Flags & ButtonsEtc.StartTestBtnsEn) != 0);
			startQ1Btn.BackColor = startQ1Btn.Enabled ? colorTestsEn : colorTestsDis;

            startQ2Btn.Enabled = ((args.Flags & ButtonsEtc.StartTestBtnsEn) != 0);
			startQ2Btn.BackColor = startQ2Btn.Enabled ? colorTestsEn : colorTestsDis;

            startQ3Btn.Enabled = ((args.Flags & ButtonsEtc.StartTestBtnsEn) != 0);
			startQ3Btn.BackColor = startQ3Btn.Enabled ? colorTestsEn : colorTestsDis;
				
            startCycleBtn.Enabled = ((args.Flags & ButtonsEtc.StartCycleBtnEn) != 0);
			startCycleBtn.BackColor = startCycleBtn.Enabled ? colorCycleEn : colorCycleDis;

#if OPRAV_DEWY
            customButton.Visible = ((args.Flags & ButtonsEtc.StartCycleBtnEn) != 0);
            customButton.BackColor = customButton.Visible ? colorCycleEn : colorCycleDis;
#endif
            purgeBeginBtn.Enabled = ((args.Flags & ButtonsEtc.PurgeBeginBtnEn) != 0);
			purgeBeginBtn.BackColor = purgeBeginBtn.Enabled ? colorPurgeEn : colorPurgeDis;

			purgeEndBtn.Enabled = ((args.Flags & ButtonsEtc.PurgeEndBtnEn) != 0);
			purgeEndBtn.BackColor = purgeEndBtn.Enabled ? colorPurgeEn : colorPurgeDis;

			emptyTank1Btn.Enabled = ((args.Flags & (ButtonsEtc.DrainTankBtn1En | ButtonsEtc.DrainTankBtn1Hi)) != 0);
			drain1Highlighted = ((args.Flags & ButtonsEtc.DrainTankBtn1Hi) != 0);
			emptyTank1Btn.BackColor = emptyTank1Btn.Enabled ? (drain1Highlighted ? colorDrainHi : colorDrainEn) : colorDrainDis;

			emptyTank2Btn.Enabled = ((args.Flags & (ButtonsEtc.DrainTankBtn2En | ButtonsEtc.DrainTankBtn2Hi)) != 0);
			drain2Highlighted = ((args.Flags & ButtonsEtc.DrainTankBtn2Hi) != 0);
			emptyTank2Btn.BackColor = emptyTank2Btn.Enabled ? (drain2Highlighted ? colorDrainHi : colorDrainEn) : colorDrainDis;

            emptyTank3Btn.Enabled = ((args.Flags & (ButtonsEtc.DrainTankBtn3En | ButtonsEtc.DrainTankBtn3Hi)) != 0);
			drain3Highlighted = ((args.Flags & ButtonsEtc.DrainTankBtn3Hi) != 0);
			emptyTank3Btn.BackColor = emptyTank3Btn.Enabled ? (drain3Highlighted ? colorDrainHi : colorDrainEn) : colorDrainDis;

			resetResultsBtn.Enabled = ((args.Flags & ButtonsEtc.ResetResultsBtnEn) != 0);
			resetResultsBtn.BackColor = resetResultsBtn.Enabled ? colorStopEn : colorStopDis;

			acceptResultsBtn.Enabled = ((args.Flags & ButtonsEtc.AcceptResultsBtnEn) != 0);
			acceptResultsBtn.BackColor = acceptResultsBtn.Enabled ? colorAcceptEn : colorAcceptDis;

			breakBtn.Enabled = ((args.Flags & ButtonsEtc.Break) != 0);
			breakBtn.BackColor = breakBtn.Enabled ? colorOtherEn : colorOtherDis;

			cameraTestBtn.Enabled = ((args.Flags & ButtonsEtc.CalibrationBtnEn) != 0);
			cameraTestBtn.BackColor = cameraTestBtn.Enabled ? colorOtherEn : colorOtherDis;

			sensitivityTestBtn.Enabled = ((args.Flags & ButtonsEtc.SensitivityTestBtnEn) != 0);
			sensitivityTestBtn.BackColor = sensitivityTestBtn.Enabled ? colorOtherEn : colorOtherDis;
        }
    }
}