///
/// Copyright (c) 2020-2023 Sensus Slovensko a.s.
///
using System;
using System.Collections.Generic;
using System.IO;
using System.Text;
using System.Windows.Forms;
using NHibernate;
using log4net;
using Common;
using Config.Entities;
using TBF.Rig.GenericDevices;
using TBF.Resources;
using TBF.UI.Shared;

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

        ProceduresDlg parent;       /// parent form
        Control parentControl;      /// parent control (split container)

        /// Database session from the parent form
        public ISession Session { get { return parent.Session; } }

        /// <summary>
        /// List of all active procedures
        /// </summary>
        public IList<Procedure> AllProcedures;

        /// <summary>
        /// List of procedures satisfying filter criteria
        /// </summary>
        public IList<Procedure> Procedures;

        /// <summary>
        /// List of removed items that have to be removed  from the database
        /// when completed with OK.
        /// </summary>
        public IList<Procedure> ToBeRemovedProcedures;

        /// <summary>
        /// true = editing was unlocked
        /// </summary>
        public bool Unlocked { get { return unlocked; } }	/// read only
        bool unlocked;

        string selectedProfile;
        float selectedDN;
        float selectedQ3;
        string selectedMClass;
        string selectedProducer;


		/// <summary>
		/// ListViewEx columns
		/// </summary>
		enum Column
		{
            ItemNr,
			Name,
            More,
			Count
		}

		Control[] editors;

        IWaterMeter waterMeterCmpnt;
        IErrorFlags errorFlagsCmpnt;

		public ProceduresCtrl()
		{
            InitializeComponent();

            waterMeterCmpnt = null;
            errorFlagsCmpnt = null;
            ToBeRemovedProcedures = new List<Procedure>();

            /// Profile
            selectedProfile = null;
            ComboBox cb = profileComboBox;
            cb.Items.Add(Strings.any);
            cb.Items.Add(Strings.no_profile);
            cb.Items.Add(Strings.any_profile);
            cb.Text = cb.Items[0].ToString();

            /// DN
            selectedDN = 0;
            cb = dnComboBox;
            cb.Items.Add(Strings.any);
            cb.Text = cb.Items[0].ToString();

            /// Q3 / Qn
            selectedQ3 = 0;
            cb = q3ComboBox;
            cb.Items.Add(Strings.any);
            cb.Text = cb.Items[0].ToString();

            /// Metrological class
            selectedMClass = null;
            cb = mclassComboBox;
            cb.Items.Add(Strings.any);
            cb.Text = cb.Items[0].ToString();

            /// Producer
            selectedProducer = null;
            cb = producerComboBox;
            cb.Items.Add(Strings.any);
            cb.Text = cb.Items[0].ToString();

            moreContent = MoreContent.Description;
        }

		public void Initialize(ProceduresDlg parent, Control parentControl)
		{
            if (parent == null) return;
            
            this.parent = parent;
			this.parentControl = parentControl;

			/// ListViewEx columns
			TBF.LocalSettings ls = Program.LocalSettings;
            listViewEx.Columns.Add(Strings.Nr, (ls.ProceduresColumnCount > 0) ? ls.ProceduresColumnWidths[0] : (30 * parent.Dpi / Constants.Dpi100pct));
            listViewEx.Columns.Add(Strings.Name, (ls.ProceduresColumnCount > 1) ? ls.ProceduresColumnWidths[1] : (100 * parent.Dpi / Constants.Dpi100pct));
            listViewEx.Columns.Add(Strings.DescriptionColHdr, (ls.ProceduresColumnCount > 2) ? ls.ProceduresColumnWidths[2] : (500 * parent.Dpi / Constants.Dpi100pct));

			editors = new Control[(int)Column.Count];
			///				
            editors[(int)Column.ItemNr] = new TextBox();		/// ItemNr
            editors[(int)Column.Name] = new TextBox();			/// Name
            editors[(int)Column.More] = null;
            ///
            for (int i = 0; i < editors.Length; i++)
            {
                if (editors[i] != null)
                {
                    editors[i].Visible = false;
                    parent.Controls.Add(editors[i]);
                }
            }

			ReloadAndRedrawAll();
		}

        public void Unlock()
        {
            unlocked = true;

            if (listViewEx.SelectedItems.Count == 1)
            {
                int ix = listViewEx.SelectedIndices[0];
                Focus();
                listViewEx.Items[ix].Selected = true;
                listViewEx.Items[ix].EnsureVisible();
            }
        }

        bool ReloadProcedures()
        {
            bool isFirstTime = (AllProcedures == null);

            try
            {
                if (isFirstTime)
                {
                    /// Find WaterMeter and ErrorFlags components, this is done just once when AllProcedures == null
                    foreach (var cmpnt in TBF.Rig.TbfComponents.LoadComponentsFromDB(Session))
                    {
                        if (waterMeterCmpnt == null && cmpnt is IWaterMeter) waterMeterCmpnt = cmpnt as IWaterMeter;
                        if (errorFlagsCmpnt == null && cmpnt is IErrorFlags) errorFlagsCmpnt = cmpnt as IErrorFlags;
                    }
                }

                /// (Re)Load all procedures unconditionally
                AllProcedures = Session.QueryOver<Procedure>()
                                       .Where(x => (x.ProcedureState == ProcedureState.Active))
                                       .OrderBy(x => x.ItemNr).Asc
                                       .List();

                if (waterMeterCmpnt != null)
                {
                    foreach (var proc in AllProcedures)
                    {
                        IParamsProvider waterMeterParams = waterMeterCmpnt.Cfg.GetUIProcParamsProvider(proc);
                        TBF.Rig.WaterMeters.WaterMeter.ProcParams wmParams = waterMeterParams as TBF.Rig.WaterMeters.WaterMeter.ProcParams;
                        if (wmParams != null)
                        {
                            proc.DN = wmParams.DN;
                            proc.Qn = wmParams.Qn;
                            proc.MClass = wmParams.MetrologicalClass;
                            proc.Producer = wmParams.Producer;

                            if (isFirstTime)
                            {
                                if (!string.IsNullOrEmpty(proc.AltProcName) && !profileComboBox.Items.Contains(proc.AltProcName))
                                {
                                    profileComboBox.Items.Add(proc.AltProcName);
                                }
                                if (!dnComboBox.Items.Contains(wmParams.DN.ToString())) dnComboBox.Items.Add(wmParams.DN.ToString());
                                if (!q3ComboBox.Items.Contains(wmParams.Qn.ToString())) q3ComboBox.Items.Add(wmParams.Qn.ToString());
                                if (!mclassComboBox.Items.Contains(wmParams.MetrologicalClass)) mclassComboBox.Items.Add(wmParams.MetrologicalClass);
                                if (!producerComboBox.Items.Contains(wmParams.Producer)) producerComboBox.Items.Add(wmParams.Producer);
                            }
                        }
                    }
                }

                return true;    /// Reloading successful
            }
            catch (Exception exc)
            {
                log.ErrorFormat("Loading Procedures from DB failed: {0}", exc.Message);
                AllProcedures = new List<Procedure>();
                return false;
            }
        }

		void ReloadAndRedrawAll()
		{
            if (ReloadProcedures())
            {
                RedrawAll();
            }
        }

        void RedrawAll()
        {
            Procedures = new List<Procedure>();

            /// Select procedures satisfying filter criteria: AllProcedures -> Procedures
            if (AllProcedures != null)
            {
                foreach (var proc in AllProcedures)
                {
                    if ((selectedProfile == null ||
                         (selectedProfile == Strings.no_profile && string.IsNullOrEmpty(proc.AltProcName)) ||
                         (selectedProfile == Strings.any_profile && !string.IsNullOrEmpty(proc.AltProcName)) ||
                         selectedProfile == proc.AltProcName) &&
                        (selectedDN == 0 || selectedDN == proc.DN) &&
                        (selectedQ3 == 0 || selectedQ3 == proc.Qn) &&
                        (selectedMClass == null || selectedMClass == proc.MClass) &&
                        (selectedProducer == null || selectedProducer == proc.Producer))
                    {
                        Procedures.Add(proc);
                    }
                }
            }

            listViewEx.Items.Clear();
            foreach (var procedure in Procedures) DrawOne(procedure);
        }

        void DrawOne(Procedure procedure)
        {
            ListViewItem lvi = new ListViewItem((procedure.ItemNr + 1).ToString());
            lvi.Tag = procedure;
            lvi.SubItems.Add(procedure.Name);
            lvi.SubItems.Add(GetMoreContent(procedure, moreContent));

            listViewEx.Items.Add(lvi);
        }

		/// <summary>
		/// Update the entities and save them to the database
		/// </summary>
		public void OkBtnClicked()
		{
            if (Session != null && Session.IsOpen)
            {
                using (ITransaction transaction = Session.BeginTransaction())
                {
                    try
                    {
                        foreach (var entity in ToBeRemovedProcedures) Session.Delete(entity);
                        ToBeRemovedProcedures.Clear();

                        int itemNr = 0;
                        foreach (var proc in AllProcedures)
                        {
                            (proc as Procedure).ItemNr = itemNr++;
                            Session.SaveOrUpdate(proc);
                        }

                        transaction.Commit();
                        Session.Flush();
                    }
                    catch (Exception exc)
                    {
                        transaction.Rollback();
                        log.ErrorFormat("Cannot save changes to DB: {0}", exc.Message);
                        MessageBox.Show(Strings.Cannot_save_changes, Strings.Error, MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                    }
                }
            }

            SaveUISettings();

			Program.MainWnd.ReloadProcedureComboBoxItems();
		}

        public void CancelBtnClicked()
        {
        }


        /// <summary>
        /// 'Add' button was clicked.
        /// </summary>
        public void AddOne()
        {
            /// Find an unused procedure name
            string newName;
            for (int nameId = 1; true; nameId++)
            {
                newName = Strings.New_procedure_name + nameId.ToString();
                bool notUsed = true;
                foreach (var t in Procedures) if (t.Name.ToLower().Equals(newName.ToLower())) notUsed = false;
                if (notUsed) break;
            }

            Procedure newProcedure = new Procedure(newName, Procedures.Count);
            newProcedure.ItemNr = AllProcedures.Count;
            newProcedure.ProcedureState = ProcedureState.Active;
            newProcedure.Revision = 1;
            newProcedure.PredecessorId = 0;
            newProcedure.ObtainedByCopy = false;
            newProcedure.CreationUser = Users.CurrentUser.UserName();
            newProcedure.CreationTime = DateTime.Now;

            if (new ProcedureDlg(Session, newProcedure, GetUsedNames(false), ProcedureDlg.Mode.Unlocked, parent).ShowDialog() == DialogResult.OK)
            {
                /// TODO: Make name uniqueness test
                parent.Unlock();

                using (var transaction = Session.BeginTransaction())
                {
                    try
                    {
                        newProcedure.LastChgUser = Users.CurrentUser.UserName();
                        newProcedure.LastChgTime = DateTime.Now;

                        DoAddOne(newProcedure);
                        Session.SaveOrUpdate(newProcedure);
                        transaction.Commit();

                        MessageBox.Show(string.Format(Strings.Procedure_0_added, newProcedure.Name),
                                        Strings.Confirmation,
                                        MessageBoxButtons.OK,
                                        MessageBoxIcon.Information);
                    }
                    catch (Exception exc)
                    {
                        transaction.Rollback();
                        log.ErrorFormat("Could not save procedure '{0}':", newProcedure.Name);
                        log.ErrorFormat("Exception: {0}", exc.Message);
                        if (exc.InnerException != null) log.ErrorFormat("InnerException: {0}", exc.InnerException.Message);
                    }
                }
            }
        }

        /// <summary>
        /// Adds an item to the ListView and at the end of the list.
        /// Focuses onto the added item.
        /// </summary>
        public void DoAddOne(Procedure procedure)
        {
            Procedures.Add(procedure);
            AllProcedures.Add(procedure);
            DrawOne(procedure);

            Focus();
            listViewEx.SelectedItems.Clear();
            listViewEx.Items[listViewEx.Items.Count - 1].Selected = true;
            listViewEx.Items[listViewEx.Items.Count - 1].EnsureVisible();
        }


        /// <summary>
        /// 'Remove' button was clicked.
        /// </summary>
        public void RemoveSelected()
        {
            if (MessageBox.Show(Strings.Do_you_want_to_delete_the_procedure,
                                Strings.Question, MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)
            {
                bool lastOneRemoved = DoRemoveSelected();

                if (lastOneRemoved && parent != null)
                {
                    parent.UpdateButtonStates(SharedButtons.SelectedItemPos.None);
                }

                /// Update the database
                using (ITransaction transaction = Session.BeginTransaction())
                {
                    try
                    {
                        foreach (var entity in ToBeRemovedProcedures) Session.Delete(entity);
                        ToBeRemovedProcedures.Clear();

                        int itemNr = 0;
                        foreach (var entity in Procedures)
                        {
                            (entity as Procedure).ItemNr = itemNr++;
                            Session.SaveOrUpdate(entity);
                        }

                        transaction.Commit();
                        Session.Flush();
                    }
                    catch (Exception exc)
                    {
                        transaction.Rollback();
                        log.ErrorFormat("Cannot save changes to DB: {0}", exc.Message);
                        MessageBox.Show(Strings.Cannot_save_changes, Strings.Error, MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                    }
                }
            }
        }

        /// <summary>
        /// Removes an item from the ListView and from the list itself.
        /// Adds it on ToBeRemovedItems list.
        /// Focuses on the next item.
        /// </summary>
        /// <returns>true when the last item was removed and 'Remove' button should be disabled</returns>
        public bool DoRemoveSelected()
        {
            if (listViewEx.SelectedItems.Count != 1) return false;

            int removeItemNr = listViewEx.SelectedIndices[0];
            if (removeItemNr < 0) return false;

            Procedure selectedItem = (Procedure)listViewEx.SelectedItems[0].Tag;

            /// Add to ToBeRemovedProcedures if necessary
            if (selectedItem.Id != 0)
            {
                /// Procedure to be removed was loaded from the DB (was not recenlu created)
                ToBeRemovedProcedures.Add(selectedItem);
            }

            /// Remove from AllProcedures
            AllProcedures.Remove(selectedItem);

            /// Remove
            Procedures.RemoveAt(removeItemNr);
            for (int i = removeItemNr; i < Procedures.Count; i++)
            {
                Procedures[i].ItemNr--;
            }

            RedrawAll();

            if (removeItemNr < listViewEx.Items.Count)
            {
                Focus();
                listViewEx.Items[removeItemNr].Selected = true;
                listViewEx.Items[removeItemNr].EnsureVisible();
                return false;
            }
            else
            {
                return true;
            }
        }

        public void MoveUpSelected()
        {
            if (listViewEx.SelectedItems.Count != 1) return;
            if (Procedures.Count != AllProcedures.Count) return;

            int ix = listViewEx.SelectedIndices[0];
            if (ix <= 0 || ix >= Procedures.Count) return;

            Procedure proc1 = (Procedure)(listViewEx.Items[ix - 1].Tag);
            Procedure proc2 = (Procedure)(listViewEx.Items[ix].Tag);
            proc1.ItemNr++;
            proc2.ItemNr--;
            Procedures.RemoveAt(ix);
            Procedures.Insert(ix - 1, proc2);
            AllProcedures.RemoveAt(ix);
            AllProcedures.Insert(ix - 1, proc2);

            RedrawAll();

            listViewEx.Focus();
            listViewEx.Items[ix - 1].Selected = true;
            listViewEx.Items[ix - 1].EnsureVisible();
        }

        public void MoveDownSelected()
        {
            if (listViewEx.SelectedItems.Count != 1) return;
            if (Procedures.Count != AllProcedures.Count) return;

            int ix = listViewEx.SelectedIndices[0];
            if (ix < 0 || ix >= Procedures.Count - 1) return;

            Procedure proc1 = (Procedure)(listViewEx.Items[ix].Tag);
            Procedure proc2 = (Procedure)(listViewEx.Items[ix + 1].Tag);
            proc1.ItemNr++;
            proc2.ItemNr--;
            Procedures.RemoveAt(ix + 1);
            Procedures.Insert(ix, proc2);
            AllProcedures.RemoveAt(ix + 1);
            AllProcedures.Insert(ix, proc2);

            RedrawAll();

            listViewEx.Focus();
            listViewEx.Items[ix + 1].Selected = true;
            listViewEx.Items[ix + 1].EnsureVisible();
        }


        void SaveUISettings()
        {
            LocalSettings ls = Program.LocalSettings;

            /// Compare list view column widths with the saved ones
            bool anyColumnDiffers = false;
            if (listViewEx.Columns.Count != ls.ProceduresColumnCount)
            {
                anyColumnDiffers = true;
            }
            else
            {
                for (int i = 0; i < listViewEx.Columns.Count; i++)
                {
                    if (listViewEx.Columns[i].Width != ls.ProceduresColumnWidths[i]) { anyColumnDiffers = true; break; }
                }
            }

            if (anyColumnDiffers)
            {
                /// Update column widths
                ls.ProceduresColumnWidths = new int[listViewEx.Columns.Count];
                for (int i = 0; i < listViewEx.Columns.Count; i++)
                {
                    ls.ProceduresColumnWidths[i] = listViewEx.Columns[i].Width;
                }

                ls.Save();
            }
        }

        private void listViewEx_MouseDoubleClick(object sender, MouseEventArgs e)
        {
            editButton_Click(sender, e);
        }
        /// 
		public void editButton_Click(object sender, EventArgs e)
		{
            if (listViewEx.SelectedItems.Count != 1) return;

            Procedure originalProcedure = listViewEx.SelectedItems[0].Tag as Procedure;
			Procedure modifiedProcedure = originalProcedure.Clone();

			modifiedProcedure.Revision = originalProcedure.Revision + 1;
			modifiedProcedure.ObtainedByCopy = false;

			IList<string> usedNames = GetUsedNames(false);
			usedNames.Remove(originalProcedure.Name.ToLower());		/// Allow original procedure name
			///
            if (new ProcedureDlg(Session, modifiedProcedure, usedNames, ProcedureDlg.Mode.Locked, parent).ShowDialog() == DialogResult.OK)
			{
				parent.Unlock();

				using (var transaction = Session.BeginTransaction())
				{
					try
					{
						originalProcedure.ProcedureState = ProcedureState.History;
                        modifiedProcedure.LastChgUser = Users.CurrentUser.UserName();
						modifiedProcedure.LastChgTime = DateTime.Now;

						Session.SaveOrUpdate(originalProcedure);
						Session.SaveOrUpdate(modifiedProcedure);
						transaction.Commit();

                        listViewEx.SelectedItems[0].Tag = modifiedProcedure;
						MessageBox.Show(string.Format(Strings.Procedure_0_modified, string.Format(" {0}  '{1}' ", modifiedProcedure.ItemNr + 1, modifiedProcedure.Name)),
										Strings.Confirmation,
										MessageBoxButtons.OK,
										MessageBoxIcon.Information);
					}
					catch (Exception exc)
					{
                        log.ErrorFormat("Could not save procedure '{0}':", modifiedProcedure.Name);
                        log.ErrorFormat("Exception: {0}", exc.Message);
                        if (exc.InnerException != null) log.ErrorFormat("InnerException: {0}", exc.InnerException.Message);
                        transaction.Rollback();
					}
				}
				Session.Flush();
			}

			ReloadAndRedrawAll();
		}

		public void copyButton_Click(object sender, EventArgs e)
		{
            if (listViewEx.SelectedItems.Count != 1) return;

            Procedure selectedProcedure = (Procedure)listViewEx.SelectedItems[0].Tag;

			/// Make a copy of the selected procedure
			Procedure newProcedure = selectedProcedure.Clone();

			newProcedure.Name = selectedProcedure.Name + Strings.New_name_copy;
			newProcedure.ItemNr = AllProcedures.Count;
			newProcedure.ProcedureState = ProcedureState.Active;
			newProcedure.Revision = 1;
			newProcedure.PredecessorId = selectedProcedure.Id;
			newProcedure.ObtainedByCopy = true;
            newProcedure.CreationUser = Users.CurrentUser.UserName();
			newProcedure.CreationTime = DateTime.Now;
            newProcedure.Protected = false;

            if ((new ProcedureDlg(Session, newProcedure, GetUsedNames(false), ProcedureDlg.Mode.Unlocked, parent)).ShowDialog() == DialogResult.OK)
			{
				/// TODO: Make name uniqueness test
				parent.Unlock();

				using (var transaction = Session.BeginTransaction())
				{
                    newProcedure.LastChgUser = Users.CurrentUser.UserName();
					newProcedure.LastChgTime = DateTime.Now;

					DoAddOne(newProcedure);
					Session.SaveOrUpdate(newProcedure);
					transaction.Commit();

					MessageBox.Show(string.Format(Strings.Procedure_0_added, newProcedure.Name),
									Strings.Confirmation,
									MessageBoxButtons.OK,
									MessageBoxIcon.Information);
				}
			}
		}

        public void exportButton_Click(object sender, EventArgs e)
        {
            if (listViewEx.SelectedItems.Count != 1) return;

            Procedure selectedProcedure = (Procedure)listViewEx.SelectedItems[0].Tag;

            SaveFileDialog dlg = new SaveFileDialog();
            if (dlg.ShowDialog() == DialogResult.OK)
            {
                selectedProcedure.Export(new StreamWriter(dlg.FileName, false, System.Text.Encoding.UTF8));
            }
        }

        public void importButton_Click(object sender, EventArgs e)
        {
            OpenFileDialog dlg = new OpenFileDialog();

            if (dlg.ShowDialog() != DialogResult.OK) return;

            /// Import a procedure from a file
            Procedure newProcedure = Procedure.Import(new StreamReader(dlg.FileName, System.Text.Encoding.UTF8));

            newProcedure.Name = newProcedure.Name + " imported";
            newProcedure.ItemNr = Procedures.Count;
            newProcedure.ProcedureState = ProcedureState.Active;
            newProcedure.Revision = 1;
            newProcedure.PredecessorId = 0;
            newProcedure.ObtainedByCopy = false;
            newProcedure.CreationUser = Users.CurrentUser.UserName();
            newProcedure.CreationTime = DateTime.Now;

            if ((new ProcedureDlg(Session, newProcedure, GetUsedNames(false), ProcedureDlg.Mode.Unlocked, parent)).ShowDialog() == DialogResult.OK)
            {
                /// TODO: Make name uniqueness test
                parent.Unlock();

                using (var transaction = Session.BeginTransaction())
                {
                    newProcedure.LastChgUser = Users.CurrentUser.UserName();
                    newProcedure.LastChgTime = DateTime.Now;

                    DoAddOne(newProcedure);
                    Session.SaveOrUpdate(newProcedure);
                    transaction.Commit();

                    MessageBox.Show(string.Format(Strings.Procedure_0_added, newProcedure.Name),
                                    Strings.Confirmation,
                                    MessageBoxButtons.OK,
                                    MessageBoxIcon.Information);
                }
            }
        }

        public void compareButton_Click(object sender, EventArgs e)
        {
            if (listViewEx.SelectedItems.Count != 1) return;

            Procedure selectedProcedure = (Procedure)listViewEx.SelectedItems[0].Tag;

            OpenFileDialog dlg = new OpenFileDialog();
            if (dlg.ShowDialog() == DialogResult.OK)
            {
                string diff = selectedProcedure.Compare(new StreamReader(dlg.FileName, System.Text.Encoding.UTF8));
                if (!string.IsNullOrEmpty(diff))
                {
                    MessageBox.Show(diff, "Differences", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                }
                else
                {
                    MessageBox.Show("No differences found", "Info", MessageBoxButtons.OK, MessageBoxIcon.Information);
                }
            }
        }

        public void CreateFromProfile()
        {
            IList<Profile> profiles;
            IList<FeedingPath> fPaths;
            IList<BenchPath> bPaths;
            IList<OutputPath> oPaths;

            try
            {
                profiles = Session.QueryOver<Profile>()
                                  .OrderBy(x => x.ItemNr).Asc
                                  .List();
                fPaths = Session.QueryOver<FeedingPath>().OrderBy(x => x.ItemNr).Asc.List();
                bPaths = Session.QueryOver<BenchPath>().OrderBy(x => x.ItemNr).Asc.List();
                oPaths = Session.QueryOver<OutputPath>().OrderBy(x => x.ItemNr).Asc.List();
            }
            catch (Exception)
            {
                log.Error("Reading Profiles failed");
                MessageBox.Show("Reading Profiles failed");
                return;
            }

            TestWizard.TestProfileSelection dlg = new TestWizard.TestProfileSelection(profiles, fPaths, bPaths, oPaths);
            if (dlg.ShowDialog() != DialogResult.OK) return;

            /// Find an unused procedure name
            string newName;
            for (int nameId = 1; true; nameId++)
            {
                newName = Strings.New_procedure_name + nameId.ToString();
                bool notUsed = true;
                foreach (var t in Procedures) if (t.Name.ToLower().Equals(newName.ToLower())) notUsed = false;
                if (notUsed) break;
            }

            ProfileType pt = dlg.SelectedProfile.ProfileType;

            Procedure newProcedure = new Procedure(newName, Procedures.Count);
            Medium medium = (pt == ProfileType.QnClassHotWater) ? Medium.HotWater : Medium.ColdWater;
            IList<IParamsProvider> errorFlagsParamsOfCreatedTests = new List<IParamsProvider>();
            IList<IParamsProvider> waterMeterParamsOfNewProcedure = new List<IParamsProvider>();

            IList<Component> cmpntEntities = Session.QueryOver<Component>()
                                                    .OrderBy(x => x.ItemNr).Asc
                		                            .List<Component>();

            IList<Rig.Generic.IComponent> components = Rig.TbfComponents.LoadComponentsFromDB(Session);
            foreach (var cmptn in components)
            {
                if (cmptn.ClassName == "WaterMeter")
                {
                    IParamsProvider waterMeterParams = cmptn.Cfg.GetUIProcParamsProvider(newProcedure);

                    TBF.Rig.WaterMeters.WaterMeter.ProcParams wmParams = waterMeterParams as TBF.Rig.WaterMeters.WaterMeter.ProcParams;
                    if (wmParams != null)
                    {
                        wmParams.Qnames = Common.Utils.ProfileType2FlowNames(pt);
                        wmParams.Qmax = (pt == ProfileType.Manual) ? 0 : Formulas.GetQ4Qmax(dlg.Qn, dlg.MetroClass, medium);
                        wmParams.Qn   = dlg.Qn;
                        wmParams.Qt   = (pt == ProfileType.Manual) ? 0 : (pt == ProfileType.QpQi) ? (0.1 * dlg.Qn) : Formulas.GetQ2Qt(dlg.Qn, dlg.MetroClass, medium);
                        wmParams.Qmin = (pt == ProfileType.Manual) ? 0 : (pt == ProfileType.QpQi) ? dlg.Qn / dlg.QpQiRatio : Formulas.GetQ1Qmin(dlg.Qn, dlg.MetroClass, medium);
                        wmParams.MetrologicalClass = dlg.MetroClass;
                        wmParams.WaterTemp = medium;
                    }

                    waterMeterParamsOfNewProcedure.Add(waterMeterParams);
                }
            }

            for (int i = 0; i < dlg.SelectedTests.Count; i++ )
            {
                Test test = dlg.SelectedTests[i];
                test.Procedure = newProcedure;
                newProcedure.Tests.Add(test);

                if (errorFlagsCmpnt != null)
                {
                    IParamsProvider errorFlagsParams = errorFlagsCmpnt.Cfg.GetUITestParamsProvider(test);

                    TBF.Rig.Various.ErrorFlags.TestParams eFlagParams = errorFlagsParams as TBF.Rig.Various.ErrorFlags.TestParams;
                    if (eFlagParams != null)
                    {
                        eFlagParams.E1            = dlg.SelectedProfile.Tests[i].E1;
                        eFlagParams.E2            = dlg.SelectedProfile.Tests[i].E2;
                        eFlagParams.E3            = dlg.SelectedProfile.Tests[i].E3;
                        eFlagParams.E4            = dlg.SelectedProfile.Tests[i].E4;
                        eFlagParams.E5            = dlg.SelectedProfile.Tests[i].E5;
                        eFlagParams.E6            = dlg.SelectedProfile.Tests[i].E6;
                        eFlagParams.E7            = dlg.SelectedProfile.Tests[i].E7;
                        eFlagParams.E8            = dlg.SelectedProfile.Tests[i].E8;
                        eFlagParams.E9            = dlg.SelectedProfile.Tests[i].E9;
                        eFlagParams.E10           = dlg.SelectedProfile.Tests[i].E10;
                        eFlagParams.E11           = dlg.SelectedProfile.Tests[i].E11;
                        eFlagParams.E12           = dlg.SelectedProfile.Tests[i].E12;
                        eFlagParams.E13           = dlg.SelectedProfile.Tests[i].E13;
                        eFlagParams.E14           = dlg.SelectedProfile.Tests[i].E14;
                        eFlagParams.E15           = dlg.SelectedProfile.Tests[i].E15;
                        eFlagParams.E16           = dlg.SelectedProfile.Tests[i].E16;
                        eFlagParams.E21           = dlg.SelectedProfile.Tests[i].E21;
                        eFlagParams.Delta_Q_pct   = dlg.SelectedProfile.Tests[i].Delta_Q_pct;
                        eFlagParams.Delta_T       = dlg.SelectedProfile.Tests[i].Delta_T;
                        eFlagParams.Delta_Tup_Tdn = dlg.SelectedProfile.Tests[i].Delta_Tup_Tdn;
                        eFlagParams.TestTime_min  = dlg.SelectedProfile.Tests[i].TestTime_min;
                        eFlagParams.TestTime_max  = dlg.SelectedProfile.Tests[i].TestTime_max;
                        eFlagParams.AmbTemp_min   = dlg.SelectedProfile.Tests[i].AmbTemp_min;
                        eFlagParams.AmbTemp_max   = dlg.SelectedProfile.Tests[i].AmbTemp_max;
                        eFlagParams.Pressure_min  = dlg.SelectedProfile.Tests[i].PressLimLo;
                        eFlagParams.Pressure_max  = dlg.SelectedProfile.Tests[i].PressLimHi;
                        eFlagParams.Coef_E9       = dlg.SelectedProfile.Tests[i].Coef_E9;
                        eFlagParams.Coef_E10      = dlg.SelectedProfile.Tests[i].Coef_E10;
                        eFlagParams.Coef_E11      = dlg.SelectedProfile.Tests[i].Coef_E11;
                        eFlagParams.Coef_E12      = dlg.SelectedProfile.Tests[i].Coef_E12;
                        eFlagParams.Offset_E9     = dlg.SelectedProfile.Tests[i].Offset_E9;
                        eFlagParams.Offset_E12    = dlg.SelectedProfile.Tests[i].Offset_E12;
                    }

                    errorFlagsParamsOfCreatedTests.Add(errorFlagsParams);
                }
            }

            newProcedure.AltProcName = dlg.SelectedProfile.Name;
            newProcedure.ProcedureState = ProcedureState.Active;
            newProcedure.Revision = 1;
            newProcedure.PredecessorId = 0;
            newProcedure.ObtainedByCopy = false;
            newProcedure.CreationUser = Users.CurrentUser.UserName();
            newProcedure.CreationTime = DateTime.Now;
            newProcedure.ResultsPrinter = dlg.SelectedProfile.Name;

            if (new ProcedureDlg(Session, newProcedure, GetUsedNames(false), ProcedureDlg.Mode.Unlocked, parent).ShowDialog() == DialogResult.OK)
            {
                /// TODO: Make name uniqueness test
                parent.Unlock();

                using (var transaction = Session.BeginTransaction())
                {
                    try
                    {
                        newProcedure.LastChgUser = Users.CurrentUser.UserName();
                        newProcedure.LastChgTime = DateTime.Now;

                        DoAddOne(newProcedure);
                        Session.SaveOrUpdate(newProcedure);

                        foreach (var efp in errorFlagsParamsOfCreatedTests)
                        {
                            efp.UpdateEmbeddedDbEntity();
                        }

                        transaction.Commit();

                        MessageBox.Show(string.Format(Strings.Procedure_0_added, newProcedure.Name),
                                        Strings.Confirmation,
                                        MessageBoxButtons.OK,
                                        MessageBoxIcon.Information);
                    }
                    catch (Exception exc)
                    {
                        transaction.Rollback();
                        log.ErrorFormat("Could not save procedure '{0}':", newProcedure.Name);
                        log.ErrorFormat("Exception: {0}", exc.Message);
                        if (exc.InnerException != null) log.ErrorFormat("InnerException: {0}", exc.InnerException.Message);
                    }
                }
            }
        }


        public IList<string> GetUsedNames(bool caseSensitive = true)
        {
            IList<string> usedNames = new List<string>();

            if (Procedures != null)
            {
                if (caseSensitive)
                {
                    foreach (var procedure in Procedures)
                    {
                        usedNames.Add(procedure.Name);
                    }
                }
                else
                {
                    foreach (var procedure in Procedures)
                    {
                        usedNames.Add(procedure.Name.ToLower());
                    }
                }
            }

            return usedNames;
        }

        private void profileComboBox_SelectedIndexChanged(object sender, EventArgs e) { UpdateSelectedProfile(); }
        private void profileComboBox_TextChanged(object sender, EventArgs e) { UpdateSelectedProfile(); }
        ///
        void UpdateSelectedProfile()
        {
            //selectedProfile = ... TODO
            selectedProfile = (profileComboBox.Text != Strings.any) ? profileComboBox.Text : null;
            RedrawAll();
            listViewEx_SelectedIndexChanged(null, null);
        }

        private void dnComboBox_SelectedIndexChanged(object sender, EventArgs e) { UpdateSelectedDN(); }
        private void dnComboBox_TextChanged(object sender, EventArgs e) { UpdateSelectedDN(); }
        /// 
        void UpdateSelectedDN()
        {
            uint ival;
            selectedDN = uint.TryParse(dnComboBox.Text, out ival) ? ival : 0;
            RedrawAll();
            listViewEx_SelectedIndexChanged(null, null);
        }

        private void q3ComboBox_SelectedIndexChanged(object sender, EventArgs e) { UpdateSelectedQn(); }
        private void q3ComboBox_TextChanged(object sender, EventArgs e) { UpdateSelectedQn(); }
        /// 
        void UpdateSelectedQn()
        {
            float fval;
            selectedQ3 = Utils.TryParseUFloat(q3ComboBox.Text, out fval) ? fval : 0;
            RedrawAll();
            listViewEx_SelectedIndexChanged(null, null);
        }

        private void mclassComboBox_SelectedIndexChanged(object sender, EventArgs e) { UpdateSelectedMClass(); }
        private void mclassComboBox_TextChanged(object sender, EventArgs e) { UpdateSelectedMClass(); }
        /// 
        void UpdateSelectedMClass()
        {
            selectedMClass = (mclassComboBox.Text != Strings.any) ? mclassComboBox.Text : null;
            RedrawAll();
            listViewEx_SelectedIndexChanged(null, null);
        }

        private void producerComboBox_SelectedIndexChanged(object sender, EventArgs e) { UpdateSelectedProducer(); }
        private void producerComboBox_TextChanged(object sender, EventArgs e) { UpdateSelectedProducer(); }
        /// 
        void UpdateSelectedProducer()
        {
            selectedProducer = (producerComboBox.Text != Strings.any) ? producerComboBox.Text : null;
            RedrawAll();
            listViewEx_SelectedIndexChanged(null, null);
        }

        private void listViewEx_SelectedIndexChanged(object sender, EventArgs e)
        {
            bool isFilterAny = (selectedProfile == null) && (selectedDN == 0) && (selectedQ3 == 0) && (selectedMClass == null) && (selectedProducer == null);
            if (parent != null) parent.SelectedIndexChanged(listViewEx, isFilterAny);
        }



        /// <summary>
        /// 'More' column content selector.
        /// </summary>
        enum MoreContent
        {
            Description,
            Tests,
            DEAndSequences,
            Writers,
            Printers,
            Profile,
#if ORACLE_DB
            Oracle,
#endif
            Count
        }
        MoreContent moreContent;

        /// <summary>
        /// 'More' column header clicked => change moreContent valiable, column header text and redraw the column.
        /// </summary>
        private void listViewEx_ColumnClick(object sender, ColumnClickEventArgs e)
        {
            if (e.Column == (int)Column.More)
            {
                if (++moreContent == MoreContent.Count) moreContent = 0;
                switch(moreContent)
                {
                    case MoreContent.Description:
                        listViewEx.Columns[(int)Column.More].Text = Strings.DescriptionColHdr;
                        break;
                    case MoreContent.Tests:
                        listViewEx.Columns[(int)Column.More].Text = Strings.Test;
                        break;
                    case MoreContent.DEAndSequences:
                        listViewEx.Columns[(int)Column.More].Text = "Data entry and purge sequences";
                        break;
                    case MoreContent.Writers:
                        listViewEx.Columns[(int)Column.More].Text = "Writers";
                        break;
                    case MoreContent.Printers:
                        listViewEx.Columns[(int)Column.More].Text = "Printers";
                        break;
                    case MoreContent.Profile:
                        listViewEx.Columns[(int)Column.More].Text = "Profile";
                        break;
#if ORACLE_DB
                    case MoreContent.Oracle:
                        listViewEx.Columns[(int)Column.More].Text = "Oracle";
                        break;
#endif
                    default:
                        listViewEx.Columns[(int)Column.More].Text = string.Empty;
                        break;
                }

                RedrawMoreColumn();
            }
        }

        /// <summary>
        /// Update the complete 'More' column
        /// </summary>
        void RedrawMoreColumn()
        {
            foreach (ListViewItem item in listViewEx.Items)
            {
                item.SubItems[(int)Column.More].Text = GetMoreContent(item.Tag as Procedure, moreContent);
            }
        }

        /// <summary>
        /// Get content of the 'More' column.
        /// </summary>
        /// <param name="procedure">Procedure in this row</param>
        /// <param name="content">'More' column content selector</param>
        /// <returns>Text to be displayed</returns>
        string GetMoreContent(Procedure procedure, MoreContent content)
        {
            if (procedure == null) return string.Empty;

            StringBuilder sb = new StringBuilder();
            switch (content)
            {
                case MoreContent.Description:
                    return string.IsNullOrEmpty(procedure.Description) ? string.Empty : procedure.Description;

                case MoreContent.Tests:
                    for (int i = 0; i < procedure.Tests.Count; i++)
                    {
                        sb.Append("'");
                        sb.Append(procedure.Tests[i].Name);
                        sb.Append("'");
                        if (i < procedure.Tests.Count - 1) sb.Append(", ");
                    }
                    break;

                case MoreContent.DEAndSequences:
                    return string.Format("DE='{0}', Start='{1}', End='{2}'",
                                         string.IsNullOrEmpty(procedure.DataEntry) ? "<none>" : procedure.DataEntry,
                                         string.IsNullOrEmpty(procedure.TransitionStart) ? "<none>" : procedure.TransitionStart,
                                         string.IsNullOrEmpty(procedure.TransitionEnd) ? "<none>" : procedure.TransitionEnd);

                case MoreContent.Writers:
                    if (!string.IsNullOrEmpty(procedure.ResultsWriter))
                    {
                        string[] writers = procedure.ResultsWriter.Split(new char[] { '~' });
                        Array.Sort(writers);
                        foreach (var w in writers) { sb.Append(w); sb.Append("  "); }
                    }
                    break;

                case MoreContent.Printers:
                    if (!string.IsNullOrEmpty(procedure.ResultsPrinter))
                    {
                        string[] printers = procedure.ResultsPrinter.Split(new char[] { '~' });
                        Array.Sort(printers);
                        foreach (var p in printers) { sb.Append(p); sb.Append("  "); }
                    }
                    break;

                case MoreContent.Profile:
                    return string.IsNullOrEmpty(procedure.AltProcName) ? string.Empty : procedure.AltProcName;

#if ORACLE_DB
                case MoreContent.Oracle:
                    if (!string.IsNullOrEmpty(procedure.ResultsWriter) && procedure.ResultsWriter.Contains("Sensus-Oracle-DB"))
                    {
                        var procParamsEntity = Session.QueryOver<ComponentProcedure>()
                                                      .Where(x => x.Procedure == procedure)
                                                      .And(x => x.CmpntName == "Sensus-Oracle-DB")
                                                      .List();
                        if (procParamsEntity.Count == 1)
                        {
                            var pp = new TBF.Rig.Output.DB.SensusOracle.ProcedureParams();
                            pp.UpdateFromDbEntity(procParamsEntity[0]);
                            sb.AppendFormat("{0}  ", pp.WMKind);
                            sb.AppendFormat("Id = {0}  ", pp.WMTypeId);
                            sb.AppendFormat("Yr = {0}  ", pp.YearOfManufacture);
                            sb.AppendFormat("Save results = {0}  ", pp.SaveResults);
                            sb.AppendFormat("Read start info = {0}  ", pp.ReadStartInfo);
                            sb.AppendFormat("Start info is required = {0}  ", pp.StartInfoIsRequired);
                        }
                    }
                    break;
#endif
            }
            return sb.ToString();
        }
    }
}