//Trading Rig States (Parent State Machine)
public class DisengagedState : State
{
    protected override void OnEntry(StateHandlerInfo<State> info)
    {
        Console.WriteLine("Entering Disengaged State");
        //TODO : Cancel All Orders
        base.OnEntry(info);
    }
}

public class EngagedState : State
{
    protected override void OnEntry(StateHandlerInfo<State> info)
    {
        Console.WriteLine("Entering Engaged State");
        base.OnEntry(info);
    }

    protected override void OnExit(StateHandlerInfo<State> info)
    {
        Console.WriteLine("Exiting Engaged State");
        base.OnExit(info);
    }
}

//MarketMaker States (Child State Machine)
public class EvaluatingState : State
{
    protected override void OnEntry(StateHandlerInfo<State> info)
    {
        Console.WriteLine("Entering Evaluating State");
        //TODO : Set desired trade price and quantity
        //Simulate a strategy update

        base.OnEntry(info);
    }

    protected override void OnExit(StateHandlerInfo<State> info)
    {
        Console.WriteLine("Exiting Evaluating State");
        base.OnExit(info);
    }
}

public class CancellingOrderState : State
{
    protected override void OnEntry(StateHandlerInfo<State> info)
    {
        Console.WriteLine("Entering Cancelling Order State");
        //TODO : Cancel existing order
        base.OnEntry(info);
    }

    protected override void OnExit(StateHandlerInfo<State> info)
    {
        Console.WriteLine("Exiting Cancelling Order State");
        base.OnExit(info);
    }
}

public class PlacingOrderState : State
{
    protected override void OnEntry(StateHandlerInfo<State> info)
    {
        Console.WriteLine("Entering Placing Order State");
        //TODO : Place Order
        Console.WriteLine("Simulating Placing Order...");
        base.OnEntry(info);
    }

    protected override void OnExit(StateHandlerInfo<State> info)
    {
        Console.WriteLine("Exiting Placing Order State");
        base.OnExit(info);
    }
}

public class OrderActiveState : State
{
    protected override void OnEntry(StateHandlerInfo<State> info)
    {
        Console.WriteLine("Entering Order Active State");
        //TODO : Place Order
        base.OnEntry(info);
    }

    protected override void OnExit(StateHandlerInfo<State> info)
    {
        Console.WriteLine("Exiting Order Active State");
        base.OnExit(info);
    }
}

public class TradingRig
{
    StateMachine TradingRigStateMachine;
    ChildStateMachine<State> MarketMakerStateMachine;

    public Event EngageEvent = new Event("Engage");
    public Event DisengageEvent = new Event("Disengage");
    public Event StrategyUpdated = new Event("Strategy Updated");
    public Event StrategyUnchanged = new Event("Strategy Unchanged");
    public Event OrderBookUpdated = new Event("Order Book Updated");
    public Event CancellationConfirmationReceived = new Event("Cancellation Confirmation Received");
    public Event OrderConfirmationReceived = new Event("Order Confirmation Received");

    public bool HasActiveOrder = false;

    void BuildMarketMakerStateMachine(State parentState)
    {
        //MarketMakerStateMachine = new StateMachine("Market Maker");
        MarketMakerStateMachine = parentState.CreateChildStateMachine("Market Maker");
        var evaluatingState = MarketMakerStateMachine.CreateInitialState<EvaluatingState>("Evaluating");
        var cancellingOrderState = MarketMakerStateMachine.CreateState<CancellingOrderState>("Cancelling Order");
        var placingOrderState = MarketMakerStateMachine.CreateState<PlacingOrderState>("Placing Order");
        var orderActiveState = MarketMakerStateMachine.CreateState<OrderActiveState>("Order Active");

        evaluatingState.TransitionOn(StrategyUpdated).To(cancellingOrderState).WithGuard(g => HasActiveOrder);
        evaluatingState.TransitionOn(StrategyUpdated).To(placingOrderState);
        evaluatingState.TransitionOn(StrategyUnchanged).To(orderActiveState).WithGuard(g => HasActiveOrder);

        cancellingOrderState.TransitionOn(CancellationConfirmationReceived).To(placingOrderState);
        placingOrderState.TransitionOn(OrderConfirmationReceived).To(orderActiveState);
        orderActiveState.TransitionOn(OrderBookUpdated).To(evaluatingState);
    }

    public void BuildTradingRigStateMachine()
    {


        TradingRigStateMachine = new StateMachine("Trading Rig");
        var disengagedState = TradingRigStateMachine.CreateInitialState<DisengagedState>("Disengaged");
        var engagedState = TradingRigStateMachine.CreateState<EngagedState>("Engaged");
        BuildMarketMakerStateMachine(engagedState);
        disengagedState.TransitionOn(EngageEvent).To(engagedState);
        engagedState.TransitionOn(DisengageEvent).To(disengagedState);
    }

    public void Engage()
    {
        EngageEvent.Fire();
    }

    public void Disengage()
    {
        DisengageEvent.Fire();
    }

}

void Main()
{
    TradingRig Rig = new TradingRig();
    Rig.BuildTradingRigStateMachine();
    Rig.EngageEvent.Fire(); //Simulate the user using the UI to engage the rig
    //Trading Rig State Machine will transition to Engaged State
    //Market Maker State Machine will transition to Evaluating State
    Rig.StrategyUpdated.Fire();  //Simulate Strategy Update Event
    //Market Maker State Machine will transition to Placing Order State
    Thread.Sleep(250); //Simulate delay between placing order and getting a confirmation
    Rig.OrderConfirmationReceived.Fire(); // Simulate receiving order confirmation
    //Market Maker State Machine will transition to Order Active State
    Rig.HasActiveOrder = true; //This is not ideal - Currently using this as a transition guard
    Thread.Sleep(250); //Simulate delate as market remains unchanged
    Rig.OrderBookUpdated.Fire(); //Simulate an order book update
    //Market Maker State Machine will transition to Evaluating State
    Rig.StrategyUpdated.Fire(); //Simulate Strategy Update Event. (i.e new order book data causes new desired order)
    //Since we have an active order (HasOrder = True),
    //this time the Market Maker State Machine will transition to Cancelling Order State
    Thread.Sleep(250); // Simulate delay receiving cancellation confirmation
    Rig.CancellationConfirmationReceived.Fire(); //Simulate receiving cancellation confirmation
    //Market Maker State Machine will transition to Placing Order State and will place a new order
    Thread.Sleep(250); //Simulate delay between placing order and getting a confirmation
    Rig.OrderConfirmationReceived.Fire(); // Simulate receiving order confirmation
    //Market Maket State Machine will transition to Order Active State
    Rig.OrderBookUpdated.Fire(); //Simulate an order book update
    //Market Maker State Machine will transition to Evaluating State
    //This time our evaluation shows no need to change the order so
    //the Market Maker State Machine will transition back to Order Active State
    Rig.StrategyUnchanged.Fire();
    Rig.DisengageEvent.Fire();
}