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

namespace TBF
{
    public partial class MainWnd : Form
    {
        static readonly ILog log = LogManager.GetLogger(typeof(MainWnd));

        public UiControls.BenchControlPanel BenchControlPanel;
		public string ProcedureName;
        public Entities.Procedure CurrentProcedure;

        /// <summary>
        /// This dialog is shown when emergency stop is activated
        /// </summary>
        TBF.Forms.EmergencyStopForm emergencyStopModelessDlg;

		bool benchInitializationFailed;
		TestProgressControls testProgressControls;

        /// <summary>
        /// Set when procedures are updated while the ProceduresComboBox is disabled (i.e. during a test).
        /// Reset when the ProceduresComboBox list of items is successfully reloaded in ReloadProcedures().
        /// This flag is tested when ProcedureComboBox is being enabled in OnButtonsEtc(),
        /// optionaly ReloadProcedures() is called.
        /// </summary>
        public bool ProceduresUpdated = false;

        /// <summary>
        /// MainTabPage ID-s 
        /// The order of TabPages in this enum must be the same as the order
        /// of their additions into the mainTabControl in MainWnd.Designer.cs
        /// TODO: Find a better way
        /// </summary>
        public enum MainTabPageId
        {
            Invalid = -1,
            Hydraulics = 0,
			Process,
            Measurement,
			Insert,
			Pictures,
            Results,
            Logs,
            TabPagesCount
        }

        /// <summary>
        /// Event handlers switching between tab pages
        /// </summary>
		private void homeTSMenuItem_Click(object sender, EventArgs e) { mainTabControl.SelectTab((int)MainTabPageId.Hydraulics); }
		private void processTSMenuItem_Click(object sender, EventArgs e) { mainTabControl.SelectTab((int)MainTabPageId.Process); }
		private void measurementTSMenuItem_Click(object sender, EventArgs e) { mainTabControl.SelectTab((int)MainTabPageId.Measurement); }
		private void picturesTSMItem_Click(object sender, EventArgs e) { mainTabControl.SelectTab((int)MainTabPageId.Pictures); }
		private void resultsTSMenuItem_Click(object sender, EventArgs e) { mainTabControl.SelectTab((int)MainTabPageId.Results); }
		private void logsTSMenuItem_Click(object sender, EventArgs e) { mainTabControl.SelectTab((int)MainTabPageId.Logs); }

        /// <summary>
        /// Constructor
        /// </summary>
        public MainWnd()
        {
            InitializeComponent();

			Version ver = System.Reflection.Assembly.GetExecutingAssembly().GetName().Version;

			Text = string.Format("Test Bench Framework  ver. {0}.{1}.{2} - {3}{4}",
								 ver.Major, ver.Minor, ver.Build, 
								 Program.CurrentBench.BenchName,
								 Program.CurrentBench.IsRealBench ? "" : Strings._offline);

            usersTSMenuItem.Visible = User.CurrentUser.IsMemberOf(Grp.GID.Administrators) ||
                                      User.CurrentUser.IsMemberOf(Grp.GID.HeadOfLab);

            benchInitializationFailed = false;
            ///
            if (Program.CurrentBench.IsRealBench)
            {
                try
                {
                    BenchControl.StateMachine.InitializeBoardEtc(ctrlBrdComponent);
                    testProgressControls = new TestProgressControls(progressFlowLayoutPanel);
                }
                catch (Exception exc)
                {
                    benchInitializationFailed = true;
                    log.Fatal("Failed to initialize a test bench component", exc);
                    MessageBox.Show(exc.Message, Strings.Error, System.Windows.Forms.MessageBoxButtons.OK,
                                                                System.Windows.Forms.MessageBoxIcon.Exclamation);
                }
            }
        }

		void Localize()
		{
			procedureGroupBox.Text = Strings.Procedure;
			activityGroupBox.Text = Strings.Activity;
			progressGroupBox.Text = Strings.Progress;
		}

