///
/// Copyright (c) 2013-2019 Sensus Slovensko a.s.
///
using System;
using System.Text;
using System.Threading;
using System.Collections.Generic;
using log4net;
using NHibernate;
using Config.Entities;
using TBF.BenchControl.Generic;
using TBF.BenchControl.GenericDevices;
using TBF.BenchControl.Sequences;
using Dirichlet.Numerics;
using TBF.Resources;

namespace TBF.BenchControl
{
    public enum MachineState
    {
        Undefined = 0,
        Disabled,
        StartingUp,     /// Start-up: Initialize() of all devices + start of the worker thread
        FailedToStart,  /// Most likely Initialize() of any device thrown an exception
        Running,        /// RunDeviceBefore() and RunDeviceAfter() of all devices, Start()/Run()/Stop() of operations
        ShuttingDown,   /// Shutdown: StopDevice() and StopDevice2() of all devices
        Off,            /// Off after the shutdown
    }


    /// <summary>
    /// This class controls real test bench behavior.
    /// It is based on a state machine
    /// </summary>
    public static class StateMachine
    {
		private static readonly ILog log = LogManager.GetLogger(typeof(StateMachine));
		private static readonly ILog wlog = LogManager.GetLogger(typeof(StateMachine));

		/// Private devices and components
		static IList<IComponent> components;		/// list of all components
		static IList<IDevice> devices;				/// list of devices
													/// 
		/// Bench paths
		static IList<Config.Entities.FeedingPath> feedingPaths;
		static IList<Config.Entities.BenchPath> benchPaths;
		static IList<Config.Entities.OutputPath> outputPaths;
		static IList<Config.Entities.MetersPath> metersPaths;
        static IList<Config.Entities.HeatMetersPath> heatMetersPaths;
        public static IList<Config.Entities.TransitionSequence> TransitionSequences;
        public static IList<Config.Entities.TransitionStep> TransitionSteps;

		/// Public components
		public static Elde.ControlBoardDev ControlBoard;
		public static GenericDevices.IAmbient Ambient;
        public static IOperation BenchWaitingOp;
        public static IOperation BenchErrorOp;
        public static GenericDevices.IScaleOrTank Tank1;
		public static GenericDevices.IScaleOrTank Tank2;
		public static GenericDevices.IScaleOrTank Tank3;
        public static GenericDevices.IValve DrainValve1;
		public static GenericDevices.IValve DrainValve2;
        public static GenericDevices.IValve DrainValve3;
        public static IList<IValve> MasterValves;				/// list of directly controlled valves
		public static IList<IValve> CoupledValves;				/// list of coupled valves
		public static IList<Elde.ValveEx.Valve> ExtendedValves;	/// list of extended valves


        /// Time and synchronization
#if TURA_IPERL || TURA_IPERL_NEW
		public const int Period = 2;				/// State machine period in sec.
#else
        public const int Period = 1;				/// State machine period in sec.
#endif

		static DateTime startDateTime;				/// DateTime of time instance when the state machine worker thread starts
        static int currentTimeSec;					/// Time from the start of the state machine in seconds

        public static MachineState MachineState;    /// see enum MachineState for explanation

		/// Worker thread and database session
        static Thread workerThread;

		static IList<State> states;					/// list of states

		public static DateTime CycleStartTimeStamp;

		public static IList<IValve> DefaultValvesOpen
		{
			get
			{
				return GenericDevices.ValveBase.Merge(
					Utils.ValvesOpen((feedingPaths != null && feedingPaths.Count > 0) ? feedingPaths[0] : null),
					Utils.ValvesOpen((benchPaths   != null && benchPaths.Count > 0)   ? benchPaths[0]   : null),
					Utils.ValvesOpen((outputPaths  != null && outputPaths.Count > 0)  ? outputPaths[0]  : null)
					);
			}
		}

		public static IList<IValve> DefaultValvesClose
		{
			get
			{
                return GenericDevices.ValveBase.Merge(
					Utils.ValvesClose((feedingPaths != null && feedingPaths.Count > 0) ? feedingPaths[0] : null),
					Utils.ValvesClose((benchPaths   != null && benchPaths.Count > 0)   ? benchPaths[0]   : null),
					Utils.ValvesClose((outputPaths  != null && outputPaths.Count > 0)  ? outputPaths[0]  : null)
					);
			}
		}

