using DTS.Common.Interface.DASFactory;
using DTS.Common.Interface.DataRecorders;
using DTS.Common.Interface.StatusAndProgressBar;
using DTS.Common.Utilities.Logging;
using Stateless;
using System;
using System.Linq;
using System.Collections.Generic;
using System.Text;
using System.Windows.Forms;
using DTS.Common.Classes.DSP;

namespace DTS.DASLib.Service.StateMachine
{
    public class StateMachineBootstrap
    {
        private StateMachine<IDASState, Trigger> _stateMachine;
        private readonly IDASFactory _dasFactory;
        public StateMachineBootstrap(IDASFactory dasFactory = null)
        {
            //initialize logger
            _logger = new TextLogger(@"Logs\StateMachine.log", OnLoggerException, MAX_LOG_FILE_SIZE);
            _logger.LogStartMessage = GetLogStartMessage();
            APILogger.StateWriter = LogStuff;

            _dasFactory = dasFactory;
            _stateMachine = new StateMachine<IDASState, Trigger>(States.Instance.Prepare);
            States.SetDASFactory(dasFactory);
            Configure();
            APILogger.StateLog("State machine started");
        }
        private void DisplayCurrentState()
        {
            Console.WriteLine($"Current state is {_stateMachine.State.ToString()}");
        }
        /// <summary>
        /// turns off excitation for units in configure state
        /// </summary>
        /// <param name="CompleteAction"></param>
        /// <param name="ProgressAction"></param>
        /// <param name="StatusAction"></param>
        /// <param name="StatusExAction"></param>
        public void TurnOffExcitation(
            ActionCompleteDelegate CompleteAction,
            SetProgressValueDelegate ProgressAction,
            StatusIntDelegate StatusAction,
            StatusExIntDelegate StatusExAction
        )
        {
            var param = States.Instance.ConfigureStart.Status.ConfigureParameters;
            param.SkipTurnOnPower = true;
            var status = States.Instance.ConfigureStart.Status.ConfigureStatus;
            //if we are running, wait till complete to do go to low power
            status.DoneEvent.WaitOne();

            //now make sure we aren't running ...            
            param.TurnOffExcitation = true;

            status.CompleteAction = () =>
            {
                APILogger.StateLog($"Complete");
                _stateMachine.Fire(Trigger.Finish);
                CompleteAction?.Invoke();
            };
            status.ProgressAction = (double d) =>
            {
                APILogger.StateLog($"Progress: {d}");
                ProgressAction?.Invoke(d);
            };

            status.StatusAction = (int iState) =>
            {
                var statusEnum = (ConfigureStatusInformation.StatusValues)iState;
                APILogger.StateLog($"StatusAction: {statusEnum.ToString()}");
                StatusAction?.Invoke(iState);
            };

            status.StatusExAction = (int iState, object[] objParams) =>
            {
                var statusEnum = (ConfigureStatusInformation.StatusValues)iState;

                APILogger.StateLog(ParamsToString($"StatusEx: {statusEnum.ToString()}", objParams));
                StatusExAction?.Invoke(iState, objParams);
            };

            APILogger.StateLog($"CurrentState: {_stateMachine.State.ToString()}");
            APILogger.StateLog($"Params: {param.ToString()}");
            APILogger.StateLog($"Trigger: {Trigger.TurnOffExcitation.ToString()}");

            _stateMachine.FireAsync(Trigger.TurnOffExcitation);
        }
        /// <summary>
        /// turns on excitation for units in configure state
        /// </summary>
        /// <param name="ErrorRequiringActionAction"></param>
        /// <param name="CompleteAction"></param>
        /// <param name="ProgressAction"></param>
        /// <param name="StatusAction"></param>
        /// <param name="StatusExAction"></param>
        public void PrepareForDiagnostics(
            ErrorCallback ErrorRequiringActionAction,
            ActionCompleteDelegate CompleteAction,
            SetProgressValueDelegate ProgressAction,
            StatusIntDelegate StatusAction,
            StatusExIntDelegate StatusExAction
        )
        {
            var param = States.Instance.ConfigureStart.Status.ConfigureParameters;
            param.ErrorRequiringActionAction = ErrorRequiringActionAction;
            param.SetConfiguration = false;
            param.SkipTurnOnPower = false;
            param.PrepareForDiagnostics = true;

            var status = States.Instance.ConfigureStart.Status.ConfigureStatus;
            status.CompleteAction = () =>
            {
                APILogger.StateLog($"Complete");
                _stateMachine.Fire(Trigger.Finish);
                CompleteAction?.Invoke();
            };
            status.ProgressAction = (double d) =>
            {
                APILogger.StateLog($"Progress: {d}");
                ProgressAction?.Invoke(d);
            };

            status.StatusAction = (int iState) =>
            {
                var statusEnum = (ConfigureStatusInformation.StatusValues)iState;
                APILogger.StateLog($"StatusAction: {statusEnum.ToString()}");
                StatusAction?.Invoke(iState);
            };

            status.StatusExAction = (int iState, object[] objParams) =>
            {
                var statusEnum = (ConfigureStatusInformation.StatusValues)iState;

                APILogger.StateLog(ParamsToString($"StatusEx: {statusEnum.ToString()}", objParams));
                StatusExAction?.Invoke(iState, objParams);
            };

            APILogger.StateLog($"CurrentState: {_stateMachine.State.ToString()}");
            APILogger.StateLog($"Params: {param.ToString()}");
            APILogger.StateLog($"Trigger: {Trigger.ApplyConfiguration.ToString()}");

            _stateMachine.FireAsync(Trigger.ApplyConfiguration);
        }