        /// <summary>
        /// Initializes this window and its controls
        /// </summary>
        private void MainWnd_Load(object sender, EventArgs e)
        {
			Localize();

            TBF.LocalSettings ls = Program.LocalSettings;
            WindowState = (ls.ManiWndMaximized ? FormWindowState.Maximized : FormWindowState.Normal);
            //if (WindowState != FormWindowState.Normal)
            //{
            //    RestoreBounds = new Rectangle((ls.MainWndLeft != 0)  ? ls.MainWndLeft   : 75,
            //                                  (ls.MainWndTop != 0)   ? ls.MainWndTop    : 5,
            //                                  (ls.MainWndWidth > 0)  ? ls.MainWndWidth  : 1250,
            //                                  (ls.MainWndHeight > 0) ? ls.MainWndHeight : 750);
            //}
            //else
            {
                Width = (ls.MainWndWidth > 0) ? ls.MainWndWidth : 1250;
                Height = (ls.MainWndHeight > 0) ? ls.MainWndHeight : 750;
                Left = (ls.MainWndLeft != 0) ? ls.MainWndLeft : 75;
                Top = (ls.MainWndTop != 0) ? ls.MainWndTop : 5;
            }
            

            if (Program.CurrentBench.IsRealBench && !benchInitializationFailed)
            {
                try
                {
                    BenchControl.StateMachine.InitializeDevices();

                    //emergencyStopModelessDlg = new TBF.Forms.EmergencyStopForm();
                    //emergencyStopModelessDlg.Show();

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

                    Bridge.ActivityHandler += delegate(object sndr, UiBridge.ActivityEventArgs args)
                    {
                        if (InvokeRequired) { Invoke(new EventHandler<UiBridge.ActivityEventArgs>(OnActivity), sndr, args); }
                        else OnActivity(sndr, args);
                    };

                    Bridge.StateChangedHandler += delegate(object sndr, UiBridge.StateChangedEventArgs args)
                    {
                        if (InvokeRequired) { Invoke(new EventHandler<UiBridge.StateChangedEventArgs>(OnStateChanged), sndr, args); }
                        else OnStateChanged(sndr, args);
                    };

                    Bridge.TestProgressHandler += delegate(object sndr, UiBridge.TestProgressEventArgs args)
                    {
                        if (InvokeRequired) { Invoke(new EventHandler<UiBridge.TestProgressEventArgs>(OnTestProgress), sndr, args); }
                        else OnTestProgress(sndr, args);
                    };

                    Bridge.ProcedureSelectedHandler += delegate(object sndr, UiBridge.ProcedureSelectedEventArgs args)
                    {
                        if (InvokeRequired) { Invoke(new EventHandler<UiBridge.ProcedureSelectedEventArgs>(OnProcedureSelected), sndr, args); }
                        else OnProcedureSelected(sndr, args);
                    };
                }
                catch (Exception exc)
                {
                    benchInitializationFailed = true;
                    log.Fatal("Failed to initialize a test bench component", exc);
                    MessageBox.Show(exc.Message, Strings.Error, System.Windows.Forms.MessageBoxButtons.OK,
                                                                System.Windows.Forms.MessageBoxIcon.Exclamation);
                }
            }

            procedureComboBox.Text = Program.LocalSettings.LastProcedureName;
            ProcedureName = Program.LocalSettings.LastProcedureName;
			rightHorizSplitContainer.SplitterDistance = Program.LocalSettings.RightPaneHorizSplitterDistance;

            /// Text boxes for data input, with border and white background
            CustomStyle.Set(0, DockStyle.Fill, Color.White, BorderStyle.FixedSingle, false,
                               new System.Drawing.Font("Verdana", 10.5F, FontStyle.Regular, GraphicsUnit.Point, (byte)(238)));

            // Read only text boxes (labels), its background matches the window background

            /// Measurement
            CustomStyle.Set(1, DockStyle.Fill, Color.FromArgb(150, 180, 200), BorderStyle.None, true,
                               new System.Drawing.Font("Verdana", 10.5F, FontStyle.Regular, GraphicsUnit.Point, (byte)(238)));

            /// Not used
            CustomStyle.Set(2, DockStyle.Fill, Color.OliveDrab, BorderStyle.None, true,
                               new System.Drawing.Font("Verdana", 10.5F, FontStyle.Regular, GraphicsUnit.Point, (byte)(238)));

            /// Procedure
            CustomStyle.Set(3, DockStyle.Fill, Color.FromArgb(200, 200, 150), BorderStyle.None, true,
                               new System.Drawing.Font("Verdana", 10.5F, FontStyle.Regular, GraphicsUnit.Point, (byte)(238)));

            /// Initialize bench control user interface(s)
			/// Initialize bench control user interface(s)
			BenchControlPanel = new TBF.UiControls.BenchControlPanel();
			BenchControlPanel.BackColor = System.Drawing.Color.LightGray;
			new System.ComponentModel.ComponentResourceManager(typeof(MainWnd)).ApplyResources(BenchControlPanel, "benchControlPanel");
			BenchControlPanel.Name = "benchControlPanel";
			rightHorizSplitContainer.Panel2.Controls.Add(BenchControlPanel);
			ReloadProcedures();

            /// Select the initial tab page
			mainTabControl.SelectTab((int)MainTabPageId.Process);		 /// This is to load the 'Process screen'
			UpdateUser();
			mainTabControl.SelectTab((int)MainTabPageId.Hydraulics);
			
            if (Program.CurrentBench.IsRealBench)
            {
                if (!benchInitializationFailed)
                {
                    BenchControl.StateMachine.Start();
                    log.Info("Test bench started");
                }
                else
                {
                    BenchControlPanel.OnButtonsEtc(null, new ButtonsEtcEventArgs(TBF.UiBridge.ButtonsEtc.None));
                    MessageBox.Show(Strings.Bench_is_not_running,
                                    Strings.Warning,
                                    System.Windows.Forms.MessageBoxButtons.OK,
                                    System.Windows.Forms.MessageBoxIcon.Exclamation);
                }
            }
        }

