using System;
using System.Collections.Generic;
using System.Linq;
using System.Windows.Forms;
using log4net;
using NHibernate;

using TBF.BenchControl.Generic;
using TBF.BenchControl.GenericDevices;
using TBF.Entities;
using TBF.Resources;
using TBF.UiControls;

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

		/// Used when re-scaling the dialog: 100% = 96dpi, 125% = 120dpi, 150% = 144dpi
		public readonly int Dpi;
		public const int Dpi100pct = 96;

		/// <summary>
		/// Fluent-NHibernate database session
		/// </summary>
		public ISession Session;

		/// <summary>
		/// Transition sequences to be updated by this dialog.
		/// Set by the constructor or updated by the parent after creation and before loading.
		/// </summary>
		public IList<Entities.TransitionSequence> TransitionSequences;

        /// <summary>
        /// Virtual bench sequences to be updated by this dialog.
        /// Set by the constructor or updated by the parent after creation and before loading.
        /// </summary>
        public IList<Entities.VirtualBenchSequence> VirtualBenchSequences;


		/// Auxiliary public lists used also by user controls in tab pages
		public IList<BenchControl.Generic.IComponent> TbfComponents;
		public IList<IValve> Valves;
		public IList<IRegulValve> RegulValves;


        IList<ITabWithListViewEx> seqStepsCtrls;

		public TransitionsDlg()
		{
			/// Detect display setting: 100% = 96dpi, 125% = 120dpi, 150% = 144dpi.
			Dpi = (int)this.CreateGraphics().DpiX;

			InitializeComponent();

			/// SharedDlgButtons configuration
			sharedButtons.RequiredGroupMembership = Grp.GID.Metrologists;
			sharedButtons.OptionalButtons = SharedButtons.Buttons.Add | SharedButtons.Buttons.Remove |
											SharedButtons.Buttons.Up | SharedButtons.Buttons.Down |
											SharedButtons.Buttons.NewTab | SharedButtons.Buttons.RenameTab |
											SharedButtons.Buttons.RemoveTab;
			sharedButtons.Unlocked += Unlocked;
			sharedButtons.OKClicked += okButton_Click;
			sharedButtons.CancelClicked += cancelButton_Click;
			sharedButtons.AddClicked += addButton_Click;
			sharedButtons.RemoveClicked += removeButton_Click;
			sharedButtons.UpClicked += upButton_Click;
			sharedButtons.DownClicked += downButton_Click;
			sharedButtons.NewTabClicked += newTabButton_Click;
			sharedButtons.RenameTabClicked += renameTabButton_Click;
			sharedButtons.RemoveTabClicked += removeTabButton_Click;

            seqStepsCtrls = new List<ITabWithListViewEx>();

            TransitionSequences = new List<TransitionSequence>();
            VirtualBenchSequences = new List<VirtualBenchSequence>();
        }

		void Localize()
		{
			Text = Strings.Transitions;
		}

		private void ProcedureDlg_Load(object sender, EventArgs e)
        {
            TBF.LocalSettings ls = Program.LocalSettings;
            Width  = (ls.TransitionsDlgWidth > 0)  ? ls.TransitionsDlgWidth  : 1050;
            Height = (ls.TransitionsDlgHeight > 0) ? ls.TransitionsDlgHeight : 360;
            Left   = (ls.TransitionsDlgLeft != 0)  ? ls.TransitionsDlgLeft   : 150;
            Top    = (ls.TransitionsDlgTop != 0)   ? ls.TransitionsDlgTop    : 150;

            /// Open the database
			Session = FluentCommon.CreateSession(Database.Procedures);

            /// Prepare a list of components and a list of all valves in the test bench
            TbfComponents = BenchControl.TbfComponents.LoadComponentsFromDB(Session);
            Valves = BenchControl.GenericDevices.ValveBase.MasterValves(TbfComponents);
            RegulValves = new List<IRegulValve>();
            foreach (var cmpnt in TbfComponents)
            {
                if (cmpnt is IRegulValve) RegulValves.Add(cmpnt as IRegulValve);
            }

            /// Load the sequences
            TransitionSequences = Session.CreateQuery("FROM TransitionSequence ORDER BY ItemNr")
								  .List<Entities.TransitionSequence>();

            VirtualBenchSequences = Session.CreateQuery("FROM VirtualBenchSequence ORDER BY ItemNr")
                                    .List<Entities.VirtualBenchSequence>();

			/// Create a tab with sequence steps for each sequence ordered by ItemNr.
            /// Note: Each sequence (in both sequences together) has a unique ItemNr (0 .. N-1)
            for (int i = 0; i < TransitionSequences.Count + VirtualBenchSequences.Count; i++)
            {
                bool skip = false;
                foreach (var transSeq in TransitionSequences)
                {
                    if (transSeq.ItemNr == i)
                    {
                        AddTransitionSeqTab(transSeq);
                        skip = true;
                        continue;
                    }
                }
                if (skip) continue;
                foreach (var vBenchSeq in VirtualBenchSequences)
                {
                    if (vBenchSeq.ItemNr == i)
                    {
                        AddVirtualBenchSeqTab(vBenchSeq);
                        continue;
                    }
                }
            }

            /// Now refresh the content of the dialog
			RefreshAllTabs();
        }

		void AddTransitionSeqTab(TransitionSequence sequence)
		{
			TabPage nwTab = new TabPage(sequence.Name);
			TransitionStepsCtrl newCtrl = new TransitionStepsCtrl();
            seqStepsCtrls.Add(newCtrl);
			nwTab.Controls.Add(newCtrl);
			this.tabControl.TabPages.Add(nwTab);
			newCtrl.Initialize(sequence, this, this.tabControl.TabPages[this.tabControl.TabPages.Count - 1]);
		}

        void AddVirtualBenchSeqTab(VirtualBenchSequence sequence)
        {
            TabPage nwTab = new TabPage(sequence.Name);
            VirtualBenchStepsCtrl newCtrl = new VirtualBenchStepsCtrl();
            seqStepsCtrls.Add(newCtrl);
            nwTab.Controls.Add(newCtrl);
            this.tabControl.TabPages.Add(nwTab);
            newCtrl.Initialize(sequence, this, this.tabControl.TabPages[this.tabControl.TabPages.Count - 1]);
        }

        void RefreshAllTabs()
        {
            foreach (var ctrl in seqStepsCtrls) (ctrl as ListViewEx).Refresh();
        }

		private void Unlocked(object sender, EventArgs e)
		{
            foreach (var ctrl in seqStepsCtrls) ctrl.Unlock();
        }

		private void newTabButton_Click(object sender, EventArgs e)
		{
			int tabId = TransitionSequences.Count + VirtualBenchSequences.Count;
			Forms.TabNameDlg dlg = new Forms.TabNameDlg();
			dlg.TabNameLabel = Strings.New_transition_name;
			dlg.TabName = "Tr1";
			dlg.ShowDialog();
            if (dlg.IsVirtualBenchSeq)
            {
                VirtualBenchSequence sequence = new VirtualBenchSequence(dlg.TabName, tabId);
                VirtualBenchSequences.Add(sequence);
                AddVirtualBenchSeqTab(sequence);
                seqStepsCtrls[tabId].Unlock();
            }
            else
            {
                TransitionSequence sequence = new TransitionSequence(dlg.TabName, tabId);
                TransitionSequences.Add(sequence);
                AddTransitionSeqTab(sequence);
                seqStepsCtrls[tabId].Unlock();
            }
            tabControl.SelectTab(tabId);
		}

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

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

		private void okButton_Click(object sender, EventArgs e)
		{
            if (seqStepsCtrls.Count > slctdTab) seqStepsCtrls[slctdTab].OkBtnClicked();

			using (var transaction = Session.BeginTransaction())
			{
				foreach (var transSeq in TransitionSequences) Session.SaveOrUpdate(transSeq);
                foreach (var vBnchSeq in VirtualBenchSequences) Session.SaveOrUpdate(vBnchSeq);

                try { transaction.Commit(); }
                catch { log.Error("Update of sequences in the database failed"); }
			}

            Program.LocalSettings.TransitionsDlgLeft = Location.X;
            Program.LocalSettings.TransitionsDlgTop = Location.Y;
            Program.LocalSettings.TransitionsDlgWidth = Size.Width;
            Program.LocalSettings.TransitionsDlgHeight = Size.Height;
            Program.LocalSettings.Save();

			DialogResult = DialogResult.OK;
			Close();
			return;
		}

		private void cancelButton_Click(object sender, EventArgs e)
		{
            Program.LocalSettings.TransitionsDlgLeft = Location.X;
            Program.LocalSettings.TransitionsDlgTop = Location.Y;
            Program.LocalSettings.TransitionsDlgWidth = Size.Width;
            Program.LocalSettings.TransitionsDlgHeight = Size.Height;
            Program.LocalSettings.Save();

            DialogResult = DialogResult.Cancel;
			Close();
			return;
		}

		int slctdTab;

        private void tabControl_SelectedIndexChanged(object sender, EventArgs e)
        {
            if (seqStepsCtrls.Count > slctdTab)
			{
                seqStepsCtrls[slctdTab].OkBtnClicked();
			}
            slctdTab = tabControl.SelectedIndex;
			sharedButtons.SetEnabled(SharedButtons.Buttons.Add, true);
			sharedButtons.DisableButtons(SharedButtons.Buttons.Remove);
            RefreshAllTabs();
        }

        private void addButton_Click(object sender, EventArgs e)
        {
            if (seqStepsCtrls.Count > slctdTab) seqStepsCtrls[slctdTab].AddOne();
		}

        private void removeButton_Click(object sender, EventArgs e)
        {
            if (seqStepsCtrls.Count > slctdTab) seqStepsCtrls[slctdTab].RemoveSelected();
		}

		private void upButton_Click(object sender, EventArgs e)
		{
            if (seqStepsCtrls.Count > slctdTab) seqStepsCtrls[slctdTab].MoveUpSelected();
		}

		private void downButton_Click(object sender, EventArgs e)
		{
            if (seqStepsCtrls.Count > slctdTab) seqStepsCtrls[slctdTab].MoveDownSelected();
		}

		public void UpdateButtonStates(SharedButtons.SelectedItemPos selectedItemPos)
		{
			if (selectedItemPos == SharedButtons.SelectedItemPos.None)
			{
				sharedButtons.DisableButtons(SharedButtons.Buttons.Remove | SharedButtons.Buttons.Up | SharedButtons.Buttons.Down);
			}
			else if (selectedItemPos == SharedButtons.SelectedItemPos.First)
			{
				sharedButtons.EnableButtons(SharedButtons.Buttons.Remove | SharedButtons.Buttons.Down);
				sharedButtons.DisableButtons(SharedButtons.Buttons.Up);
			}
			else if (selectedItemPos == SharedButtons.SelectedItemPos.Last)
			{
				sharedButtons.EnableButtons(SharedButtons.Buttons.Remove | SharedButtons.Buttons.Up);
				sharedButtons.DisableButtons(SharedButtons.Buttons.Down);
			}
			else if (selectedItemPos == SharedButtons.SelectedItemPos.FirstAndLast)
			{
				sharedButtons.EnableButtons(SharedButtons.Buttons.Remove);
				sharedButtons.DisableButtons(SharedButtons.Buttons.Up | SharedButtons.Buttons.Down);
			}
			else
			{
				sharedButtons.EnableButtons(SharedButtons.Buttons.Remove | SharedButtons.Buttons.Up | SharedButtons.Buttons.Down);
			}
		}

		private void purgeStartCtrl_SelectedIndexChanged(object sender, EventArgs e)
		{
			SelectedIndexChanged(sender, e);
		}

		private void purgeEndCtrl_SelectedIndexChanged(object sender, EventArgs e)
		{
			SelectedIndexChanged(sender, e);
		}

		/// <summary>
		/// Common part for three xxxListViewEx_SelectedIndexChanged event handlers
		/// </summary>
		/// <param name="listViewEx"></param>
		void SelectedIndexChanged(object sender, EventArgs e)
		{
			ListViewEx listViewEx = sender as ListViewEx;
			if (listViewEx.SelectedItems.Count != 1)
			{
				UpdateButtonStates(SharedButtons.SelectedItemPos.None);
			}
			else if (listViewEx.Items.Count == 1)
			{
				UpdateButtonStates(SharedButtons.SelectedItemPos.FirstAndLast);
			}
			else if (listViewEx.SelectedIndices[0] == 0)
			{
				UpdateButtonStates(SharedButtons.SelectedItemPos.First);
			}
			else if (listViewEx.SelectedIndices[0] == (listViewEx.Items.Count - 1))
			{
				UpdateButtonStates(SharedButtons.SelectedItemPos.Last);
			}
			else
			{
				UpdateButtonStates(SharedButtons.SelectedItemPos.Middle);
			}
		}
	}
}