public class StateMachine : IStateMachine
    {
        private readonly IFactoryCreator _commandFactoryCreator;

        private IWorkMachine _workMachine;
        private EventWaitHandle _awaiterPause;
        private EventWaitHandle _awaiterCancelCommand;
        private CancellationTokenSource _ctsStateReader;
        private CancellationTokenSource _ctsExecuteCommand;
        private ExecuteAbstractCommand _command;
        private HandlerAbstractCommand _handler;
        public StateMachineState State { get; private set; }
        private Subject<StateMachineState> _onChangeState;


        public StateMachine(IFactoryCreator commandFactoryCreator, IWorkMachine workMachine)
        {
            State = StateMachineState.Idle;
            _commandFactoryCreator = commandFactoryCreator;
            _workMachine = workMachine;
            _onChangeState = new Subject<StateMachineState>();
            _awaiterPause = new AutoResetEvent(true);
            _awaiterCancelCommand = new AutoResetEvent(true);
        }
        public async Task StartAsync()
        {

            _ctsStateReader = new CancellationTokenSource();
            var token = _ctsStateReader.Token;
            _awaiterPause.Set();

            await Task.Run(async () =>
          {
              while (!token.IsCancellationRequested)
              {
                  var newState = await _workMachine.ReadState();
                  if (CheckStateChange(newState))
                  {
                      _ctsExecuteCommand?.Cancel();
                      UpdateCurrentCommands();
                      HandleCurrentStateAsync();
                  }
                  _ctsStateReader.Token.WaitHandle.WaitOne(100);
              }

          }, token);

        }

        private void HandleCurrentStateAsync()
        {
            _ctsExecuteCommand = new CancellationTokenSource();
            var token = _ctsExecuteCommand.Token;
            Task.Run(() =>
           {
               _awaiterCancelCommand.WaitOne();
               _awaiterCancelCommand.Reset();
               while (!token.IsCancellationRequested)
               {
                   _awaiterPause.WaitOne();
                   _command.Execute();
               }
               _awaiterCancelCommand.Set();
           });
        }


        private bool CheckStateChange(StateMachineState newState)
        {
            if (newState != State)
            {
                State = newState;
                _onChangeState.OnNext(State);
                return true;
            }
            return false;
        }

        private void UpdateCurrentCommands()
        {
            var factory = _commandFactoryCreator.Create(State);
            _command = factory.CreateCommad();
            _handler = factory.CreateHandler();
        }

        public void Pause()
        {
            _awaiterPause.Reset();
        }

        public void Stop()
        {
            _ctsStateReader.Cancel();
            _ctsExecuteCommand?.Cancel();
        }

        public IObservable<StateMachineState> OnChangeState()
        {
            return _onChangeState.AsObservable();
        }
    }