		/// <summary>
		/// Loaded by LoadProcedure() or IOperation LoadProcedureOp(...)
		/// </summary>
		public static Procedure Procedure;					/// Procedure
		public static IList<Test> Tests;					/// Tests
        public static bool IsRemoteProcedure;                                                            


		/// Hardware devices connected to the PC controlling the bench.
		public static IList<IComponent> Components { get { return components; } }
		public static IList<IDevice> Devices { get { return devices; } }

        /// <summary>
        /// DateTime of time instance when the state machine worker thread starts
        /// </summary>
        public static DateTime StartDateTime { get { return startDateTime; } }

        /// <summary>
        /// Current state name
        /// </summary>
        public static int Time
        {
            get { return currentTimeSec; }
            set { currentTimeSec = value; }
        }

        /// <summary>
        /// Constructor
        /// </summary>
        static StateMachine()
        {
            devices = new List<IDevice>();
			states = new List<State>();
            currentTimeSec = 0;
        }

		/// <summary>
		/// Add a device to the state machine.
		/// </summary>
		/// <param name="obj">Device</param>
		public static void AddDevice(IDevice device)
		{
			if (device != null && !devices.Contains(device)) devices.Add(device);
		}

        /// <summary>
        /// Add a state to the state machine.
		/// In this way a sequence can be created programtically.
        /// </summary>
        /// <param name="obj">State</param>
		public static void AddState(State state)
		{
			if (state != null && !states.Contains(state)) states.Add(state);
		}

        /// <summary>
        /// Remove the state from the state machine.
        /// </summary>
		/// <param name="obj">State</param>
		public static void RemoveState(State state)
        {
			if (state != null && state != State.CurrentState && states.Contains(state)) states.Remove(state);
        }

        /// <summary>
        /// Get a state from a label
        /// </summary>
        /// <param name="label"></param>
        /// <returns>The matching state or null</returns>
        static State GetStateFromLabel(string label)
        {
			if (label == null) return null;

            foreach (State state in states)
            {
                if (state.Label != null && state.Label.Equals(label)) return state;
            }
            return null;
        }