        /// <summary>
        /// updates the config for units in configure state
        /// optionally turns on excitation
        /// </summary>
        /// <param name="ResetEventLines"></param>
        /// <param name="PrepareForDiagnostics"></param>
        /// <param name="ConfigureDigitalOutputs"></param>
        /// <param name="DoStrictCheck"></param>
        /// <param name="DummyConfig"></param>
        /// <param name="EventConfig"></param>
        /// <param name="maxAAF"></param>
        /// <param name="TurnOffAAFRealtime"></param>
        /// <param name="SkipTurnOnPower"></param>
        /// <param name="UnitsToConfigure"></param>
        /// <param name="SampleRateLookup"></param>
        /// <param name="AAFRateLookup"></param>
        /// <param name="ErrorRequiringActionAction"></param>
        /// <param name="CompleteAction"></param>
        /// <param name="ProgressAction"></param>
        /// <param name="StatusAction"></param>
        /// <param name="StatusExAction"></param>
        public void UpdateConfig(
            bool ResetEventLines,
            bool PrepareForDiagnostics,
            bool ConfigureDigitalOutputs,
            bool DoStrictCheck,
            bool DummyConfig,
            bool EventConfig,
            double[] maxAAF,
            bool TurnOffAAFRealtime,
            bool SkipTurnOnPower,
            IDASCommunication[] UnitsToConfigure,
            IReadOnlyDictionary<string, double> SampleRateLookup,
            IReadOnlyDictionary<string, float> AAFRateLookup,
            ErrorCallback ErrorRequiringActionAction,
            ActionCompleteDelegate CompleteAction,
            SetProgressValueDelegate ProgressAction,
            StatusIntDelegate StatusAction,
            StatusExIntDelegate StatusExAction,
            DSPFilterType dspFilterType
            )
        {            
            var param = States.Instance.ConfigureStart.Status.ConfigureParameters;
            param.ResetHardwareEventLines = ResetEventLines;
            param.PrepareForDiagnostics = PrepareForDiagnostics;
            param.UnitsToConfigure = UnitsToConfigure;
            param.ConfigureDigitalOutputs = ConfigureDigitalOutputs;
            param.ErrorRequiringActionAction = ErrorRequiringActionAction;
            param.DoStrictCheck = DoStrictCheck;
            param.DummyConfig = DummyConfig;
            param.EventConfig = EventConfig;
            param.TurnOffAAFRealtime = TurnOffAAFRealtime;
            param.MaxAAF = maxAAF;
            param.SampleRateLookup = SampleRateLookup;
            param.AAFRateLookup = AAFRateLookup;
            param.SkipTurnOnPower = SkipTurnOnPower;
            param.DSPFilterType = dspFilterType;

            var status = States.Instance.ConfigureStart.Status.ConfigureStatus;
            status.CompleteAction = () =>
            {
                APILogger.StateLog($"Complete");
                _stateMachine.Fire(Trigger.Finish);
                CompleteAction?.Invoke();
            };
            status.ProgressAction = (double d) =>
            {
                APILogger.StateLog($"Progress: {d}");
                ProgressAction?.Invoke(d);
            };

            status.StatusAction = (int iState) =>
            {
                var statusEnum = (ConfigureStatusInformation.StatusValues)iState;
                APILogger.StateLog($"StatusAction: {statusEnum.ToString()}");
                StatusAction?.Invoke(iState);
            };

            status.StatusExAction = (int iState, object[] objParams) =>
            {
                var statusEnum = (ConfigureStatusInformation.StatusValues)iState;

                APILogger.StateLog(ParamsToString($"StatusEx: {statusEnum.ToString()}", objParams));
                StatusExAction?.Invoke(iState, objParams);
            };

            APILogger.StateLog($"CurrentState: {_stateMachine.State.ToString()}");
            APILogger.StateLog($"Params: {param.ToString()}");
            APILogger.StateLog($"Trigger: {Trigger.ApplyConfiguration.ToString()}");
            _stateMachine.FireAsync(Trigger.ApplyConfiguration);
        }
        /// <summary>
        /// turns an array of generic parameters into a single string for logging
        /// </summary>
        /// <param name="prepend"></param>
        /// <param name="objParams"></param>
        /// <returns></returns>
        private string ParamsToString(string prepend, object[] objParams)
        {
            var sb = new StringBuilder();
            sb.Append(prepend);
            foreach (var obj in objParams)
            {
                sb.Append(", ");
                switch (obj)
                {
                    case Common.Utils.Entry entry:
                        sb.Append(entry.IPAddress);
                        break;
                    case IDASCommunication das:
                        sb.Append(das.SerialNumber);
                        break;
                    case IDASHardware hardware:
                        sb.Append(hardware.SerialNumber);
                        break;
                    default:
                        sb.Append(obj.ToString());
                        break;
                }

            }

            return sb.ToString();
        }
        /// <summary>
        /// max size (bytes?) for state machine log
        /// </summary>
        private const int MAX_LOG_FILE_SIZE = 4194304;
        /// <summary>
        /// the state machine logger itself
        /// </summary>
        private static TextLogger _logger;
        /// <summary>
        /// any additional work needed to done to log a message
        /// </summary>
        /// <param name="message"></param>
        private void LogStuff(string message)
        {
            try
            {
                _logger?.LogMessage(message);
            }
            catch (Exception)
            {
            }
        }
        /// <summary>
        /// the prepend to a new state machine log
        /// </summary>
        /// <returns></returns>
        private string GetLogStartMessage()
        {
            return string.Format($"Application: StateMachine{Environment.NewLine}OS:          {Environment.OSVersion}{Environment.NewLine}MachineName: {Environment.MachineName}{Environment.NewLine}Environment: {Environment.Version}{Environment.NewLine}=================================================================={Environment.NewLine}");
        }
        /// <summary>
        /// what to do if there's an exception while logging
        /// </summary>
        /// <param name="ex"></param>
        private static void OnLoggerException(Exception ex)
        {
            System.Diagnostics.Trace.WriteLine(ex.ToString());
        }

