///
/// Copyright (c) 2013-2017 Sensus Metering Systems
///
using System;
using System.Drawing;
using System.Windows.Forms;
using log4net;
using Config.Entities;
using TBF.BenchControl;
using TBF.BenchControl.GenericDevices;
using TBF.Resources;
using System.Collections.Generic;

namespace TBF.UiControls
{
	public class PathsOutputCtrl : BaseWithListViewEx<Config.Entities.OutputPath>, ITabWithListViewEx
	{
		static readonly ILog log = LogManager.GetLogger(typeof(PathsOutputCtrl));

		/// <summary>
		/// Fixed ListViewEx columns
		/// </summary>
		enum Column
		{
			Name,
			Qfrom,
			Qto,
			RegulValve,
			RefFlowmtr,
			PidCoef,
            StartValve,
			Div,
			Tdiv,
			Scale,
			FixedColumnsCount,
		}
		readonly int fixedColumnsCount = (int)Column.FixedColumnsCount;

		PathsDlg parent;
		Control parentControl;
		Control[] editors;

		public PathsOutputCtrl()
			: base()
		{
			FixedRowsCount = 1;
		}

		public void Initialize(PathsDlg parent, Control parentControl)
		{
			this.parent = parent;
			this.parentControl = parentControl;

			/// Load the paths
            MyItems = parent.Session.QueryOver<Config.Entities.OutputPath>()
                                    .OrderBy(x => x.ItemNr).Asc
                                    .List();

            foreach (var path in MyItems) path.OriName = path.Name;

			SubItemClicked += new Results.Forms.SubItemEventHandler(listViewEx_SubItemClicked);
			SubItemRightClicked += new Results.Forms.SubItemEventHandler(listViewEx_SubItemRightClicked);
			SubItemEndEditing += new Results.Forms.SubItemEndEditingEventHandler(listViewEx_SubItemEndEditing);

			/// ListViewEx columns
            TBF.LocalSettings ls = Program.LocalSettings;
            Columns.Add(Strings.Name,           (ls.OutputColumnCount > 0) ? ls.OutputColumnWidths[0] : 60 * parent.Dpi / PathsDlg.Dpi100pct);
            Columns.Add(Strings.Q_from_m3h,     (ls.OutputColumnCount > 1) ? ls.OutputColumnWidths[1] : 50 * parent.Dpi / PathsDlg.Dpi100pct);
            Columns.Add(Strings.Q_to_m3h,       (ls.OutputColumnCount > 2) ? ls.OutputColumnWidths[2] : 50 * parent.Dpi / PathsDlg.Dpi100pct);
            Columns.Add(Strings.Reg_valve,      (ls.OutputColumnCount > 3) ? ls.OutputColumnWidths[3] : 80 * parent.Dpi / PathsDlg.Dpi100pct);
            Columns.Add(Strings.Flowmeter,      (ls.OutputColumnCount > 4) ? ls.OutputColumnWidths[4] : 85 * parent.Dpi / PathsDlg.Dpi100pct);
			Columns.Add(Strings.PID,            (ls.OutputColumnCount > 5) ? ls.OutputColumnWidths[5] : 50 * parent.Dpi / PathsDlg.Dpi100pct);
			Columns.Add(Strings.StartValve,     (ls.OutputColumnCount > 6) ? ls.OutputColumnWidths[6] : 80 * parent.Dpi / PathsDlg.Dpi100pct);
            Columns.Add(Strings.Diverter,       (ls.OutputColumnCount > 7) ? ls.OutputColumnWidths[7] : 60 * parent.Dpi / PathsDlg.Dpi100pct);
            Columns.Add(Strings.T_div,          (ls.OutputColumnCount > 8) ? ls.OutputColumnWidths[8] : 70 * parent.Dpi / PathsDlg.Dpi100pct);
            Columns.Add(Strings.Balance,        (ls.OutputColumnCount > 9) ? ls.OutputColumnWidths[9] : 50 * parent.Dpi / PathsDlg.Dpi100pct);
            int clmn = (int)Column.FixedColumnsCount;
            foreach (var vlv in parent.Valves)
            {
                if (vlv.Category == ValveCategory.All || vlv.Category == ValveCategory.Output)
                {
                    Columns.Add(vlv.Cfg.Name, (ls.OutputColumnCount > clmn) ? ls.OutputColumnWidths[clmn] : 50 * parent.Dpi / PathsDlg.Dpi100pct);
                    clmn++;
                }
            }

			/// Prepare fixed columns combo boxes
			ComboBox regulValveComboBox = new ComboBox();
			ComboBox flowMeterComboBox = new ComboBox();
            ComboBox startValveComboBox = new ComboBox();
            ComboBox diverterComboBox = new ComboBox();
			ComboBox tempMeterDivComboBox = new ComboBox();
			ComboBox scaleComboBox = new ComboBox();
            regulValveComboBox.Items.Add("---");
            flowMeterComboBox.Items.Add("---");
            startValveComboBox.Items.Add("---");
            diverterComboBox.Items.Add("---");
			tempMeterDivComboBox.Items.Add("---");
			scaleComboBox.Items.Add("---");
            foreach (var cmpnt in parent.TbfComponents)
			{
				if (cmpnt is IRegulValve) regulValveComboBox.Items.Add(cmpnt.Cfg.Name);
				if (cmpnt is IFlowMeter) flowMeterComboBox.Items.Add(cmpnt.Cfg.Name);
				if (cmpnt is IDiverter) diverterComboBox.Items.Add(cmpnt.Cfg.Name);
				if (cmpnt is IScale) scaleComboBox.Items.Add(cmpnt.Cfg.Name);
				if (cmpnt is ITempMeter) tempMeterDivComboBox.Items.Add(cmpnt.Cfg.Name);
                if (cmpnt is IValve && (cmpnt as IValve).CoupledTo == null)
                {
                    startValveComboBox.Items.Add(cmpnt.Cfg.Name);
                }
			}

			editors = new Control[fixedColumnsCount + 64];
			///				
			editors[(int)Column.Name]       = new TextBox();		/// Name
			editors[(int)Column.Qfrom]      = new TextBox();		/// Q_from
			editors[(int)Column.Qto]        = new TextBox();		/// Q_to
			editors[(int)Column.RegulValve] = regulValveComboBox;
			editors[(int)Column.RefFlowmtr] = flowMeterComboBox;
			editors[(int)Column.PidCoef]    = new TextBox();		/// PID
			editors[(int)Column.StartValve] = startValveComboBox;
            editors[(int)Column.Div]        = diverterComboBox;
			editors[(int)Column.Tdiv]       = tempMeterDivComboBox;
			editors[(int)Column.Scale]      = scaleComboBox;
			/// Prepare valve combo-boxes (max. 64 valves)
			for (int i = 0; i < 64; i++)
			{
				ComboBox cb = new ComboBox();
				cb.Items.Add("---");
				cb.Items.Add(Strings.open);
				cb.Items.Add(Strings.close);
				editors[fixedColumnsCount + i] = cb;
			}
			///
            for (int i = 0; i < editors.Length; i++)
            {
                editors[i].Visible = false;
                parent.Controls.Add(editors[i]);
            }

			base.RedrawAll();
		}

