using System;

using Stateless;

​

public class Program

{

    public class Bug

    {

        private enum State { Open, Assigned, Deferred, Closed }

​

        private enum Trigger { Assign, Defer, Close }

​

        private readonly StateMachine<State, Trigger> _machine;

        // The TriggerWithParameters object is used when a trigger requires a payload.

        private readonly StateMachine<State, Trigger>.TriggerWithParameters<string> _assignTrigger;

​

        private readonly string _title;

        private string _assignee;

​

​

        /// <summary>

        /// Constructor for the Bug class

        /// </summary>

        /// <param name="title">The title of the bug report</param>

        public Bug(string title)

        {

            _title = title;

​

            // Instantiate a new state machine in the Open state

            _machine = new StateMachine<State, Trigger>(State.Open);

​

            // Instantiate a new trigger with a parameter. 

            _assignTrigger = _machine.SetTriggerParameters<string>(Trigger.Assign);

​

            // Configure the Open state

            _machine.Configure(State.Open)

                .Permit(Trigger.Assign, State.Assigned);

​

            // Configure the Assigned state

            _machine.Configure(State.Assigned)

                .SubstateOf(State.Open)

                .OnEntryFrom(_assignTrigger, OnAssigned)  // This is where the TriggerWithParameters is used. Note that the TriggerWithParameters object is used, not something from the enum

                .PermitReentry(Trigger.Assign)

                .Permit(Trigger.Close, State.Closed)

                .Permit(Trigger.Defer, State.Deferred)

                .OnExit(OnDeassigned);

​

            // Configure the Deferred state

            _machine.Configure(State.Deferred)

                .OnEntry(() => _assignee = null)

                .Permit(Trigger.Assign, State.Assigned);

        }

​

        public void Close()

        {

            _machine.Fire(Trigger.Close);

        }

​

        public void Assign(string assignee)

        {

            // This is how a trigger with parameter is used, the parameter is supplied to the state machine as a parameter to the Fire method.

            _machine.Fire(_assignTrigger, assignee);

        }

​

        public bool CanAssign => _machine.CanFire(Trigger.Assign);

​

        public void Defer()

        {

            _machine.Fire(Trigger.Defer);

        }

        /// <summary>

        /// This method is called automatically when the Assigned state is entered, but only when the trigger is _assignTrigger.

        /// </summary>

        /// <param name="assignee"></param>

        private void OnAssigned(string assignee)

        {

            if (_assignee != null && assignee != _assignee)

                SendEmailToAssignee("Don't forget to help the new employee!");

​

            _assignee = assignee;

            SendEmailToAssignee("You own it.");

        }

        /// <summary>

        /// This method is called when the state machine exits the Assigned state

        /// </summary>

        private void OnDeassigned()

        {

            SendEmailToAssignee("You're off the hook.");

        }

​

        private void SendEmailToAssignee(string message)

        {

            Console.WriteLine("{0}, RE {1}: {2}", _assignee, _title, message);

        }

​

        public string ToDotGraph()

        {

            return null;//UmlDotGraph.Format(_machine.GetInfo());

        }

        static void Main(string[] args)

        {

            var bug = new Bug("Incorrect stock count");

​

            bug.Assign("Joe");

            bug.Defer();

            bug.Assign("Harry");

            bug.Assign("Fred");

            bug.Close();

​

        }

    }

}