        /// <summary>
        /// Start the state machine in the state 'label' in a desired mode of operation.
        /// This method is called in the UI thread and creates a new state machine thread. 
        /// This method call should be embedded in: try { StateMachine.Start(...); } catch { }
        /// to handle configuration problems. Calls CreateDevices(mode) and CreateStates(). 
        /// </summary>
        /// <param name="mode">Mode of operation</param>
        /// <param name="benchData">A copy of bench data used by the state machine</param>
        /// <param name="label">Identifies the initial state</param>
#if DN100
		public static void InitializeBoardEtc(ControlCom2VB.ControlCom2panel ctrlBrdComponent)
#elif MUNICH || FUZHOU_150
		public static void InitializeBoardEtc(ControlComponent3Munich.UserControl1 ctrlBrdComponent)
#elif FUZHOU_300
        public static void InitializeBoardEtc(ControlComponent3F300.UserControl1 ctrlBrdComponent)
#elif IZRAEL_200 || PUCHONG_200 || GENESIS || BERLIN || GELSENWASSER || SLM_150 || PETERSBURG_200
		public static void InitializeBoardEtc(ControlComponent_Izrael2014.UserControl1 ctrlBrdComponent)
#else /// all newer benches
        public static void InitializeBoardEtc(ControlComponent_Torino2015.UserControl1 ctrlBrdComponent)
#endif
        {
            /// Load the list of components (entities) from the database.
			/// Then create the components (derived from IComponent).
			components = BenchControl.TbfComponents.LoadComponentsFromDB(Config.FluentCommon.CreateSession(Users.Entities.DBKind.Config));
			MasterValves = GenericDevices.ValveBase.MasterValves(components);
			CoupledValves = GenericDevices.ValveBase.CoupledValves(components);
			ExtendedValves = GenericDevices.ValveBase.ExtendedValves(components);

			/// Find all balances (to initialize tank capacities in the control board)
			/// Find the control board
			IList<IScaleOrTank> tanks = new List<IScaleOrTank>();
            ProcessData.IperlHeads = new List<TestMethods.iPerlCommunication.iPerlHead.IperlHead>();
            SequenceBase.FlowMeters = new List<IFlowMeter>();
            SequenceBase.RegulValves = new List<IRegulValve>();
            SequenceBase.PumpsWithFM = new List<IPumpFM>();
			SequenceBase.WaterMeters = new List<IWaterMeter>();
			SequenceBase.Cameras = new List<ICamera>();
            UInt128 valvesToInvert = 0;
			foreach (var cmpnt in components)
			{
                if (cmpnt is Elde.ControlBoardDev) ControlBoard = cmpnt as Elde.ControlBoardDev;
                if (cmpnt is IBenchInfo) ProcessData.BenchInfo = cmpnt as IBenchInfo;
				if (cmpnt is IErrorFlags) ProcessData.ErrorFlagsComp = cmpnt as IErrorFlags;
                if (cmpnt is IStatisticsMonitoring) ProcessData.StatisticsMonitoringComp = cmpnt as IStatisticsMonitoring;

                if ((cmpnt is Output.DB.SensusOracle.Database) && (ProcessData.OracleDB == null))
                {
                    ProcessData.OracleDB = cmpnt as Output.DB.SensusOracle.Database;
                }
                if (cmpnt is TestMethods.iPerlCommunication.iPerlHead.IperlHead)
                {
                    ProcessData.IperlHeads.Add(cmpnt as TestMethods.iPerlCommunication.iPerlHead.IperlHead);
                }
                if (cmpnt is IFlowMeter) SequenceBase.FlowMeters.Add(cmpnt as IFlowMeter);
				if ((cmpnt is IRegulValve) && !(cmpnt is BenchControl.Elde.RegulValveTandem.RegulValveTandem))
				{
					SequenceBase.RegulValves.Add(cmpnt as IRegulValve);
				}
                if (cmpnt is IPumpFM && !(cmpnt is Elde.PumpTandem.Pump))
                {
                    SequenceBase.PumpsWithFM.Add(cmpnt as IPumpFM);
                }
                if (cmpnt is IWaterMeter) SequenceBase.WaterMeters.Add(cmpnt as IWaterMeter);
				if (cmpnt is ICamera) SequenceBase.Cameras.Add(cmpnt as ICamera);
				if (cmpnt is GenericDevices.IAmbient) Ambient = cmpnt as GenericDevices.IAmbient;

                if (cmpnt is GenericDevices.IParallelOutput && cmpnt.Name.ToLower().Contains("tower"))
                {
                    BenchWaitingOp = (cmpnt as GenericDevices.IParallelOutput).ShowBenchWaitingOp();
                    BenchErrorOp = (cmpnt as GenericDevices.IParallelOutput).ShowBenchErrorOp();
                }

				if (cmpnt is IScaleOrTank)
				{
					IScaleOrTank tank = cmpnt as IScaleOrTank;
                    tanks.Add(tank);

					if      ((tank.ScaleNr == 0) && (Tank1 == null)) Tank1 = tank;
					else if ((tank.ScaleNr == 1) && (Tank2 == null)) Tank2 = tank;
					else if ((tank.ScaleNr == 2) && (Tank3 == null)) Tank3 = tank;
                }

                Elde.Valve.Valve eldeValve = (cmpnt as Elde.Valve.Valve);
                if ((eldeValve != null) && eldeValve.Inverted) valvesToInvert |= eldeValve.Mask;

				cmpnt.StartChangeHandler();		/// Start handling parameter change events
			}

			/// Create an array with tank capacities
			double[] tankCapacities = new double[tanks.Count];
			for (int i = 0; i < tankCapacities.Length; i++) tankCapacities[i] = tanks[i].Capacity;

			/// Pre-initialize the control board (= buffer the arguments ctrlBrdComponent, tankCapacities)
			if (ControlBoard != null)
			{
				ControlBoard.InitializeComponent(ctrlBrdComponent, valvesToInvert, tankCapacities);
			}
			else
			{
				throw new Exception("Control board component is missing");
			}
		}


