/// ############## Form1.CS

using FiniteStateMachine.Core;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace FiniteStateMachine
{
    public partial class Form1 : Form
    {
        StateContext SC;


        public Form1()
        {
            InitializeComponent();
            SC = new StateContext(1000);
            SC.SensorStateChanged += SC_SensorStateChanged;

        }

        private void SC_SensorStateChanged(object sender, SensorStateChangedEventArgs e)
        {
            //if (SC.CurrentSensorState == StateContext.SensorState.WORKING)
            //{
            //    SC.CurrentSensorState = e.NewState;
            //    SC.Working();
            //}

            if (e.NewState is StateIn || e.NewState is StateStart || e.NewState is StateOut)
            {
                SC.Working();
            }


            //if (e.NewState == Core.State1)
            //{
                
           // }
        }

        private void btnIN_Click(object sender, EventArgs e)
        {
            HandleSensorStateChange(StateContext.SensorState.IN);
        }

        private void btnSTART_Click(object sender, EventArgs e)
        {
            HandleSensorStateChange(StateContext.SensorState.START);
        }

        private void btnOUT_Click(object sender, EventArgs e)
        {
            HandleSensorStateChange(StateContext.SensorState.OUT);
        }

        private void HandleSensorStateChange(StateContext.SensorState newState)
        {
            //if (SC.CurrentSensorState == StateContext.SensorState.WORKING)
            //{
                SC.CurrentSensorState = newState;
                SC.Working();
            //}
        }

        private void Form1_Load(object sender, EventArgs e)
        {

        }

        private void btnWorking_Click(object sender, EventArgs e)
        {
            SC = new StateContext(777);
            SC.SensorStateChanged += SC_SensorStateChanged;


            SC.CurrentSensorState = StateContext.SensorState.WORKING;

            HandleSensorStateChange(StateContext.SensorState.WORKING);
        }
    }
}

// ########################################## 





using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace FiniteStateMachine.Core
{
    interface IState
    {
        void Entry();
        void Exit();
        void Do();
    }

    public abstract class StateBase : IState
    {
        private readonly StateContext SC;

        public StateBase(StateContext sC)
        {
            SC = sC;
        }

        public virtual void Do()
        {
            Trace.WriteLine("StateBase : Do");

            Trace.WriteLine("StateBase : DataFromServer");
            Trace.WriteLine("StateBase : CheckIsMarkingpossible");
        }
        public virtual void Entry()
        {
            Trace.WriteLine("StateBase : Entry");
        }
        public virtual void Exit()
        {
            Trace.WriteLine("StateBase : Exit");
        }
    }

    public class StateIn : StateBase
    {
        public StateIn(StateContext sC) : base(sC)
        {

        }

        public override void Do()
        {
            base.Do();

            Trace.WriteLine("State 1: Do");

            Trace.WriteLine("State 1: DataFromServer");
            Trace.WriteLine("State 1: CheckIsMarkingpossible");


            Trace.WriteLine("State 1: ServerData1 and ServerData2 are available!");



        }

        public override void Entry()
        {
            base.Entry();
            Trace.WriteLine("State 1: Entry");


        }

        public override void Exit()
        {
            base.Exit();
            Trace.WriteLine("State 1: Exit");


        }
    }

    public class StateStart : StateBase
    {
        public StateStart(StateContext sC) : base(sC)
        {

        }

        public override void Do()
        {
            base.Do();
            Trace.WriteLine("State 2: Do");
            Trace.WriteLine("State 2: Marking Ink");
        }

        public override void Entry()
        {
            base.Entry();
            Trace.WriteLine("State 2: Entry");
        }

        public override void Exit()
        {
            base.Exit();
            Trace.WriteLine("State 2: Exit");
        }
    }

    public class StateOut : StateBase
    {
        public StateOut(StateContext sC) : base(sC)
        {

        }

        public override void Do()
        {
            Trace.WriteLine("State 3: Do");
            Trace.WriteLine("State 3: Send result to server");
        }

        public override void Entry()
        {
            Trace.WriteLine("State 3: Entry");
        }

        public override void Exit()
        {
            Trace.WriteLine("State 3: Exit");
        }
    }
}



// ######################

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace FiniteStateMachine.Core
{
    public class SensorStateChangedEventArgs : EventArgs
    {
        public StateBase NewState { get; set; }

        public SensorStateChangedEventArgs(StateBase newState)
        {
            NewState = newState;
        }
    }


    public class StateContext
    {
        public enum SensorState
        {
            NotDefine = -1,
            IN,
            START,
            OUT,
            WORKING
        }

        public event EventHandler<SensorStateChangedEventArgs> SensorStateChanged;

        private IState Actual;
        private int CurrentCounter;

        public SensorState CurrentSensorState { set; get; }
        private StateIn StateIn;// = new State1(this);
        private StateStart StateStart;// = new State2(this);
        private StateOut StateOut;// = new State3(this);

        public StateContext(int counter)
        {
            StateIn = new StateIn(this);
            StateStart = new StateStart(this);
            StateOut = new StateOut(this);

            Actual = StateIn;
            CurrentSensorState = SensorState.NotDefine;
            CurrentCounter = counter;
        }

        public void Working()
        {
            switch (CurrentSensorState)
            {
                default:
                    break;
                case SensorState.IN:
                    if (Actual == StateIn)
                    {
                        ++CurrentCounter;
                        Actual.Do();
                        ChangeState();


                        SensorStateChanged?.Invoke(this, new SensorStateChangedEventArgs(Actual as StateBase));
                    }
                    break;
                case SensorState.START:
                    if (Actual == StateStart)
                    {
                        ++CurrentCounter;
                        Actual.Do();
                        ChangeState();
                        SensorStateChanged?.Invoke(this, new SensorStateChangedEventArgs(Actual as StateBase));
                    }
                    break;
                case SensorState.OUT:
                    if (Actual == StateOut)
                    {
                        ++CurrentCounter;
                        Actual.Do();
                        ChangeState();
                        SensorStateChanged?.Invoke(this, new SensorStateChangedEventArgs(Actual as StateBase));
                    }
                    break;
            }
        }

        public void ChangeState()
        {
            Actual.Exit();

            if (Actual is StateIn)
            {
                Actual = StateStart;
            }
            else if (Actual is StateStart) //&& CurrentCounter > 20)
            {
                Actual = StateOut;
            }
            else if (Actual is StateOut)
            {
                Actual = StateIn;
            }
            else
            {

            }
            Actual.Entry();
        }
    }
}