		void listViewEx_SubItemClicked(object sender, Results.Forms.SubItemEventArgs e)
		{
			if (!Unlocked || e.SubItem >= editors.Length) return;
			if ((e.Item.Tag is IHasItemNr) &&
				((e.Item.Tag as IHasItemNr).ItemNr < FixedRowsCount) &&
				(e.SubItem < fixedColumnsCount))
			{
				return;
			}
			StartEditing(editors[e.SubItem], e.Item, e.SubItem);
		}

		void listViewEx_SubItemRightClicked(object sender, Results.Forms.SubItemEventArgs e)
        {
            if (!Unlocked || e.SubItem >= editors.Length) return;

            if (DialogResult.Yes == MessageBox.Show(Strings.Do_you_want_to_copy_this_value_to_all_cells_below_this_cell,
                                                    Strings.Confirmation, MessageBoxButtons.YesNo, MessageBoxIcon.Question))
            {
                int columnNr = e.SubItem;
                string value = null;
                System.Drawing.Color backColor = System.Drawing.Color.White;
                foreach (ListViewItem item in Items)
                {
                    if (value != null && item.SubItems.Count > columnNr)
                    {
                        item.SubItems[columnNr].Text = value;
                        item.SubItems[columnNr].BackColor = backColor;
                    }
                    else if (item == e.Item)
                    {
                        value = item.SubItems[columnNr].Text;
                        backColor = item.SubItems[columnNr].BackColor;
                    }
                }
            }
        }