        /// <summary>
        /// pings, connects, and checks out hardware (firmware/version/status/channels, etc)
        /// </summary>
        /// <param name="Addresses"></param>
        /// <param name="AddressRanges"></param>
        /// <param name="GoToDownload"></param>
        /// <param name="KnownSLICEIPAddresses"></param>
        /// <param name="KnownTDASIPAddresses"></param>
        /// <param name="ProceedWhenDone"></param>
        /// <param name="ReadIds"></param>
        /// <param name="RequireAllDASFound"></param>
        /// <param name="RunAutoSense"></param>
        /// <param name="UseUDPDiscovery"></param>
        /// <param name="RequiredSerials"></param>
        /// <param name="CalDateExpiredQuery"></param>
        /// <param name="ExpectedHardware"></param>
        /// <param name="UnitExpectedFirmwareQuery"></param>
        /// <param name="UnitExpectedMaxMemoryQuery"></param>
        /// <param name="UnitIsInDbQuery"></param>
        /// <param name="UpdateMaxMemoryAction"></param>
        /// <param name="CompleteAction"></param>
        /// <param name="ProgressAction"></param>
        /// <param name="StatusAction"></param>
        /// <param name="StatusExAction"></param>
        public void PingAndConnectAndCheckHardware(
            string[] Addresses,
            Tuple<string, string>[] AddressRanges,
            bool GoToDownload,
            string[] KnownSLICEIPAddresses,
            string[] KnownTDASIPAddresses,
            bool ProceedWhenDone,
            bool ReadIds,
            bool RequireAllDASFound,
            bool RunAutoSense,
            bool UseUDPDiscovery,
            string[] RequiredSerials,
            HardwareDiscoveryParameters.IsCalDateExpiredDelegate CalDateExpiredQuery,
            IDASHardware[] ExpectedHardware,
            HardwareDiscoveryParameters.FirmwareExpectedVersionDelegate UnitExpectedFirmwareQuery,
            HardwareDiscoveryParameters.UnitExpectedMaxMemoryDelegate UnitExpectedMaxMemoryQuery,
            HardwareDiscoveryParameters.UnitIsInDbDelegate UnitIsInDbQuery,
            HardwareDiscoveryParameters.UpdateMaxMemoryDelegate UpdateMaxMemoryAction,
            ActionCompleteDelegate CompleteAction,
            SetProgressValueDelegate ProgressAction,
            StatusIntDelegate StatusAction,
            StatusExIntDelegate StatusExAction)
        {
            var param = GetPingAndConnectParameters();
            param.Addresses = Addresses;
            param.AddressRanges = AddressRanges;
            param.Connect = true;
            param.GoToDownload = GoToDownload;
            param.KnownSLICEIPAddresses = KnownSLICEIPAddresses;
            param.KnownTDASIPAddresses = KnownTDASIPAddresses;
            param.ProceedWhenDone = ProceedWhenDone;
            param.ReadIds = ReadIds;
            param.RequireAllDASFound = RequireAllDASFound;
            param.RunAutoSense = RunAutoSense;
            param.UseMulticastDiscover = UseUDPDiscovery;
            param.RequeryDevice = null;
            param.RequiredSerials = RequiredSerials;
            param.DoHardwareChecks = true;
            param.CalDateExpiredQuery = CalDateExpiredQuery;
            param.ExpectedHardware = ExpectedHardware;
            param.UnitExpectedFirmwareQuery = UnitExpectedFirmwareQuery;
            param.UnitExpectedMaxMemoryQuery = UnitExpectedMaxMemoryQuery;
            param.UnitIsInDbQuery = UnitIsInDbQuery;
            param.UpdateMaxMemoryAction = UpdateMaxMemoryAction;

            var status = GetPingAndConnectStatus();
            status.CompleteAction = () =>
            {
                APILogger.StateLog("Finished");
                _stateMachine.Fire(Trigger.Finish);
                CompleteAction?.Invoke();
            };
            status.ProgressAction = (double d) =>
            {
                APILogger.StateLog($"Progress: {d}");
                ProgressAction?.Invoke(d);
            };
            status.StatusAction = (int iStatus) =>
            {
                var statusEnum = (HardwareDiscoveryStatusInfo.StatusValues)iStatus;
                APILogger.StateLog($"Status: {statusEnum.ToString()}");
                StatusAction?.Invoke(iStatus);
            };
            status.StatusExAction = (int iStatus, object[] objParams) =>
            {
                var statusEnum = (HardwareDiscoveryStatusInfo.StatusValues)iStatus;
                APILogger.StateLog(ParamsToString($"StatusEx: {statusEnum.ToString()}", objParams));
                StatusExAction?.Invoke(iStatus, objParams);
            };
            APILogger.StateLog($"CurrentState: {_stateMachine.State.ToString()}");
            APILogger.StateLog($"Params: {param.ToString()}");
            APILogger.StateLog($"Trigger: {Trigger.PingAndConnect.ToString()}");
            _stateMachine.FireAsync(Trigger.PingAndConnect);
        }