        public static string CurrentlyInitializedDeviceName;
        /// 
        public static string InitializeDevices()
        {
            CurrentlyInitializedDeviceName = "-";

            bool anyComponentIsInSimulMode = false;
			StringBuilder inSimulMode = new StringBuilder();

			/// Add all devices to the state machine and initialize them
			foreach (var cmpnt in components)
			{
				if (cmpnt.DebugLevel == DebugMode.Simulate)
				{
					inSimulMode.AppendFormat("{0}{1}", anyComponentIsInSimulMode ? ", " : "", cmpnt.Name);
					anyComponentIsInSimulMode = true;
				}

                IDevice device = cmpnt as IDevice;
				if (device != null)
				{
                    CurrentlyInitializedDeviceName = device.Name;
					UiBridge.Bridge.OnActivity(null, device.Name);	/// Info

                    device.Initialize();
					AddDevice(device);		        /// Only components that were initialized are added
				}
			}
            
            CurrentlyInitializedDeviceName = "---";

			///
			/// (1) Propagate debug levels from parents to children when necessary
			/// (2) Set drain valves DrainValve1, DrainValve2 and DrainValve3
			///
			foreach (var cmpnt in components)
			{
				if (cmpnt.Cfg is IChildComponentCfg && !string.IsNullOrEmpty(cmpnt.Cfg.ParentName) &&
					(cmpnt.Cfg.DebugLevel == DebugMode.Inherit || cmpnt.Cfg.DebugLevel == DebugMode.AutoDetect))
				{
					foreach (var par in components)
					{
						if (par.Cfg.Name.Equals(cmpnt.Cfg.ParentName)) { cmpnt.Cfg.DebugLevel = par.Cfg.DebugLevel; break; }
					}
				}

				if (cmpnt is IScaleOrTank)
				{
					IScaleOrTank tank = cmpnt as IScaleOrTank;

                    if ((tank.ScaleNr == 0) && (DrainValve1 == null))
					{
						DrainValve1 = tank.DrainValve;
						log.WarnFormat("InitializeBoardEtc() ... Scale1={0} Draining valve1={1}",
										tank.Name, (DrainValve1 != null) ? DrainValve1.Name : "---");
					}
					else if ((tank.ScaleNr == 1) && (DrainValve2 == null))
					{
						DrainValve2 = tank.DrainValve;
						log.WarnFormat("InitializeBoardEtc() ... Scale2={0} Draining valve2={1}",
										tank.Name, (DrainValve2 != null) ? DrainValve2.Name : "---");
					}
                    else if ((tank.ScaleNr == 2) && (DrainValve3 == null))
					{
						DrainValve3 = tank.DrainValve;
						log.WarnFormat("InitializeBoardEtc() ... Scale3={0} Draining valve3={1}",
										tank.Name, (DrainValve3 != null) ? DrainValve3.Name : "---");
					}
				}
			}

			if (anyComponentIsInSimulMode)
				return inSimulMode.ToString();
			else
				return null;
        }

		/// <summary>
		/// Stop devices that were started by InitializeDevices().
		/// Works correctly also after exeption from InitializeDevices() as only ...
		/// ... correctly started devices were added in 'devices' list.
		/// </summary>
		public static void StopDevices()
		{
            foreach (var dev in devices)
            {
                UiBridge.Bridge.OnActivity(null, string.Format("1. {0}", dev.Name));	/// Info
                dev.StopDevice();
            }
		}

		/// <summary>
		/// Stop devices that were started by InitializeDevices().
		/// Works correctly also after exeption from InitializeDevices() as only ...
		/// ... correctly started devices were added in 'devices' list.
		/// </summary>
		public static void StopDevices2()
		{
            foreach (var dev in devices)
            {
                UiBridge.Bridge.OnActivity(null, string.Format("2. {0}", dev.Name));	/// Info
                dev.StopDevice2();
            }
		}

