MockDevice.cs

Go to the documentation of this file.

using AxelSemrau.Chronos.Plugin;
using MockPlugin.Tasks;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics.CodeAnalysis;
using System.Drawing.Design;
using System.IO;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;
using MockPlugin.SampleList;
 
// ReSharper disable LocalizableElement
#pragma warning disable 169
 
namespace MockPlugin.Device
{
 
 
    [SuppressMessage("ReSharper", "MemberCanBePrivate.Global")]
    [SuppressMessage("ReSharper", "UnusedMember.Global")]
    public class MockDevice :
        // ReSharper disable once RedundantExtendsListEntry
        IDevice,
        INeedAConnection,
        IProvideStatusMessages,
        IHaveDebugOutput,
        IAbortSchedules,
        ICanInterrupt,
        INotifyPropertyChanged,
        IDisposable,
        IHaveMachineParameters<CoffeMakerParams>,
        IProvideDiagnosticLogs,
        IStopRuns,
        IScheduleStateAware,
        IHaveInteractiveErrorHandling
    {
        public const string DeviceTypeName = "ACME Coffee Maker";
        #region private variables
 
        private bool mIsConnected;
 
        #endregion private variables
 
        #region IDevice
 
        public MockDevice()
        {
            Instances.Add(this);
        }
 
        internal static readonly List<MockDevice> Instances = new List<MockDevice>();
 
        public void Dispose()
        {
            Instances.Remove(this);
            DebugOutput?.Invoke($"MockDevice {Name} disposed");
        }
 
        public string DisplayedTypeName => DeviceTypeName;
 
        public string DeviceTypeDescription => "coffee machine";
 
        public string Name
        {
            get;
            set;
        }
 
        public void BrewFrappuccino(BrewFrappuccino.CompositionData composition)
        {
            WaitIfPaused();
            ShowTheMessage(
                $"Making a {composition.Volume} mL frappuccino with cream type \"{composition.Cream}\"{(composition.DeCaffeinated ? ", decaffeinated." : "")}.");
        }
 
        public void SomeDummyMethod()
        {
            DebugOutput?.Invoke($"Dummy method of {Name} was called.");
        }
 
        public void Connect()
        {
            ConnectionStateChanged(ConnectionState.Connecting);
            MessageBox.Show(Helpers.Gui.MainWindow, $"Device {Name} was connected to {Connection}.");
            ConnectionStateChanged(ConnectionState.Connected);
            mIsConnected = true;
            OnIsConnectedChanged();
        }
 
        public void Disconnect()
        {
            ConnectionStateChanged(ConnectionState.Disconnecting);
            MessageBox.Show(Helpers.Gui.MainWindow, $"Device {Name} was disconnected from {Connection}.");
            ConnectionStateChanged(ConnectionState.Disconnected);
            mIsConnected = false;
            OnIsConnectedChanged();
        }
 
        public event Action<ConnectionState> ConnectionStateChanged;
 
        #endregion IDevice
 
        #region INeedAConnection
 
        [Editor(typeof(ConnectionEditor), typeof(UITypeEditor))]
        public string Connection { get; set; } = "COM17";
 
        #endregion INeedAConnection
 
        #region Custom methods and properties
 
        public void ShowTheMessage(string messageText)
        {
            WaitIfPaused();
            SetStatusMessage?.Invoke("The device just did something wonderful.");
            MessageBox.Show(Helpers.Gui.MainWindow,
                $"The following message was shown addressing the mock device {Name}:\r\n{messageText}",
                "Mock Device",
                MessageBoxButtons.OK);
            DebugOutput?.Invoke($"Finished showing the message {messageText}");
        }
 
        public bool IsConnected
        {
            get => mIsConnected;
            set
            {
                if (!mIsConnected && value)
                {
                    Connect();
                }
                else if (mIsConnected && !value)
                {
                    Disconnect();
                }
            }
        }
 
        #endregion Custom methods and properties
 
        #region IProvideStatusMessages
 
        public event Action<string> SetStatusMessage;
 
        #endregion IProvideStatusMessages
 
        #region IHaveDebugOutput
 
        public event Action<string> DebugOutput;
 
        #endregion IHaveDebugOutput
 
        #region INotifyPropertyChanged
 
        private void OnIsConnectedChanged()
        {
            var myHandler = PropertyChanged;
            if (myHandler != null)
            {
                Helpers.Gui.GuiTaskFactory.StartNew(() => myHandler(this, new PropertyChangedEventArgs(nameof(IsConnected))));
            }
        }
 
        public event PropertyChangedEventHandler PropertyChanged;
 
        #endregion INotifyPropertyChanged
 
        #region IAbortSchedules
 
        public void TriggerAbort(string reason, bool softStop)
        {
            Task.Run(() =>
                     {
                         Thread.Sleep(5000);
                         if (softStop)
                         {
                             StopRun?.Invoke(new StopRunArgs()
                             {
                                 How = StopRunArgs.StopMode.NoNewJobs, StopQueue = true, Reason = reason,
                                 RestartRemainingJobs = false
                             });
                         }
                         else
                         {
                             AbortSchedule?.Invoke(reason);
                         }
                     });
}
 
        public event Action<string> AbortSchedule;
 
        public void CheckForAbort()
        {
            if (mAborted.IsSet)
            {
                throw new OperationCanceledException("Aborted");
            }
        }
 
        #endregion IAbortSchedules
 
        #region Implementation of IHaveMachineParameters<CoffeMakerParams>
 
        public CoffeMakerParams Parameters { get; set; } = new CoffeMakerParams();
 
        public Task ApplyParametersAsync(bool waitUntilSetpointIsReached, CancellationToken canToken)
        {
            
            SetStatusMessage?.Invoke($"Applying parameters: '{Parameters}' and {(!waitUntilSetpointIsReached ? "not " : "")} waiting for setpoint.");
            if (waitUntilSetpointIsReached)
            {
                return Task.Delay(TimeSpan.FromSeconds(10),canToken);
            }
            return Task.CompletedTask;
        }
 
        #endregion Implementation of IHaveMachineParameters<CoffeMakerParams>
 
        public void WaitIfPaused()
        {
            WaitHandle.WaitAny(new[] { mPauseEnded.WaitHandle, mAborted.WaitHandle });
            CheckForAbort();
        }
 
        #region Implementation of ICanInterrupt
 
        private readonly ManualResetEventSlim mPauseEnded = new ManualResetEventSlim(true);
 
        private readonly ManualResetEventSlim mAborted = new ManualResetEventSlim(false);
 
        public bool Aborted
        {
            get => mAborted.IsSet;
            set
            {
                if (value) { mAborted.Set(); } else { mAborted.Reset(); }
            }
        }
 
        public bool Paused
        {
            get => !mPauseEnded.IsSet;
            set
            {
                if (value)
                {
                    mPauseEnded.Reset();
                }
                else
                {
                    mPauseEnded.Set();
                }
            }
        }
 
        #endregion Implementation of ICanInterrupt
 
        public IEnumerable<string> LogPaths =>
            MockSampleListWorker.GetFakeLogs($"{GetType().FullName} instance {Name}");
 
        public Func<StopRunArgs, Task> StopRun { get; set; }
 
        #region Schedule state events
 
        private IScheduleEvents mScheduleEvents;
 
        public IScheduleEvents ScheduleEvents
        {
            set
            {
                if (mScheduleEvents != null)
                {
                    mScheduleEvents.ScheduleStateChanged -= ScheduleStateChangedHandler;
                }
 
                mScheduleEvents = value;
                if (value != null)
                {
                    mScheduleEvents.ScheduleStateChanged += ScheduleStateChangedHandler;
                }
            }
        }
 
        private void ScheduleStateChangedHandler(object sender, ScheduleStateEventArgs e)
        {
            DebugOutput?.Invoke($"Schedule {e.PlanerName} ({e.PlanerID}) state {e.State}, abort reason {(string.IsNullOrEmpty(e.AbortReason) ? "N/A" : e.AbortReason)}");   
        }
        #endregion
 
        public void BeginInteraction()
        {
            DebugOutput?.Invoke("Starting error handling interaction");
        }
 
        public void EndInteraction()
        {
            DebugOutput?.Invoke("Ending error handling interaction");
        }
 
        public void RaiseError(string errorDescription, ErrorType errType, bool resolved)
        {
            var errArgs = new InteractiveErrorHandlingEventArgs() { Error = errorDescription, ErrorType = errType };
            do
            {
                HandleError?.Invoke(this, errArgs);
            } while (errArgs.RetryLastAction);
 
            if (!resolved)
            {
                throw new IOException($"Coffee machine reported a problem: {errorDescription}");
            }
        }
        public event EventHandler<InteractiveErrorHandlingEventArgs> HandleError;
    }
}