        /// <summary>
        /// just pings and connects to hardware
        /// </summary>
        /// <param name="Addresses"></param>
        /// <param name="AddressRanges"></param>
        /// <param name="GoToDownload"></param>
        /// <param name="KnownSLICEIPAddresses"></param>
        /// <param name="KnownTDASIPAddresses"></param>
        /// <param name="ProceedWhenDone"></param>
        /// <param name="ReadIds"></param>
        /// <param name="RequireAllDASFound"></param>
        /// <param name="RunAutoSense"></param>
        /// <param name="UseUDPDiscovery"></param>
        /// <param name="RequiredSerials"></param>
        /// <param name="CompleteAction"></param>
        /// <param name="ProgressAction"></param>
        /// <param name="StatusAction"></param>
        /// <param name="StatusExAction"></param>
        public void PingAndConnect(
            string[] Addresses,
            Tuple<string, string>[] AddressRanges,
            bool GoToDownload,
            string[] KnownSLICEIPAddresses,
            string[] KnownTDASIPAddresses,
            bool ProceedWhenDone,
            bool ReadIds,
            bool RequireAllDASFound,
            bool RunAutoSense,
            bool UseUDPDiscovery,
            string[] RequiredSerials,
            ActionCompleteDelegate CompleteAction,
            SetProgressValueDelegate ProgressAction,
            StatusIntDelegate StatusAction,
            StatusExIntDelegate StatusExAction
        )
        {
            var param = GetPingAndConnectParameters();
            param.Addresses = Addresses;
            param.AddressRanges = AddressRanges;
            param.Connect = true;
            param.GoToDownload = GoToDownload;
            param.KnownSLICEIPAddresses = KnownSLICEIPAddresses;
            param.KnownTDASIPAddresses = KnownTDASIPAddresses;
            param.ProceedWhenDone = ProceedWhenDone;
            param.ReadIds = ReadIds;
            param.RequireAllDASFound = RequireAllDASFound;
            param.RunAutoSense = RunAutoSense;
            param.UseMulticastDiscover = UseUDPDiscovery;
            param.RequeryDevice = null;
            param.RequiredSerials = RequiredSerials;
            param.DoHardwareChecks = false;
            var status = GetPingAndConnectStatus();
            status.CompleteAction = () =>
            {
                APILogger.StateLog("Finished");
                _stateMachine.Fire(Trigger.Finish);
                CompleteAction?.Invoke();
            };
            status.ProgressAction = (double d) =>
            {
                APILogger.StateLog($"Progress: {d}");
                ProgressAction?.Invoke(d);
            };
            status.StatusAction = (int iStatus) =>
            {
                var statusEnum = (HardwareDiscoveryStatusInfo.StatusValues)iStatus;
                APILogger.StateLog($"Status: {statusEnum.ToString()}");
                StatusAction?.Invoke(iStatus);
            };
            status.StatusExAction = (int iStatus, object[] objParams) =>
            {
                var statusEnum = (HardwareDiscoveryStatusInfo.StatusValues)iStatus;
                APILogger.StateLog(ParamsToString($"StatusEx: {statusEnum.ToString()}", objParams));
                StatusExAction?.Invoke(iStatus, objParams);
            };
            APILogger.StateLog($"CurrentState: {_stateMachine.State.ToString()}");
            APILogger.StateLog($"Params: {param.ToString()}");
            APILogger.StateLog($"Trigger: {Trigger.PingAndConnect.ToString()}");
            _stateMachine.FireAsync(Trigger.PingAndConnect);
        }

        /// <summary>
        /// requires one specific already connected device
        /// used by hardware discovery tile when a device is reconfigured
        /// </summary>
        /// <param name="device"></param>
        /// <param name="CompleteAction"></param>
        /// <param name="ProgressAction"></param>
        /// <param name="StatusAction"></param>
        /// <param name="StatusExAction"></param>
        public void RequeryDevice(
            IDASCommunication device,
            ActionCompleteDelegate CompleteAction,
            SetProgressValueDelegate ProgressAction,
            StatusIntDelegate StatusAction,
            StatusExIntDelegate StatusExAction)
        {
            var param = GetPingAndConnectParameters();
            param.RequeryDevice = device;
            param.ReadIds = false;
            var status = GetPingAndConnectStatus();
            status.CompleteAction = () =>
            {
                APILogger.StateLog("Finished");
                _stateMachine.Fire(Trigger.Finish);
                CompleteAction?.Invoke();
                param.RequeryDevice = null;
            };
            status.ProgressAction = (double d) =>
            {
                APILogger.StateLog($"Progress: {d}");
                ProgressAction?.Invoke(d);
            };
            status.StatusAction = (int iStatus) =>
            {
                var statusEnum = (HardwareDiscoveryStatusInfo.StatusValues)iStatus;
                APILogger.StateLog($"{statusEnum.ToString()}");
                StatusAction?.Invoke(iStatus);
            };
            status.StatusExAction = (int iStatus, object[] objParams) =>
            {
                var statusEnum = (HardwareDiscoveryStatusInfo.StatusValues)iStatus;
                APILogger.StateLog(ParamsToString($"StatusEx: {statusEnum.ToString()}", objParams));
                StatusExAction?.Invoke(iStatus, objParams);
            };
            APILogger.StateLog($"CurrentState: {_stateMachine.State.ToString()}");
            APILogger.StateLog($"Params: {param.ToString()}");
            APILogger.StateLog($"Trigger: {Trigger.RequeryDevice.ToString()}");
            _stateMachine.FireAsync(Trigger.RequeryDevice);
        }

