//Trading Rig States (Parent State Machine)
public class ConnectingToClient : State
{
    protected override void OnEntry(StateHandlerInfo<State> info)
    {
        Console.WriteLine("Entering Connecting To Client State");
        Console.WriteLine("Connect to Client");


        base.OnEntry(info);
    }

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

public class CachingAPIKeyState : State
{
    protected override void OnEntry(StateHandlerInfo<State> info)
    {
        Console.WriteLine("Entering Caching API Key State");
        Console.WriteLine("Requesting API Key");

        base.OnEntry(info);
    }

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

public class ConnectingToExchange : State
{
    protected override void OnEntry(StateHandlerInfo<State> info)
    {
        Console.WriteLine("Entering Connecting to Exchange State");
        Console.WriteLine("Connecting to Exchange");
        base.OnEntry(info);
    }

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

public class ConnectedToExchange : State
{
    protected override void OnEntry(StateHandlerInfo<State> info)
    {
        Console.WriteLine("Entering Connected to Exchange State");
        Console.WriteLine("Connected to Exchange");
        base.OnEntry(info);
    }

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

public class SessionComplete : State
{
    protected override void OnEntry(StateHandlerInfo<State> info)
    {
        Console.WriteLine("Entering Session Complete State");

        base.OnEntry(info);
    }

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

//Child StateMachine States
public class GettingInitialAccountInfoState : State
{
    protected override void OnEntry(StateHandlerInfo<State> info)
    {
        Console.WriteLine("Entering Getting Initial Account Info State");
        Console.WriteLine("Requesting Account Info from Exchange");
        base.OnEntry(info);
    }

    protected override void OnExit(StateHandlerInfo<State> info)
    {
        Console.WriteLine("Received Account Info from Exchange");
        Console.WriteLine("Exiting Getting Initial Account Info State");
        base.OnExit(info);
    }
}

public class UpdatingClient : State
{
    protected override void OnEntry(StateHandlerInfo<State> info)
    {
        Console.WriteLine("Entering Updating Client State");
        Console.WriteLine("Sending Account Info to Client");
        base.OnEntry(info);
    }

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

public class PollingExchange : State
{
    protected override void OnEntry(StateHandlerInfo<State> info)
    {
        Console.WriteLine("Entering Polling Exchange State");
        Console.WriteLine("Waiting 500 milliseconds");
        Console.WriteLine("Requesting Account Info from Exchange");
        base.OnEntry(info);
    }

    protected override void OnExit(StateHandlerInfo<State> info)
    {
        Console.WriteLine("Received Account Info");
        Console.WriteLine("Exiting Polling Exchange State");
        base.OnExit(info);
    }
}

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

    public Event ConnectedToClient = new Event("Connected to Client");
    public Event KeyCached = new Event("Key Cached");
    public Event ExchangeConnected = new Event("Exchange Connected");
    public Event Shutdown = new Event("Shutdown");

    public Event AccountInfoReceived = new Event("Account Info Received");
    public Event ClientUpdated = new Event("ClientUpdated");
    public Event PollingTimeout = new Event("Polling Timeout");

    public bool HasActiveOrder = false;

    void BuildConnectedToExchangeStateMachine(State parentState)
    {
        ConnectedToExchangeStateMachine = parentState.CreateChildStateMachine("Market Maker");
        var gettingInitialAccountInfoState = ConnectedToExchangeStateMachine.CreateInitialState<GettingInitialAccountInfoState>("Getting Initial Account Info");
        var updatingClientState = ConnectedToExchangeStateMachine.CreateState<UpdatingClient>("Updating Client");
        var pollingExchangeState = ConnectedToExchangeStateMachine.CreateState<PollingExchange>("Polling Exchange");

        gettingInitialAccountInfoState.TransitionOn(AccountInfoReceived).To(updatingClientState);
        updatingClientState.TransitionOn(ClientUpdated).To(pollingExchangeState);
        pollingExchangeState.TransitionOn(AccountInfoReceived).To(updatingClientState);
    }

    public void BuildTradingRigStateMachine()
    {
        TradingRigStateMachine = new StateMachine("Trading Rig");
        var connectingToClientState = TradingRigStateMachine.CreateInitialState<ConnectingToClient>("Connecting to Client");
        var cachingKeyState = TradingRigStateMachine.CreateState<CachingAPIKeyState>("Caching API Key");
        var connectingToExchangeState = TradingRigStateMachine.CreateState<ConnectingToExchange>("Connecting to Exchange");

        var connectedToExchangeState = TradingRigStateMachine.CreateState<ConnectedToExchange>("Connected to Exchange");
        var sessionCompleteState = TradingRigStateMachine.CreateState<SessionComplete>("Session Complete");

        BuildConnectedToExchangeStateMachine(connectedToExchangeState);

        connectingToClientState.TransitionOn(ConnectedToClient).To(cachingKeyState);
        cachingKeyState.TransitionOn(KeyCached).To(connectingToExchangeState);
        connectingToExchangeState.TransitionOn(ExchangeConnected).To(connectedToExchangeState);

        connectedToExchangeState.TransitionOn(Shutdown).To(sessionCompleteState);
    }

}

void Main()
{
    TradingRig Rig = new TradingRig();
    Rig.BuildTradingRigStateMachine();
    Rig.ConnectedToClient.Fire();
    Rig.KeyCached.Fire();
    Rig.ExchangeConnected.Fire();
    Rig.AccountInfoReceived.Fire();
    Rig.ClientUpdated.Fire();
    Rig.AccountInfoReceived.Fire();
}