		/// <summary>
		/// Pass any pressed keys to the Bench control panel.
		/// Note that MainWnd.KeyPreview must be set to true.
		/// </summary>
		private void MainWnd_KeyPress(object sender, KeyPressEventArgs e)
		{
			if (BenchControlPanel != null && BenchControlPanel.ProcessKey(e.KeyChar))
			{
				e.Handled = true;
			}
		}

        /// <summary>
        /// Invoked from the UiBridge to update the activity label.
        /// </summary>
        void OnActivity(object sender, UiBridge.ActivityEventArgs args)
        {
			switch (args.Cmd)
			{
				case ActivityEventArgs.Update.Activity:
					activityLabel.Text = args.Activity;
					break;
				case ActivityEventArgs.Update.Message:
					messageLabel.Text = args.Message;
					if (args.ErrorMsg) messageLabel.ForeColor = Color.Red;
					else               messageLabel.ForeColor = Color.Black;
					break;
				default:
					activityLabel.Text = args.Activity;
					messageLabel.Text = args.Message;
					if (args.ErrorMsg) messageLabel.ForeColor = Color.Red;
					else               messageLabel.ForeColor = Color.Black;
					break;
			}
        }

        /// <summary>
        /// Invoked from the UiBridge to update the current state status bar item.
        /// </summary>
        void OnStateChanged(object sender, StateChangedEventArgs args)
        {
            activityStatusLabel.Text = args.StateChangedMsg;
        }

		void OnTestProgress(object sender, UiBridge.TestProgressEventArgs args)
		{
			mainProgressBar.Value = (int)(100.499f * args.OveralProgress);
		}

        void OnProcedureSelected(object sender, UiBridge.ProcedureSelectedEventArgs args)
        {
            mainProgressBar.Value = 0;
        }

        void OnButtonsEtc(object sender, UiBridge.ButtonsEtcEventArgs args)
        {
            if (((args.Flags & ButtonsEtc.ShowBenchEmpty) != 0) ||
                ((args.Flags & ButtonsEtc.ShowBenchFilled) != 0))
            {
                return;
            }

            procedureComboBox.Enabled = ((args.Flags & UiBridge.ButtonsEtc.ProcedureCmbBoxEn) != 0);

            if (procedureComboBox.Enabled && ProceduresUpdated)
            {
                ReloadProcedures();
            }
        }

        public void UpdateUser()
        {
            userInfoStatusLabel.Text = Strings.User_ + Entities.User.CurrentUser.Name + " , ";
        }

        /// <summary>
        /// Stop the bench when program closes
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void MainWnd_FormClosed(object sender, FormClosedEventArgs e)
        {
            //BenchControl.StateMachine.Stop();
        }