        public void StopRealtime()
        {
            GetRealtimeStatus().StopRealtime();
        }

        public bool IsInRealtime
        {
            get
            {
                return GetRealtimeStatus().IsInRealtime;
            }
        }

        public void StartRealtime(List<IDASCommunication> ldas, List<int> moduleIndicies, bool useSingleSampleMode,
          double realtimeSampleRate, int realtimeDelayBetweenPolls, bool allowMultipleSampleRealtime, byte realtimeSampleRateAAFilterRatio, bool sliceTurnOffAAFRealtime,
           Action<double, double> SetRealtimeSampleRateAAF, Action CompleteAction,
           Dictionary<IDASCommunication, byte[]> idasToActiveChannels, ServiceBase.Callback StartRealtimeCallback
           )
        {
            var param = GetRealtimeParameters();
            var status = GetRealtimeStatus();
            param.UnitsToStartRealtime = ldas;
            param.ModuleIndices = moduleIndicies;
            param.UseSingleSampleMode = useSingleSampleMode;
            param.RealtimeSampleRate = realtimeSampleRate;
            param.RealtimeDelayBetweenPollsInMilliSecond = realtimeDelayBetweenPolls;
            param.AllowMultipleSampleRealtime = allowMultipleSampleRealtime;
            param.IdasToActiveChannels = idasToActiveChannels;
            param.RealtimeSampleRateAAFilterRatio = realtimeSampleRateAAFilterRatio;
            param.SliceTurnOffAAFRealtime = sliceTurnOffAAFRealtime;

            status.CompleteAction = () =>
            {
                _stateMachine.Fire(Trigger.Finish);
                CompleteAction?.Invoke();
            };
            status.SetRealtimeSampleRateAAF = SetRealtimeSampleRateAAF;
            status.StartRealtimeCallback = StartRealtimeCallback;
            _stateMachine.FireAsync(Trigger.StartRealtime);
        }

        /// <summary>
        /// pings but does not connect
        /// </summary>
        /// <param name="UseUDPDiscovery">whether UDP multicast discovery should be used</param>
        /// <param name="ipAddresses">specific ips that should be pinged</param>
        /// <param name="ipRanges">ranges of ips that should be pinged (aaa.bbb.ccc.xxx : aa.bb.cc.yyy)</param>
        /// <param name="CompleteAction">action to take on completion</param>
        /// <param name="ProgressAction">action to be taken on progress</param>
        /// <param name="StatusAction">action to take on status change</param>
        /// <param name="StatusExAction">action to take on status change with extended info</param>
        public void Ping(
            bool UseUDPDiscovery,
            string[] ipAddresses,
            Tuple<string, string>[] ipRanges,
            ActionCompleteDelegate CompleteAction,
            SetProgressValueDelegate ProgressAction,
            StatusIntDelegate StatusAction,
            StatusExIntDelegate StatusExAction
            )
        {
            var param = GetPingAndConnectParameters();
            var status = GetPingAndConnectStatus();
            param.Addresses = ipAddresses;
            param.AddressRanges = ipRanges;
            param.GoToDownload = false;
            param.ProceedWhenDone = false;
            param.RequireAllDASFound = false;
            param.GoToDownload = false;
            param.Connect = false;
            param.UseMulticastDiscover = UseUDPDiscovery;
            param.RequeryDevice = null;
            status.CompleteAction = () =>
            {
                APILogger.StateLog($"Finished");
                _stateMachine.Fire(Trigger.Finish);
                CompleteAction?.Invoke();
            };
            status.ProgressAction = (double d) =>
            {
                APILogger.StateLog($"Progress: {d}");
                ProgressAction?.Invoke(d);
            };
            status.StatusAction = (int iStatus) =>
            {
                var statusEnum = (HardwareDiscoveryStatusInfo.StatusValues)iStatus;
                APILogger.StateLog($"{statusEnum.ToString()}");
                StatusAction?.Invoke(iStatus);
            };
            status.StatusExAction = (int iStatus, object[] objParams) =>
            {
                var statusEnum = (HardwareDiscoveryStatusInfo.StatusValues)iStatus;
                APILogger.StateLog(ParamsToString($"StatusEx: {statusEnum.ToString()}", objParams));
                StatusExAction?.Invoke(iStatus, objParams);
            };
            APILogger.StateLog($"CurrentState: {_stateMachine.State.ToString()}");
            APILogger.StateLog($"Params: {param.ToString()}");
            APILogger.StateLog($"Trigger: {Trigger.PingAndConnect.ToString()}");
            _stateMachine.FireAsync(Trigger.PingAndConnect);
        }