        /// <summary>
        /// Checks remote and local configuration DB paths and transitions for compatibility
        /// </summary>
        /// <returns>true when DB-s are compatible</returns>
        public static bool IsRemoteDBCompatible(out string message)
        {
            IList<Config.Entities.FeedingPath> remoteFeedingPaths;
            IList<Config.Entities.BenchPath> remoteBenchPaths;
            IList<Config.Entities.OutputPath> remoteOutputPaths;
            IList<Config.Entities.MetersPath> remoteMetersPaths;
            IList<Config.Entities.TransitionSequence> remoteTransitions;
            
            try
            {
                ISession remoteSession = Config.FluentCommon.CreateSession(Users.Entities.DBKind.RemoteConfig);
                remoteFeedingPaths = remoteSession.QueryOver<Config.Entities.FeedingPath>().List();
                remoteBenchPaths = remoteSession.QueryOver<Config.Entities.BenchPath>().List();
                remoteOutputPaths = remoteSession.QueryOver<Config.Entities.OutputPath>().List();
                remoteMetersPaths = remoteSession.QueryOver<Config.Entities.MetersPath>().List();
                remoteTransitions = remoteSession.QueryOver<Config.Entities.TransitionSequence>().List();
            }
            catch (Exception)
            {
                message = "Cannot open remote database";
                return false;
            }

            ISession localSession = Config.FluentCommon.CreateSession(Users.Entities.DBKind.Config);
            var localFeedingPaths = localSession.QueryOver<Config.Entities.FeedingPath>().List();
            var localBenchPaths = localSession.QueryOver<Config.Entities.BenchPath>().List();
            var localOutputPaths = localSession.QueryOver<Config.Entities.OutputPath>().List();
            var localMetersPaths = localSession.QueryOver<Config.Entities.MetersPath>().List();
            var localTransitions = localSession.QueryOver<Config.Entities.TransitionSequence>().List();

            string subMsg;
            if (!IsCompatible(localFeedingPaths, remoteFeedingPaths, out subMsg))
            {
                message = string.Format("Feeding: {0}", subMsg);
                return false;
            }

            if (!IsCompatible(localBenchPaths, remoteBenchPaths, out subMsg))
            {
                message = string.Format("Bench: {0}", subMsg);
                return false;
            }

            if (!IsCompatible(localOutputPaths, remoteOutputPaths, out subMsg))
            {
                message = string.Format("Output: {0}", subMsg);
                return false;
            }

            if (!IsCompatible(localMetersPaths, remoteMetersPaths, out subMsg))
            {
                message = string.Format("Sensors: {0}", subMsg);
                return false;
            }

            if (!IsCompatible(localTransitions, remoteTransitions, out subMsg))
            {
                message = string.Format("Transitions: {0}", subMsg);
                return false;
            }

            message = string.Empty;
            return true;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <typeparam name="T">FeedingPath, BenchPath, OutputPath, MetersPath or TransitionSequence</typeparam>
        /// <param name="localList">Local list of paths or transitions</param>
        /// <param name="remoteList">Remote list of paths or transitions</param>
        /// <param name="message">Message specifying a cause of incompatibility</param>
        /// <returns>true when lists are compatible, otherwise false</returns>
        private static bool IsCompatible<T>(IList<T> localList, IList<T> remoteList, out string message)
        {
            message = "Local list is empty";
            if ((localList == null) || (localList.Count == 0) || !(localList[0] is IHasName)) return false;

            message = "Remote list is empty";
            if ((remoteList == null) || (remoteList.Count == 0) || !(remoteList[0] is IHasName)) return false;

            ///
            /// Each path or transition on a remote list must exist on a local list
            ///
            foreach (var rItem in remoteList)
            {
                bool exists = false;
                foreach (var lItem in localList)
                {
                    if ((rItem as IHasName).Name == (lItem as IHasName).Name)
                    {
                        exists = true;
                        break;
                    }
                }

                if (!exists)
                {
                    message = string.Format("Remote item {0} does not exist on a local list", (rItem as IHasName).Name);
                    return false;
                }
            }

            message = string.Empty;
            return true;
        }


		/// <summary>
		/// Start the state machine 
		/// </summary>
		public static void Start()
		{
            if (MachineState != MachineState.StartingUp)
            {
                /// Unexpected MachineState (not MachineState.StartingUp) --> prevent worker thread from starting
                ///
                MachineState = MachineState.FailedToStart;
                return;
            }

            workerThread = new Thread(Worker);
			workerThread.CurrentCulture = Thread.CurrentThread.CurrentCulture;
			workerThread.CurrentUICulture = Thread.CurrentThread.CurrentUICulture;
			workerThread.Start();
        }

        /// <summary>
        /// Loads all paths and transitions from the DB.
        /// Updates StatMachine.feedingPaths ... StatMachine.meterPaths, StatMachine.TransitionSequences
        /// </summary>
        public static void LoadPathsAndTransitions(ISession session)
		{
			feedingPaths = session.QueryOver<Config.Entities.FeedingPath>().OrderBy(x => x.ItemNr).Asc.List();
            benchPaths   = session.QueryOver<Config.Entities.BenchPath>().OrderBy(x => x.ItemNr).Asc.List();
            outputPaths  = session.QueryOver<Config.Entities.OutputPath>().OrderBy(x => x.ItemNr).Asc.List();
            metersPaths  = session.QueryOver<Config.Entities.MetersPath>().OrderBy(x => x.ItemNr).Asc.List();
            TransitionSequences = session.QueryOver<TransitionSequence>().OrderBy(x => x.ItemNr).Asc.List();
            TransitionSteps = session.QueryOver<TransitionStep>().OrderBy(x => x.ItemNr).Asc.List();
#if HEAT_METERS
            heatMetersPaths = session.QueryOver<Config.Entities.HeatMetersPath>().OrderBy(x => x.ItemNr).Asc.List();
#endif
		}

        /// <summary>
        /// Loads selected procedure from the DB.
        /// Updates StateMachine.Procedure and StateMachine.Tests
        /// </summary>
        public static bool LoadProcedure(ISession session, string procedureName, bool isRemote, IList<string> autoTests = null)
        {
            Procedure = null;

            IList<Procedure> selectedProcs = session.QueryOver<Procedure>()
                                                    .Where(x => (x.ProcedureState == ProcedureState.Active))
                                                    .And(x => (x.Name == procedureName))
                                                    .List();
            if (selectedProcs.Count == 1)
            {
                IsRemoteProcedure = isRemote;
                Procedure = selectedProcs[0];

                Tests = selectedProcs[0].Tests;
                for (int i = Tests.Count - 1; i >= 0; i--)
                {
                    Test test = Tests[i];
                    if ((test.Name.Length > 0) && (test.Name[0] == '[') && test.Name.Contains("]"))
                    {
                        /// This is an AutoAction test => If 'actionName' is not on 'autoTests' list the test should be removed
                        int actionNameEndPos = test.Name.IndexOf(']');
                        string actionName = test.Name.Substring(1, actionNameEndPos - 1);
                        if (autoTests == null || autoTests.Count == 0 || !autoTests.Contains(actionName))
                        {
                            /// AutoAction test was not selected and should be deleted
                            Tests.RemoveAt(i);
                        }
                    }
                }

                return true;
            }

            return false;
        }

		public static void LoadProcedureParams(Procedure procedure)
		{
			foreach (var cmpnt in components)
			{
                cmpnt.Cfg.LoadProcedureParamsFromDB(procedure);
			}
		}

		public static void LoadTestParams(Test test)
		{
			foreach (var cmpnt in components)
			{
				cmpnt.Cfg.LoadTestParamsFromDB(test);
			}
		}

		/// <summary>
		/// Called from the sequence to update paths based on the selected test
		/// </summary>
		/// <param name="test">Selected test</param>
		/// <param name="pfeed"></param>
		/// <param name="pben"></param>
		/// <param name="pout"></param>
		/// <param name="pmtrs"></param>
		/// <param name="transitionBefore">Transition sequence entity</param>
		/// <param name="transitionAfter">Transition sequence entity</param>
		/// <param name="errorMsg">Error message in case of incorrect configuration</param>
		/// <returns>true when loaded configuration is correct (all four paths are defined !=null, etc.)</returns>
		public static bool GetPaths(Test test,
                                    bool heatMetersPathRequired,
									out FeedingPath pfeed,
                                    out BenchPath pben,
                                    out OutputPath pout,
                                    out MetersPath pmtrs,
                                    out HeatMetersPath phmtrs,
                                    out TransitionSequence transitionBefore,
                                    out TransitionSequence transitionBetween,
                                    out TransitionSequence transitionAfter,
                                    out string errorMsg)
		{
            ITestMethod tm = TbfComponents.FindComponent(test.Method) as ITestMethod;
            bool isHydroTest = (tm != null) ? tm.DoTransitions() : false;

			pfeed = null;
			pben = null;
			pout = null;
            phmtrs = null;
			transitionBefore = null;
            transitionBetween = null;
            transitionAfter = null;

			foreach (var path in feedingPaths)
			{
				if (test.FeedingPath == path.Name) { pfeed = new FeedingPath(path, components); break; }
			}

			foreach (var path in benchPaths)
			{
				if (test.BenchPath == path.Name) { pben = new BenchPath(path, components); break; }
			}

			foreach (var path in outputPaths)
			{
				if (test.OutputPath == path.Name) { pout = new OutputPath(path, components); break; }
			}

			pmtrs = GetMetersPath(test);

            if (isHydroTest && (pfeed == null)) errorMsg = Strings.Cannot_load_feeding_path;
            else if (isHydroTest && (pben == null)) errorMsg = Strings.Cannot_load_bench_path;
            else if (isHydroTest && (pout == null)) errorMsg = Strings.Cannot_load_output_path;
            else if (pmtrs == null) errorMsg = Strings.Cannot_load_sensor_path;
            else errorMsg = string.Empty;
            if ((isHydroTest && (pfeed == null || pben == null || pout == null)) || (pmtrs == null))
            {
                log.ErrorFormat("GetPaths({0},...) returns false, wrong configuration", test.Name);
                return false;
            }

#if HEAT_METERS
            foreach (var path in heatMetersPaths)
            {
                if (test.HeatMetersPath == path.Name) { phmtrs = new HeatMetersPath(path, components); break; }
            }
#endif
            if (heatMetersPathRequired && phmtrs == null)
            {
                log.ErrorFormat("GetPaths({0},...) returns false, missing heat meters sensors", test.Name);
                errorMsg = "Cannot load heat meters sensors";
                return false;
            }

            foreach (var tr in TransitionSequences)
			{
				if (tr.Name == test.RelTransBefore) transitionBefore = tr;
                if (tr.Name == test.RelTransBetween) transitionBetween = tr;
                if (tr.Name == test.TransitionAfter) transitionAfter = tr;
			}

            if (isHydroTest && pout.Scale == null)
            {
                log.ErrorFormat("GetPaths({0},...) returns false, missing scales in output path {1}", test.Name, test.OutputPath);
                errorMsg = string.Format("No balance specified in path {0}", test.OutputPath);
                return false;
            }

            if (Config.Formulas.RealDensity() < 500.0f || Config.Formulas.RealDensity() > 2000.0f)
			{
                log.ErrorFormat("GetPaths({0},...) returns false, density was not specified", test.Name);
                errorMsg = string.Format("Density was not specified");
				return false;
			}

            log.WarnFormat("GetPaths({0},...) returns true, paths loaded OK, isHydroTest={1}", test.Name, isHydroTest);
            errorMsg = string.Empty;
            return true;
		}


		/// <summary>
		/// Updates paths based on the selected test
		/// </summary>
		public static MetersPath GetMetersPath(Test test)
		{
			MetersPath pmtrs = null;
			foreach (var path in metersPaths)
			{
				if (test.MetersPath == path.Name) { pmtrs = new MetersPath(path, components); break; }
			}
			if (pmtrs != null)
			{
                int count = Math.Min(Config.Data.WMsCount, pmtrs.RegisterReaders.Length);
				for (int i = 0; i < count; i++)
				{
					if ((pmtrs.RegisterReaders[i] != null) &&
						(pmtrs.RegisterReaders[i].Cfg.DebugLevel == DebugMode.DetectedOff))
					{
						pmtrs.RegisterReaders[i] = null;
					}
				}
			}
			return pmtrs;
		}


        /*
         * This is and example sequence of RunDeviceBefore() / RunOperations() / RunDeviceAfter() calls
         * as they are executed during normal run from the progran start to the end.
         * 
        foreach (var device in devices) device.RunDeviceBefore();  . . . . . .  in StateMachine.Worker()
        State.Create(...).AddOperation(...).AddOperation(...).EnterState() . .  in the sequence in Execute(...)

        foreach (var device in devices) device.RunDeviceAfter(); . . . . . . .  in WaitRunDevsRunOps()
        WaitNextTick()  (may throw QuitStateMachineException)  . . . . . . . .  in WaitRunDevsRunOps()
        foreach (var device in devices) device.RunDeviceBefore();  . . . . . .  in WaitRunDevsRunOps()
        IList<Event> events = State.RunOperations(); . . . . . . . . . . . . .  in WaitRunDevsRunOps()

        foreach (var device in devices) device.RunDeviceAfter(); . . . . . . .  in WaitRunDevsRunOps()
        WaitNextTick()  (may throw QuitStateMachineException)  . . . . . . . .  in WaitRunDevsRunOps()
        foreach (var device in devices) device.RunDeviceBefore();  . . . . . .  in WaitRunDevsRunOps()
        IList<Event> events = State.RunOperations(); . . . . . . . . . . . . .  in WaitRunDevsRunOps()

        State.Create(...).AddOperation(...).AddOperation(...).EnterState() . .  in the sequence in Execute(...)

        foreach (var device in devices) device.RunDeviceAfter(); . . . . . . .  in WaitRunDevsRunOps()
        WaitNextTick()  (may throw QuitStateMachineException)  . . . . . . . .  in WaitRunDevsRunOps()
        foreach (var device in devices) device.RunDeviceBefore();  . . . . . .  in WaitRunDevsRunOps()
        IList<Event> events = State.RunOperations(); . . . . . . . . . . . . .  in WaitRunDevsRunOps()

        foreach (var device in devices) device.RunDeviceAfter(); . . . . . . .  in WaitRunDevsRunOps()
        WaitNextTick()  (assume QuitStateMachineException thrown)  . . . . . .  in WaitRunDevsRunOps()
        State.StopOperations();  . . . . . . . . . . . . . . . . . . . . . . .  in StateMachine.Worker() catch()
        foreach (var device in devices) device.StopDevice(); . . . . . . . . .  in StateMachine.Worker() catch()
        */

        /// <summary>
        /// Worker thread: calls Start(), Run() and Stop() methods of operations.
        /// It uses 'currentState', 'nextState' and 'quitStateMachine' static fields.
        /// </summary>
        static void Worker()
        {
            MachineState = MachineState.Running;
            startDateTime = DateTime.Now;
            CycleStartTimeStamp = startDateTime;	/// Do not leave CycleStartTimeStamp uninitialized
			wlog.InfoFormat("   currentTime = {0}s   startDateTime = {1}", currentTimeSec.ToString(), startDateTime.ToString());

            /// Run all devices for the first time
            foreach (var device in devices) device.RunDeviceBefore();

            SequenceBase.ReferenceFlowmetersCount = SequenceBase.FlowMeters.Count;
            SequenceBase.CalibratedLtrPerRefPulse = new double[SequenceBase.ReferenceFlowmetersCount];
            foreach (var flowmtr in SequenceBase.FlowMeters)
            {
                int ix = flowmtr.Idx1;
                if (ix > 0 && ix <= SequenceBase.ReferenceFlowmetersCount)
                {
                    SequenceBase.CalibratedLtrPerRefPulse[ix - 1] = flowmtr.NominalFlow / 7200.0;
                }
            }

            ///
            /// Run the main sequence
            ///
			(new Sequences.MainSeq()).Execute();

            StateMachine.MachineState = MachineState.Off;                   /// Update StateMachine.MachineState
            TBF.UiBridge.Bridge.Bench2UI(TBF.UiBridge.ButtonsEtc.Shutdown); /// Let UI know the state machine is shut down now
        }


        /// <summary>
        /// Do stuff that is repeated in the state execution loops most often
        /// </summary>
        /// <returns>List of Event-s returned from the state operations, null == quit</returns>
        public static IList<Event> WaitRunDevsRunOps(bool lastTime = false)
        {
            Thread.Sleep(100);      /// Insert 1/10 sec.delay between RunOperations() and RunDeviceAfter()

            foreach (var device in devices)
            {
                device.RunDeviceAfter();
            }
			
            WaitNextTick();

            if (lastTime)
            {
                ///
                /// Executed when the state machine is being stopped
                ///
                State.StopOperations();
				return null;
            }

            foreach (var device in devices)
            {
                device.RunDeviceBefore();
            }

            Thread.Sleep(100);              /// Insert 1/10 sec.delay between RunDeviceBefore() and RunOperations()

            return State.RunOperations();   /// Returns events from all running operations
                                            /// This is followed by a state change in the sequence
        }


        /// <summary>
        /// Wait time period - synchronize
        /// </summary>
        /// <returns>true when interrupted by 'quitStateMachine', otherwise false</returns>
        public static void WaitNextTick()
        {
            currentTimeSec += Period;
            DateTime nextTickDateTime = startDateTime + TimeSpan.FromSeconds(currentTimeSec);

            while (DateTime.Now < nextTickDateTime)
            {
				Thread.Sleep(100);	
            }
        }
    }
}