///
/// Copyright (c) 2020 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));

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


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


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

		ProceduresDlg parent;
		Control parentControl;
		Control[] editors;

		ISession session;
        IWaterMeter waterMeterCmpnt;
        IErrorFlags errorFlagsCmpnt;

		public ProceduresCtrl()
		{
            InitializeComponent();

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

            dnComboBox.Text = Strings.any;
            dnComboBox.Items.Add(Strings.any);
            selectedDN = 0;

            q3ComboBox.Text = Strings.any;
            q3ComboBox.Items.Add(Strings.any);
            selectedQ3 = 0;

            mclassComboBox.Text = Strings.any;
            mclassComboBox.Items.Add(Strings.any);
            selectedMClass = null;

            producerComboBox.Text = Strings.any;
            producerComboBox.Items.Add(Strings.any);
            selectedProducer = null;

            moreContent = MoreContent.Description;
        }

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

            /// Create a DB session
            session = TBF.DB.CreateSession(DBKind.Config);
            
            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 (!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 ((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()
		{
            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.GlobalData.CurrentUser.UserName;
            newProcedure.CreationTime = DateTime.Now;

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

                using (var transaction = session.BeginTransaction())
                {
                    try
                    {
                        newProcedure.LastChgUser = Users.GlobalData.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("Exception when saving Procedure '{0}' : {1}", newProcedure.Name, exc.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(modifiedProcedure, usedNames, ProcedureDlg.Mode.Locked).ShowDialog() == DialogResult.OK)
			{
				parent.Unlock();

				using (var transaction = session.BeginTransaction())
				{
					try
					{
						originalProcedure.ProcedureState = ProcedureState.History;
						modifiedProcedure.LastChgUser = Users.GlobalData.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("Exception when saving Procedure '{0}' : {1}", modifiedProcedure.Name, exc.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.GlobalData.CurrentUser.UserName;
			newProcedure.CreationTime = DateTime.Now;
            newProcedure.Protected = false;

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

				using (var transaction = session.BeginTransaction())
				{
					newProcedure.LastChgUser = Users.GlobalData.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.GlobalData.CurrentUser.UserName;
            newProcedure.CreationTime = DateTime.Now;

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

                using (var transaction = session.BeginTransaction())
                {
                    newProcedure.LastChgUser = Users.GlobalData.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;

            try
            {
                profiles = session.QueryOver<Profile>().List();
            }
            catch (Exception)
            {
                log.Error("Reading Profiles failed");
                MessageBox.Show("Reading Profiles failed");
                return;
            }

            TestWizard.TestProfileSelection dlg = new TestWizard.TestProfileSelection(profiles);
            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.NewQnames = (pt == ProfileType.Q3R);
                        wmParams.Qmax = (float)((pt == ProfileType.Manual) ? 0 : Config.Utils.GetQ4Qmax(dlg.Qn, dlg.MetroClass, medium));
                        wmParams.Qn   = (float)dlg.Qn;
                        wmParams.Qt   = (float)((pt == ProfileType.Manual) ? 0 : (pt == ProfileType.QpQi) ? (0.1 * dlg.Qn) : Config.Utils.GetQ2Qt(dlg.Qn, dlg.MetroClass, medium));
                        wmParams.Qmin = (float)((pt == ProfileType.Manual) ? 0 : (pt == ProfileType.QpQi) ? dlg.Qn / dlg.QpQiRatio : Config.Utils.GetQ1Qmin(dlg.Qn, dlg.MetroClass, medium));
                        wmParams.MetrologicalClass = dlg.MetroClass;
                        wmParams.WaterTemp = medium;
                    }

                    waterMeterParamsOfNewProcedure.Add(waterMeterParams);
                }
            }


            int itemNr = 0;
            foreach (var ptest in dlg.SelectedProfile.Tests)
            {
                double Qtg;
                if (ptest.Name.Contains("Q4") || ptest.Name.Contains("Qmax"))
                {
                    Qtg = Config.Utils.GetQ4Qmax(dlg.Qn, dlg.MetroClass, medium, ptest.CoefQto);
                }
                else if (ptest.Name.Contains("Q3") || ptest.Name.Contains("Qn") || ptest.Name.Equals("qp"))
                {
                    Qtg = dlg.Qn;
                }
                else if (ptest.Name.Contains("Q2") || ptest.Name.Contains("Qt"))
                {
                    Qtg = Config.Utils.GetQ2Qt(dlg.Qn, dlg.MetroClass, medium, ptest.CoefQto);
                }
                else if (ptest.Name.Contains("Q1") || ptest.Name.Contains("Qmin"))
                {
                    Qtg = Config.Utils.GetQ1Qmin(dlg.Qn, dlg.MetroClass, medium, ptest.CoefQto);
                }
                else if (ptest.Name.Contains("0,1qp") || ptest.Name.Contains("0.1qp"))
                {
                    Qtg = 0.1 * dlg.Qn;
                }
                else if (ptest.Name.Contains("qi"))
                {
                    Qtg = dlg.Qn / dlg.QpQiRatio;
                }
                else
                {
                    Qtg = dlg.Qn;       /// Manual flow selection: CoefQfrom and CoefQto are used to calculate Qfrom and Qto from Qn
                }

                Test test = new Test(ptest.Name, itemNr++, newProcedure);
                test.Part = ptest.Part;
                test.Profile = (pt == ProfileType.QpQi) ? TestProfile.ProtectedHeatMeter : TestProfile.Protected;
                test.Qtg = (float)Qtg;
                test.Qfrom = (float)(Qtg * ptest.CoefQfrom);
                test.Qto = (float)(Qtg * ptest.CoefQto);
                test.TempLimLo = (float)ptest.TempLimLo;
                test.TempLimHi = (float)ptest.TempLimHi;
                test.Publish = ptest.Publish;
                test.DoEvaluate = ptest.Evaluate;

                if (pt != ProfileType.QpQi)
                {
                    test.ErrLimLo = (float)ptest.ErrLimLo;
                    test.ErrLimHi = (float)ptest.ErrLimHi;
                }
                else
                {
                    int metroClass;
                    if (int.TryParse(dlg.MetroClass, out metroClass)) test.ErrLimLo = (float)metroClass;
                    test.ErrLimHi = -(float)dlg.Qn;
                }

                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  = ptest.E1;
                        eFlagParams.E2  = ptest.E2;
                        eFlagParams.E3  = ptest.E3;
                        eFlagParams.E4  = ptest.E4;
                        eFlagParams.E5  = ptest.E5;
                        eFlagParams.E6  = ptest.E6;
                        eFlagParams.E7  = ptest.E7;
                        eFlagParams.E8  = ptest.E8;
                        eFlagParams.E9  = ptest.E9;
                        eFlagParams.E10 = ptest.E10;
                        eFlagParams.E11 = ptest.E11;
                        eFlagParams.E12 = ptest.E12;
                        eFlagParams.E13 = ptest.E13;
                        eFlagParams.E14 = ptest.E14;
                        eFlagParams.E15 = ptest.E15;
                        eFlagParams.E16 = ptest.E16;
                        eFlagParams.E21 = ptest.E21;

                        eFlagParams.Delta_Q_pct   = ptest.Delta_Q_pct;
                        eFlagParams.Delta_T       = ptest.Delta_T;
                        eFlagParams.Delta_Tup_Tdn = ptest.Delta_Tup_Tdn;
                        eFlagParams.TestTime_min  = ptest.TestTime_min;
                        eFlagParams.TestTime_max  = ptest.TestTime_max;
                        eFlagParams.AmbTemp_min   = ptest.AmbTemp_min;
                        eFlagParams.AmbTemp_max   = ptest.AmbTemp_max;
                        eFlagParams.Pressure_min  = ptest.PressLimLo;
                        eFlagParams.Pressure_max  = ptest.PressLimHi;
                        eFlagParams.Coef_E9       = ptest.Coef_E9;
                        eFlagParams.Coef_E10      = ptest.Coef_E10;
                        eFlagParams.Coef_E11      = ptest.Coef_E11;
                        eFlagParams.Coef_E12      = ptest.Coef_E12;
                        eFlagParams.Offset_E9     = ptest.Offset_E9;
                        eFlagParams.Offset_E12    = ptest.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.GlobalData.CurrentUser.UserName;
            newProcedure.CreationTime = DateTime.Now;

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

                using (var transaction = session.BeginTransaction())
                {
                    try
                    {
                        newProcedure.LastChgUser = Users.GlobalData.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("Exception when saving Procedure '{0}' : {1}", newProcedure.Name, exc.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 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 = (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,
            Writers,
            Printers,
#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.Writers:
                        listViewEx.Columns[(int)Column.More].Text = "Writers";
                        break;
                    case MoreContent.Printers:
                        listViewEx.Columns[(int)Column.More].Text = "Printers";
                        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:
                    foreach (var test in procedure.Tests)
                    {
                        sb.Append(test.Name);
                        sb.Append("  ");
                    }
                    break;

                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;
#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);
                            sb.AppendFormat("Designation mode = {0}", pp.DesigMode);
                            if (pp.DesigMode == TBF.Rig.Output.DB.SensusOracle.DesigMode.As_specified)
                            {
                                sb.AppendFormat("  Designation type = {0}", pp.DesigType);
                            }
                        }
                    }
                    break;
#endif
            }
            return sb.ToString();
        }
    }
}