        private void PingAndConnect(bool bProceedWhenDone, bool useMulticast, Tuple<string, string> ipRanges, bool connect)
        {
            var pingParam = GetPingAndConnectParameters();
            pingParam.ProceedWhenDone = bProceedWhenDone;
            pingParam.UseMulticastDiscover = useMulticast;
            pingParam.AddressRanges = new[] { ipRanges };
            pingParam.Connect = connect;
            pingParam.RequeryDevice = null;
            var status = GetPingAndConnectStatus();
            status.CompleteAction = () =>
            {
                _stateMachine.Fire(Trigger.Finish);
            };
            status.ProgressAction = (double d) => { Console.WriteLine($"{d}%"); };
            status.StatusAction = (int iStatus) =>
            {
                var statusEnum = (HardwareDiscoveryStatusInfo.StatusValues)iStatus;
                Console.WriteLine($"{statusEnum.ToString()}");
            };
            status.StatusExAction = (int iStatus, object[] param) =>
            {
                var statusEnum = (HardwareDiscoveryStatusInfo.StatusValues)iStatus;
                switch (statusEnum)
                {
                    case HardwareDiscoveryStatusInfo.StatusValues.DiscoveredDevice:
                        var device = (IDiscoveredDevice)param[0];
                        Console.WriteLine($"Discovered {device.Serial}");
                        break;
                    case HardwareDiscoveryStatusInfo.StatusValues.PingStatus:
                        var entry = (Common.Utils.Entry)param[0];
                        var pingStatus = (Common.Utils.PingProgressStates)param[1];
                        var roundTrip = (long)param[2];
                        Console.WriteLine($"Ping: {entry.IPAddress}, {pingStatus.ToString()}, {roundTrip}");
                        break;
                    case HardwareDiscoveryStatusInfo.StatusValues.Connecting:
                        Console.WriteLine($"Connecting: {param[0]}");
                        break;
                    case HardwareDiscoveryStatusInfo.StatusValues.Connected:
                        Console.WriteLine($"Connected: {param[0]}");
                        break;
                }
            };
            _stateMachine.FireAsync(Trigger.PingAndConnect);
        }

        private ConfigureStatusInformation GetConfigureStatus()
        {
            return States.Instance.Configure.Status.ConfigureStatus;
        }

        private ConfigureStatusParameters GetConfigureParameters()
        {
            return States.Instance.Configure.Status.ConfigureParameters;
        }
        private DiagnoseParameters GetDiagnoseParameters()
        {
            return States.Instance.Diagnose.Status.DiagnoseParams;
        }
        private HardwareDiscoveryParameters GetPingAndConnectParameters()
        {
            return States.Instance.HardwareDiscovery.Status.HardwareDiscoveryParams;
        }
        private HardwareDiscoveryStatusInfo GetPingAndConnectStatus()
        {
            return States.Instance.HardwareDiscovery.Status.HardwareDiscoveryStatusInfo;
        }
        private RealtimeParameters GetRealtimeParameters()
        {
            return States.Instance.Realtime.Status.RealtimeParams;
        }
        private RealtimeStatusInformation GetRealtimeStatus()
        {
            return States.Instance.Realtime.Status.RealtimeStatus;
        }

        /// <summary>
        /// resets the state machine to the start
        /// </summary>
        public void Reset()
        {
            _stateMachine.Fire(Trigger.Reset);
            //all the states share the same status reference right now
            States.Instance.HardwareDiscovery.Status.Reset();
        }

        /// <summary>
        /// Configure the state machine
        /// </summary>
        private void Configure()
        {
            States.SetDASFactory(_dasFactory);
            //--------------------PREPARE------------------
            _stateMachine.Configure(States.Instance.Prepare)
                .OnEntry(States.Instance.Prepare.OnEntry)
                .OnExit(States.Instance.Prepare.OnExit)
                .PermitReentry(Trigger.Reset)
                .Permit(Trigger.PingAndConnect, States.Instance.HardwareDiscoveryStart);

            //--------------------HardwareDiscovery------------------
            _stateMachine.Configure(States.Instance.HardwareDiscoveryStart)
                .OnEntry(States.Instance.HardwareDiscoveryStart.OnEntry)
                .SubstateOf(States.Instance.HardwareDiscovery)
                .Permit(Trigger.Cancel, States.Instance.HardwareDiscovery)
                .PermitDynamicIf(Trigger.Finish, States.Instance.HardwareDiscoveryStart.StateSelector)
                .Permit(Trigger.Reset, States.Instance.Prepare);

            _stateMachine.Configure(States.Instance.HardwareDiscovery)
                .OnEntry(States.Instance.HardwareDiscovery.OnEntry)
                .OnExit(States.Instance.HardwareDiscovery.OnExit)
                .Permit(Trigger.PingAndConnect, States.Instance.HardwareDiscoveryStart)
                .Permit(Trigger.RequeryDevice, States.Instance.HardwareDiscoveryStart)
                .Permit(Trigger.ApplyConfiguration, States.Instance.ConfigureStart)
                .Permit(Trigger.Reset, States.Instance.Prepare);

            //--------------------Configure------------------
            _stateMachine.Configure(States.Instance.Configure)
                .OnEntry(States.Instance.Configure.OnEntry)
                .OnExit(States.Instance.Configure.OnExit)
                //trigger resolve channels can be sent by application (or application could just use apply configuration itself)
                //auto is work done by the application
                .PermitReentry(Trigger.ResolveChannelsAuto)
                //trigger resolve channels can be sent by application, this is after work done by the user
                .PermitReentry(Trigger.ResolveChannelsManual)
                .Permit(Trigger.ApplyConfiguration, States.Instance.ConfigureStart)
                .Permit(Trigger.TurnOffExcitation, States.Instance.ConfigureStart)
                .Permit(Trigger.Reset, States.Instance.Prepare);

            _stateMachine.Configure(States.Instance.ConfigureStart)
                .SubstateOf(States.Instance.Configure)
                .OnEntry(States.Instance.ConfigureStart.OnEntry)
                .OnExit(States.Instance.ConfigureStart.OnExit)
                .Permit(Trigger.Cancel, States.Instance.Configure)
                .Permit(Trigger.Reset, States.Instance.Prepare)
                .Permit(Trigger.Finish, States.Instance.Configure);

            //--------------------Diagnose------------------
            _stateMachine.Configure(States.Instance.Diagnose)
                .OnEntry(States.Instance.Diagnose.OnEntry)
                .OnExit(States.Instance.Diagnose.OnExit)
                .PermitDynamicIf(Trigger.StartRealtime, States.Instance.Diagnose.StateSelector)
                .Permit(Trigger.Reset, States.Instance.Prepare);

            //--------------------Realtime------------------
            _stateMachine.Configure(States.Instance.RealtimeStart)
              .SubstateOf(States.Instance.Realtime)
              .OnEntry(States.Instance.RealtimeStart.OnEntry)
              .PermitDynamicIf(Trigger.Finish, States.Instance.RealtimeStart.StateSelector)
              .Permit(Trigger.Reset, States.Instance.Prepare);

            _stateMachine.Configure(States.Instance.Realtime)
                .OnEntry(States.Instance.Realtime.OnEntry)
                .Permit(Trigger.Arm, States.Instance.Arming)
                .Permit(Trigger.Reset, States.Instance.Prepare);

            //--------------------Download------------------
            //_stateMachine.Configure(States.Instance.Download)
            //    .OnEntry(States.Instance.Download.OnEntry)
            //    .Permit(Trigger.Download, States.Instance.DownloadStart)
            //    .Permit(Trigger.Reset, States.Instance.Prepare);

            //_stateMachine.Configure(States.Instance.DownloadStart)
            //    .SubstateOf(States.Instance.Download)
            //    .OnEntry(States.Instance.DownloadStart.OnEntry)
            //    .OnExit(States.Instance.DownloadStart.OnExit)
            //    .Permit(Trigger.Cancel, States.Instance.Download)
            //    .Permit(Trigger.Reset, States.Instance.Prepare)
            //    .Permit(Trigger.Finish, States.Instance.Download);

            GenerateStateMachineGraph();
        }

