///
/// Copyright (c) 2013-2021 Senus Slovensko a.s.
///
using System;
using System.Collections.Generic;
using System.Drawing;
using System.Windows.Forms;
using log4net;
using Common;
using Config.Entities;
using TBF.UiBridge;
using TBF.Resources;
using NHibernate;

namespace TBF.UI.Shared
{
    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;

        bool isRestoreSessionEnabled;

        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 = 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;

            startTestBtn.Enabled = false;
            startTestBtn.BackColor = colorTestsDis;

            startCycleBtn.Enabled = false;
            startCycleBtn.BackColor = colorCycleDis;

            acceptResultsBtn.Enabled = false;
            acceptResultsBtn.BackColor = colorAcceptDis;

            breakBtn.Enabled = false;
            breakBtn.BackColor = System.Drawing.SystemColors.Control;

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

        void Localize()
        {
            testGroupBox.Text = Strings.Session;
            startTestBtn.Text = Strings.Start_the_test;
            startCycleBtn.Text = Strings.Start_cycle;
            acceptResultsBtn.Text = Strings.End_session;
            breakBtn.Text = Strings.Abort_session;
            stopBtn.Text = Strings.Stop;
            purgeGroupBox.Text = Strings.Pipeline;
            purgeBeginBtn.Text = Strings.Fill;
            purgeEndBtn.Text = Strings.Empty;
            emptyGroupBox.Text = Strings.Empty_the_tank;
        }

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

            bool openAndCloseSession = (session == null);

			string oriTestName = testComboBox.Text;

            try
            {
                if (openAndCloseSession)
                {
                    session = Program.MainWnd.SelectedProcedure.IsRemote
                                    ? TBF.DB.SharedDBSessionFactory.OpenSession()
                                    : TBF.DB.ConfigDBSessionFactory.OpenSession();
                }

                var procedures = session.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];
                if (procedures[0].GetTestInstances() == null)
                {
                    procedures[0].UpdateTestInstances(TBF.Rig.StateMachine.LoopStartNames, TBF.Rig.StateMachine.LoopEndNames, null);
                }

                testComboBox.Items.Clear();
                foreach (var tinst in procedures[0].GetTestInstances())
                {
                    testComboBox.Items.Add(tinst);
                }

                if (testComboBox.Items.Contains(oriTestName))
                {
                    testComboBox.Text = oriTestName;
                    TestName = oriTestName;
                }
                else if (testComboBox.Items.Count > 0)
                {
                    testComboBox.Text = testComboBox.Items[0].ToString();
                    TestName = testComboBox.Items[0].ToString();
                }
                else
                {
                    testComboBox.Text = string.Empty;
                    TestName = null;
                }
            }
            catch (Exception e)
            {
                log.ErrorFormat("Cannot reload tests: {0}", e.Message);
            }
            finally
            {
                if (openAndCloseSession && session != null && session.IsOpen) session.Close();
            }
		}

		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 (isRestoreSessionEnabled)
            {
                /// Restore session button is enabled
                if (MessageBox.Show(Strings.Do_you_really_want_to_restore_uncompleted_session,
                                    Strings.Warning,
                                    MessageBoxButtons.YesNo,
                                    MessageBoxIcon.Exclamation) == DialogResult.Yes)
                {
                    Bridge.Ui2Bench(UI2BenchCmd.RestoreSession);
                }
            }
            else
            {
                /// Break button is enabled
                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.CurrentUser.IsMemberOf(GID.TestingSpecialists))
            {
                var dlg = new DummyDlg();
                if ((new Users.Forms.LoginDlg(TBF.DB.UserSessionFactories, new GID[] { GID.TestingSpecialists }, dlg)).ShowDialog() != DialogResult.OK)
					return;

                Bridge.Ui2Bench(UI2BenchCmd.StopDrainingTank1);
                Users.CurrentUser.Restore(dlg);
                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.CurrentUser.IsMemberOf(GID.TestingSpecialists))
            {
                var dlg = new DummyDlg();
                if ((new Users.Forms.LoginDlg(TBF.DB.UserSessionFactories, new GID[] { GID.TestingSpecialists }, dlg)).ShowDialog() != DialogResult.OK)
                    return;

                Bridge.Ui2Bench(UI2BenchCmd.StopDrainingTank2);
                Users.CurrentUser.Restore(dlg);
                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.CurrentUser.IsMemberOf(GID.TestingSpecialists))
            {
                var dlg = new DummyDlg();
                if ((new Users.Forms.LoginDlg(TBF.DB.UserSessionFactories, new GID[] { GID.TestingSpecialists }, dlg)).ShowDialog() != DialogResult.OK)
                    return;

                Bridge.Ui2Bench(UI2BenchCmd.StopDrainingTank3);
                Users.CurrentUser.Restore(dlg);
                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;

            isRestoreSessionEnabled = (args.Flags & ButtonsEtc.RestoreSession) != 0;
            breakBtn.Enabled = isRestoreSessionEnabled || (args.Flags & ButtonsEtc.Break) != 0;
            breakBtn.Text = isRestoreSessionEnabled ? Strings.Restore_session : Strings.Abort_session;
			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;
        }
    }
}