		void listViewEx_SubItemEndEditing(object sender, Results.Forms.SubItemEndEditingEventArgs e)
		{
            if (e.SubItem >= fixedColumnsCount)
            {
                e.Item.SubItems[e.SubItem].BackColor = e.DisplayText == Strings.open ? Color.LightGray : Color.White;
            }
        }

		public override void DrawOne(object myItem)
		{
			Config.Entities.OutputPath entity =(Config.Entities.OutputPath)myItem;
			BenchControl.OutputPath path = new BenchControl.OutputPath(entity, parent.TbfComponents);

			ListViewItem lvi = new ListViewItem(entity.Name);
            lvi.UseItemStyleForSubItems = false;

            lvi.SubItems.Add(path.Qfrom.ToString());
			lvi.SubItems.Add(path.Qto.ToString());
			lvi.SubItems.Add((path.RegulValve != null) ? path.RegulValve.Cfg.Name : "---");
			lvi.SubItems.Add((path.FlowMeter != null) ? path.FlowMeter.Cfg.Name : "---");
			lvi.SubItems.Add(path.PidCoef.ToString("F1"));
            lvi.SubItems.Add((path.StartValve != null) ? path.StartValve.Cfg.Name : "---");
            lvi.SubItems.Add((path.Diverter != null) ? path.Diverter.Cfg.Name : "---");
			lvi.SubItems.Add((path.TempDiv != null) ? path.TempDiv.Cfg.Name : "---");
			lvi.SubItems.Add((path.Scale != null) ? path.Scale.Cfg.Name : "---");

			foreach (var valve in parent.Valves)
			{
                if (valve.Category == ValveCategory.All || valve.Category == ValveCategory.Output)
                {
					if (path.ValvesOpen != null && path.ValvesOpen.Contains(valve))
					{
						lvi.SubItems.Add(Strings.open);
                        lvi.SubItems[lvi.SubItems.Count - 1].BackColor = Color.LightGray;
                    }
					else if (path.ValvesClose != null && path.ValvesClose.Contains(valve))
					{
						lvi.SubItems.Add(Strings.close);
                        lvi.SubItems[lvi.SubItems.Count - 1].BackColor = Color.White;
                    }
					else
					{
						lvi.SubItems.Add("---");
                        lvi.SubItems[lvi.SubItems.Count - 1].BackColor = Color.White;
                    }
				}
			}

			lvi.Tag = entity;

			Items.Add(lvi);
		}

		public override void UpdateOne(ListViewItem lvi, object myItem)
		{
			Config.Entities.OutputPath entity = (Config.Entities.OutputPath)myItem;

			entity.Name = lvi.Text;

			float Qfrom;
			bool allOk = Utils.TryParseUFloat(lvi.SubItems[(int)Column.Qfrom].Text, out Qfrom);
			entity.Qfrom = Qfrom;

			float Qto;
			allOk &= Utils.TryParseUFloat(lvi.SubItems[(int)Column.Qto].Text, out Qto);
			entity.Qto = Qto;

			entity.RegulValve     = lvi.SubItems[(int)Column.RegulValve].Text.Equals("---") ? null : lvi.SubItems[(int)Column.RegulValve].Text;
			entity.FlowMeter      = lvi.SubItems[(int)Column.RefFlowmtr].Text.Equals("---") ? null : lvi.SubItems[(int)Column.RefFlowmtr].Text;

			float pid;
			allOk &= Utils.TryParseSFloat(lvi.SubItems[(int)Column.PidCoef].Text, out pid);
			entity.PidCoef = pid;

			entity.StartValve     = lvi.SubItems[(int)Column.StartValve].Text.Equals("---") ? null : lvi.SubItems[(int)Column.StartValve].Text;
			entity.Diverter       = lvi.SubItems[(int)Column.Div].Text.Equals("---")        ? null : lvi.SubItems[(int)Column.Div].Text;
			entity.TempDiv        = lvi.SubItems[(int)Column.Tdiv].Text.Equals("---")       ? null : lvi.SubItems[(int)Column.Tdiv].Text;
			entity.Scale        = lvi.SubItems[(int)Column.Scale].Text.Equals("---")      ? null : lvi.SubItems[(int)Column.Scale].Text;

			string valvesOpen = string.Empty;
			string valvesClose = string.Empty;
            int k = 0;
			for (int j = 0; j < parent.Valves.Count; j++)
			{
                if (parent.Valves[j].Category == ValveCategory.All || parent.Valves[j].Category == ValveCategory.Output)
                {
                    string text = lvi.SubItems[fixedColumnsCount + k].Text;
					if (text.Equals(Strings.open))
					{
						if (valvesOpen != string.Empty) valvesOpen += ";";
						valvesOpen += parent.Valves[j].Cfg.Name;
					}
					if (text.Equals(Strings.close))
					{
						if (valvesClose != string.Empty) valvesClose += ";";
						valvesClose += parent.Valves[j].Cfg.Name;
					}
                    k++;
                }
			}
			entity.ValvesOpen = valvesOpen;
			entity.ValvesClose = valvesClose;
		}