        private void GenerateStateMachineGraph()
        {
            //Output this value to a file and use a DOT graph renderer tool to create a visual representation of the state machine "dot -T pdf -o DAS.pdf DAS.dot"
            string graph = Stateless.Graph.UmlDotGraph.Format(_stateMachine.GetInfo());
            graph = graph.Replace("DTS.DASLib.Service.StateMachine.", "");
        }


        public void Start()
        {
            DisplayCurrentState();
            _stateMachine.Fire(Trigger.Reset);
            SimulatePingAndConnectWithCancel();
            Reset();
            SimulatePingAndConnectComplete();
            Reset();
            BasicInfoToDiagnostics();
            Reset();
            BasicInfoToRealtime();
            Reset();

        }

        private void SimulatePingAndConnectComplete()
        {
            GetConfigureStatus().StatusAction = (int i) =>
            {
                var status = (ConfigureStatusInformation.StatusValues)i;
                Console.WriteLine($"{status.ToString()}");
            };
            GetConfigureStatus().ProgressAction = (double d) => { Console.WriteLine($"{d}%"); };

            DisplayCurrentState();
            PingAndConnect(true, true, new Tuple<string, string>("192.168.1.95", "192.168.1.97"), true);
            GetPingAndConnectStatus().DoneEvent.WaitOne();
            System.Threading.Thread.Sleep(100);
            DisplayCurrentState();
        }
        private void SimulatePingAndConnectWithCancel()
        {
            GetConfigureStatus().StatusAction = (int i) =>
            {
                var status = (ConfigureStatusInformation.StatusValues)i;
                Console.WriteLine($"{status.ToString()}");
            };
            GetConfigureStatus().ProgressAction = (double d) => { Console.WriteLine($"{d}%"); };
            DisplayCurrentState();
            //Fire the trigger            
            PingAndConnect(false, true, new Tuple<string, string>("192.168.1.95", "192.168.1.97"), true);
            DisplayCurrentState();
            //allow ping thread to work before canceling
            System.Threading.Thread.Sleep(2000);
            _stateMachine.FireAsync(Trigger.Cancel);
            DisplayCurrentState();
            GetPingAndConnectStatus().Cancel();
            DisplayCurrentState();
        }

        private void BasicInfoToDiagnostics()
        {
            GetConfigureStatus().StatusAction = (int i) =>
            {
                var status = (ConfigureStatusInformation.StatusValues)i;
                Console.WriteLine($"{status.ToString()}");
            };
            GetConfigureStatus().ProgressAction = (double d) => { Console.WriteLine($"{d}%"); };

            GetConfigureStatus().StatusExAction = (int status, object[] param) =>
            {
                var state = (ConfigureStatusInformation.StatusValues)status;
                Console.Write($"{state.ToString()} ");
                foreach (var o in param)
                {
                    if (o is IDASCommunication idas)
                    {
                        Console.Write($"{idas.SerialNumber} ");
                    }
                    if (o is Exception ex)
                    {
                        Console.Write($"{ex.Message}");
                    }

                    if (o is string s)
                    {
                        Console.Write(s);
                    }
                }
                Console.WriteLine();
            };

            GetPingAndConnectParameters().ReadIds = true;
            GetPingAndConnectParameters().RequireAllDASFound = false;
            DisplayCurrentState(); //prepare
            PingAndConnect(true, true, new Tuple<string, string>("192.168.1.95", "192.168.1.97"), true);
            DisplayCurrentState(); //HardwareDiscoveryStart
            GetPingAndConnectStatus().DoneEvent.WaitOne();
            System.Threading.Thread.Sleep(100);
            DisplayCurrentState();
            //Configure
            ResolveChannelsAuto();
            DisplayCurrentState();
            //configure
            ResolveChannelsManual();
            DisplayCurrentState();
            //configure
            ApplyConfiguration();
            DisplayCurrentState();
            //ConfigureStart
            GetConfigureStatus().DoneEvent.WaitOne();
            System.Threading.Thread.Sleep(100);
            DisplayCurrentState();
            //Diagnos
        }