		private void benchComponentsTSMItem_Click(object s, EventArgs e)  { new ComponentsManagerDlg().ShowDialog(); }
		private void benchPathsTSMItem_Click(object s, EventArgs e)		  { new PathsDlg().ShowDialog(); }
		private void benchTransitionsTSMItem_Click(object s, EventArgs e) { new TransitionsDlg().ShowDialog(); }
		private void benchMetrologyTSMItem_Click(object s, EventArgs e)   { new MetrologyDlg().ShowDialog(); }
		private void proceduresTSMItem_Click(object s, EventArgs e)		  { new ProceduresDlg().ShowDialog(); }
        private void localSettingsTSMItem_Click(object s, EventArgs e)	  { new PreferencesDlg().ShowDialog(); }
        private void databaseSettingsTSMItem_Click(object s, EventArgs e) { new BenchesDlg().ShowDialog(); }
        private void usersTSMItem_Click(object s, EventArgs e)			  { new Forms.EditUsers().ShowDialog(); }
		private void aboutTSMItem_Click(object s, EventArgs e)			  { new Forms.AboutDlg().ShowDialog(); }

		/// <summary>
		/// Read the database and re-initialize procedureComboBox items.
		/// Try to preserve the original selection.
		/// </summary>
		public void ReloadProcedures()
		{
            if (procedureComboBox.Enabled)
            {
                string oriProcName = procedureComboBox.Text;

                IList<Procedure> procedures = FluentCommon.CreateSession(Database.Procedures)
                    .CreateQuery("FROM Procedure ORDER BY ItemNr")
                    .List<Procedure>();

                procedureComboBox.Items.Clear();
                foreach (var proc in procedures) procedureComboBox.Items.Add(proc.Name);

                if (procedureComboBox.Items.Contains(oriProcName))
                {
                    procedureComboBox.Text = oriProcName;
                    ProcedureName = oriProcName;
                }
                else if (procedures.Count > 0)
                {
                    procedureComboBox.Text = procedures[0].Name;
                    ProcedureName = procedures[0].Name;
                }
                else
                {
                    procedureComboBox.Text = string.Empty;
                    ProcedureName = null;
                }

                ProceduresUpdated = false;

                BenchControlPanel.ReloadTests();
            }
            else
            {
                ProceduresUpdated = true;
            }
		}

		private void procedureComboBox_SelectedIndexChanged(object sender, EventArgs e)
		{
			ProcedureName = procedureComboBox.Text;
			BenchControlPanel.ReloadTests();
            if (CurrentProcedure != null && CurrentProcedure.Description != null)
            {
                descriptionLabel.Text = CurrentProcedure.Description;
            }
			if (CurrentProcedure != null && testProgressControls != null)
			{
				testProgressControls.ProcedureSelectedInUI(this, new UiBridge.ProcedureSelectedEventArgs(CurrentProcedure));
			}
			if (!string.IsNullOrEmpty(ProcedureName))
            {
                Program.LocalSettings.LastProcedureName = ProcedureName;
                Program.LocalSettings.Save();
            }
		}

		private void rightHorizSplitContainer_SplitterMoved(object sender, SplitterEventArgs e)
		{
			Program.LocalSettings.RightPaneHorizSplitterDistance = rightHorizSplitContainer.SplitterDistance;
			Program.LocalSettings.Save();
		}

        private void MainWnd_FormClosing(object sender, FormClosingEventArgs e)
        {
            Program.LocalSettings.ManiWndMaximized = (WindowState == FormWindowState.Maximized);
            if (WindowState == FormWindowState.Normal)
            {
                Program.LocalSettings.MainWndLeft = Location.X;
                Program.LocalSettings.MainWndTop = Location.Y;
                Program.LocalSettings.MainWndWidth = Size.Width;
                Program.LocalSettings.MainWndHeight = Size.Height;
            }
            else
            {
                /// Maximized or minimized (when restarted, minimized window is restored as normal)
                Program.LocalSettings.MainWndLeft = RestoreBounds.Left;
                Program.LocalSettings.MainWndTop = RestoreBounds.Top;
                Program.LocalSettings.MainWndWidth = RestoreBounds.Width;
                Program.LocalSettings.MainWndHeight = RestoreBounds.Height;
            }
            Program.LocalSettings.Save();

            if (DialogResult == DialogResult.None)
            {
                exitToolStripMenuItem_Click(sender, e);
            }
        }