		public void AddOne()
		{
			Config.Entities.OutputPath entity;

			if (MyItems.Count < FixedRowsCount)
			{
				entity = new Config.Entities.OutputPath(Strings._none_, MyItems.Count);
			}
			else
			{
				/// Find an unused test name
				string newName;
				for (int nameId = 1; true; nameId++)
				{
					newName = Strings.New_output_path_name + nameId.ToString();
					bool notUsed = true;
					foreach (var t in MyItems) if (t.Name.Equals(newName)) notUsed = false;
					if (notUsed) break;
				}
				entity = new Config.Entities.OutputPath(newName, MyItems.Count);
			}

			base.AddOne(entity);
		}

		public new void RemoveSelected()
		{
			bool lastOneRemoved = base.RemoveSelected();
			if (lastOneRemoved && parent != null)
			{
				parent.UpdateButtonStates(SharedButtons.SelectedItemPos.None);
			}
		}

		public string GetWarningsBeforeSaving(ref Dictionary<string, string> renmInfo)
		{
			base.OkBtnClicked();		/// = UpdateAll()

			string warnings = string.Empty;

            foreach (var entity in ToBeRemovedItems)
            {
                if (!string.IsNullOrEmpty(entity.OriName))
                {
                    int occurances = 0;
                    foreach (var tst in parent.Tests) if (!string.IsNullOrEmpty(tst.OutputPath) && tst.OutputPath.Equals(entity.OriName)) occurances++;

                    if (occurances > 0)
                    {
                        warnings += string.Format(Strings._0_path_1_used_by_2_tests_will_be_removed_3, Strings.OutputTabPageTitle, entity.Name, occurances, Environment.NewLine);
                    }
                }
            }

            foreach (var entity in MyItems)
            {
                if (!string.IsNullOrEmpty(entity.OriName) && entity.OriName != entity.Name)
                {
                    int occurances = 0;
                    foreach (var tst in parent.Tests) if (!string.IsNullOrEmpty(tst.OutputPath) && tst.OutputPath.Equals(entity.OriName)) occurances++;

                    if (occurances > 0)
                    {
                        warnings += string.Format(Strings._0_path_1_used_by_2_tests_will_be_renamed_3, Strings.OutputTabPageTitle, entity.Name, occurances, Environment.NewLine);
                    }
                }
            }

			return warnings;
		}

		public void UpdateRelatedItems(Dictionary<string, string> renameInfo)
        {
			foreach (var tst in parent.Tests)
			{
				string newPathName;
				if (!string.IsNullOrEmpty(tst.OutputPath) && renameInfo.TryGetValue(tst.OutputPath, out newPathName))
				{
					tst.OutputPath = newPathName;
					Config.FluentCommon.SaveToDb(parent.Session, tst);
				}
			}
		}

        /// <summary>
        /// Update the entities and save them to the database
        /// </summary>
        public new void OkBtnClicked()
        {
            base.OkBtnClicked();

            /// Update the database
            foreach (var entity in ToBeRemovedItems)
            {
                Config.FluentCommon.DeleteFromDb(parent.Session, entity);
            }
            foreach (var entity in MyItems)
            {
                Config.FluentCommon.SaveToDb(parent.Session, entity);
            }

            /// Update the column widths
            Program.LocalSettings.OutputColumnWidths = new int[Columns.Count];
            for (int i = 0; i < Columns.Count; i++)
            {
                Program.LocalSettings.OutputColumnWidths[i] = Columns[i].Width;
            }
            Program.LocalSettings.Save();
        }
    }
}