        private void BasicInfoToRealtime()
        {
            GetConfigureStatus().StatusAction = (int i) =>
            {
                var status = (ConfigureStatusInformation.StatusValues)i;
                Console.WriteLine($"{status.ToString()}");
            };
            GetConfigureStatus().ProgressAction = (double d) => { Console.WriteLine($"{d}%"); };

            GetConfigureStatus().StatusExAction = (int status, object[] param) =>
            {
                var state = (ConfigureStatusInformation.StatusValues)status;
                Console.Write($"{state.ToString()} ");
                foreach (var o in param)
                {
                    if (o is IDASCommunication idas)
                    {
                        Console.Write($"{idas.SerialNumber} ");
                    }
                    if (o is Exception ex)
                    {
                        Console.Write($"{ex.Message}");
                    }

                    if (o is string s)
                    {
                        Console.Write(s);
                    }
                }
                Console.WriteLine();
            };

            GetPingAndConnectParameters().ReadIds = true;
            GetPingAndConnectParameters().RequireAllDASFound = false;
            DisplayCurrentState(); //prepare
            PingAndConnect(true, true, new Tuple<string, string>("192.168.1.95", "192.168.1.97"), true);
            DisplayCurrentState(); //HardwareDiscoveryStart
            GetPingAndConnectStatus().DoneEvent.WaitOne();
            System.Threading.Thread.Sleep(100);
            DisplayCurrentState();
            //Configure
            ResolveChannelsAuto();
            DisplayCurrentState();
            //configure
            ResolveChannelsManual();
            DisplayCurrentState();
            //configure
            ApplyConfiguration();
            DisplayCurrentState();
            //ConfigureStart
            GetConfigureStatus().DoneEvent.WaitOne();
            System.Threading.Thread.Sleep(100);
            DisplayCurrentState();
            //Diagnos

            //Realtime
            StartAndStopRealtime();
            DisplayCurrentState();
        }

        private void StartAndStopRealtime()
        {
            var diagParam = GetDiagnoseParameters();
            diagParam.ProceedToRealtimeWhenDone = true;
            diagParam.AllUnitsPassedDiagnostic = false;

            var param = GetRealtimeParameters();
            var status = GetRealtimeStatus();
            var pingAndConnectStatus = GetPingAndConnectStatus();

            param.UnitsToStartRealtime = pingAndConnectStatus.UnitsConnected.ToList();

            var indices = new List<int>();
            indices.Add(0);
            param.ModuleIndices = indices;

            param.UseSingleSampleMode = false;
            param.RealtimeSampleRate = 1000;
            param.RealtimeDelayBetweenPollsInMilliSecond = 4;
            param.AllowMultipleSampleRealtime = true;
            param.RealtimeSampleRateAAFilterRatio = 1;
            param.SliceTurnOffAAFRealtime = true;

            var b = new byte[1];
            b[0] = 0;
            var dict = new Dictionary<IDASCommunication, byte[]>();
            dict.Add(pingAndConnectStatus.UnitsConnected[0], b);
            param.IdasToActiveChannels = dict;

            status.CompleteAction = () =>
            {
                Console.WriteLine("Realtime started");
            };
            status.SetRealtimeSampleRateAAF += (p, q) =>
            {
                Console.WriteLine("Set RealtimeSampleRateAAF {0},{1}", p, q);
            };

            status.StartRealtimeCallback += (data) =>
            {
                if (data.Status == ServiceBase.CallbackData.CallbackStatus.AllFinished)
                {
                    Console.WriteLine("Finished receiving data");
                }

                if (data.Status == ServiceBase.CallbackData.CallbackStatus.NewData)
                {

                    Console.WriteLine("Receiving new data {0}", data.Data[0].SampleNumber.ToString());
                }
            };

            _stateMachine.FireAsync(Trigger.StartRealtime);
            //5 seconds get the data then stop the real time
            System.Threading.Thread.Sleep(5000);
            StopRealtime();
            Console.WriteLine("Stopped Realtime");

        }

        private void ResolveChannelsManual()
        {
        }

        private void ResolveChannelsAuto()
        {
        }

        private void ApplyConfiguration()
        {
            GetConfigureStatus().CompleteAction = () =>
            {
                _stateMachine.Fire(Trigger.Finish);
            };
            GetConfigureParameters().ErrorRequiringActionAction = (string errorString, string msg) => DialogResult.OK;
            GetConfigureParameters().ConfigureDigitalOutputs = true;
            GetConfigureParameters().DoStrictCheck = true;
            GetConfigureParameters().DummyConfig = false;
            GetConfigureParameters().EventConfig = true;
            GetConfigureParameters().MaxAAF = new[] { 10000D, 100000D, 100000D };
            GetConfigureParameters().UnitsToConfigure = GetPingAndConnectStatus().UnitsWithConfiguration;
            _stateMachine.FireAsync(Trigger.ApplyConfiguration);
        }
    }
}