        private void exitToolStripMenuItem_Click(object sender, EventArgs e)
        {
            bool oriEmgStopState = false;
            if (emergencyStopModelessDlg != null)
            {
                oriEmgStopState = emergencyStopModelessDlg.Visible;
                emergencyStopModelessDlg.Visible = false;
            }

            if (DialogResult.Yes == MessageBox.Show("Do you want to exit the Test Bench Framework?", "Closing the program",
                                                     MessageBoxButtons.YesNo, MessageBoxIcon.Question))
            {
                BenchControl.StateMachine.Stop();
                UiBridge.Bridge.OnEmergencyStopChanged(this, UiBridge.EmergencyStopEventArgs.State.CloseForm);
                new Forms.ClosingProgram().ShowDialog();
                DialogResult = DialogResult.OK;
                Close();
                return;
            }
            else if (e is FormClosingEventArgs)
            {
                (e as FormClosingEventArgs).Cancel = true;
            }

            if (emergencyStopModelessDlg != null) emergencyStopModelessDlg.Visible = oriEmgStopState;
        }


		private void printToolStripMenuItem_Click(object sender, EventArgs e)
		{
			TBF.Forms.PrintOrderForm dlg = new TBF.Forms.PrintOrderForm();
			if (dlg.ShowDialog() == DialogResult.OK)
			{
				string purchaseOrder = dlg.PurchaseOrder;
				string tester = dlg.Tester;

				NHibernate.ISession session = FluentCommon.CreateSession(Database.Procedures);

				IList<TestResult> testResults = session
					.CreateQuery("FROM TestResult WHERE PurchaseOrder = :purchaseOrder")
					.SetParameter("purchaseOrder", purchaseOrder)
					.List<TestResult>();

				if (testResults.Count == 0)
				{
					MessageBox.Show("No results to print", "Error", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
					return;
				}

				if (dlg.OnlyGoodResults)
				{
					/// Proceed from the end of the list so that items can be removed by index
					for (int i = testResults.Count - 1; i >= 0; i--)
					{
						// TODO: Complete
					}
				}

				if (dlg.OnlyLastResult)
				{
					/// Remove test results if there exist a later test results for the same sn
					/// Proceed from the end of the list so that items can be removed by index
					for (int i = testResults.Count - 1; i >= 0; i--)
					{
						string name = testResults[i].Name;
						int batchNr = testResults[i].BatchNr;
						foreach (var tr in testResults)
						{
							if (tr.Name == name && tr.BatchNr > batchNr)
							{
								bool allWMsAreTheSame = true;

								int cnt = Math.Min(testResults[i].Meters.Count, tr.Meters.Count);
								for (int j = 0; j < cnt; j++)
								{
									if (testResults[i].Meters[j].SerialNr != tr.Meters[j].SerialNr)
									{
										allWMsAreTheSame = false;
										break;
									}
								}

								if (allWMsAreTheSame)
								{
									/// Remove as there exists a more recent measurement with the same meters
									testResults.RemoveAt(i);
									break;
								}
							}
						}
					}
				}

				IList<Procedure> procedure = session
					.CreateQuery("FROM Procedure WHERE Name = :procedureName")
					.SetParameter("procedureName", testResults[0].ProcedureName)
					.List<Procedure>();

				if (procedure.Count != 1)
				{
					MessageBox.Show("No results to print", "Error", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
					return;
				}


				if ((testResults != null) && (testResults.Count != 0) && (testResults[0].MetersKind == Entities.MetersKind.Single))
				{
					PrintOrderDocument doc = new PrintOrderDocument(procedure[0], testResults, tester);
					doc.DefaultPageSettings.Landscape = true;
					doc.Print();
				}
				else if((testResults != null) && (testResults.Count != 0) && (testResults[0].MetersKind == Entities.MetersKind.Combined))
				{
					/// Do nothing right now
				}
				else
				{
					MessageBox.Show("No results to print", "Error", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
					return;
				}		
			}
		}
    }
}