StateMachine.Async

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

namespace Stateless
{
    public partial class StateMachine<TState, TTrigger>
    {

        public Task ActivateAsync()
        {
            var representativeState = GetRepresentation(State);
            return representativeState.ActivateAsync();
        }

        public Task DeactivateAsync()
        {
            var representativeState = GetRepresentation(State);
            return representativeState.DeactivateAsync();
        }

        public Task FireAsync(TTrigger trigger)
        {
            return InternalFireAsync(trigger, new object[0]);
        }


        public Task FireAsync<TArg0>(TriggerWithParameters<TArg0> trigger, TArg0 arg0)
        {
            Enforce.ArgumentNotNull(trigger, "trigger");
            return InternalFireAsync(trigger.Trigger, arg0);
        }


        public Task FireAsync<TArg0, TArg1>(TriggerWithParameters<TArg0, TArg1> trigger, TArg0 arg0, TArg1 arg1)
        {
            Enforce.ArgumentNotNull(trigger, "trigger");
            return InternalFireAsync(trigger.Trigger, arg0, arg1);
        }


        public Task FireAsync<TArg0, TArg1, TArg2>(TriggerWithParameters<TArg0, TArg1, TArg2> trigger, TArg0 arg0, TArg1 arg1, TArg2 arg2)
        {
            Enforce.ArgumentNotNull(trigger, "trigger");
            return InternalFireAsync(trigger.Trigger, arg0, arg1, arg2);
        }

        async Task InternalFireAsync(TTrigger trigger, params object[] args)
        {
            TriggerWithParameters configuration;
            if (_triggerConfiguration.TryGetValue(trigger, out configuration))
                configuration.ValidateParameters(args);

            var source = State;
            var representativeState = GetRepresentation(source);

            TriggerBehaviourResult result;
            if (!representativeState.TryFindHandler(trigger, out result))
            {
                await _unhandledTriggerAction.ExecuteAsync(representativeState.UnderlyingState, trigger, result?.UnmetGuardConditions);
                return;
            }

            TState destination;
            if (result.Handler.ResultsInTransitionFrom(source, args, out destination))
            {
                var transition = new Transition(source, destination, trigger);

                await representativeState.ExitAsync(transition);

                State = transition.Destination;
                var newRepresentation = GetRepresentation(transition.Destination);
                await _onTransitionedEvent.InvokeAsync(transition);

                await newRepresentation.EnterAsync(transition, args);
            }
            else
            {
                var transition = new Transition(source, destination, trigger);

                await CurrentRepresentation.InternalActionAsync(transition, args);
            }
        }


        public void OnUnhandledTriggerAsync(Func<TState, TTrigger, Task> unhandledTriggerAction)
        {
            if (unhandledTriggerAction == null) throw new ArgumentNullException("unhandledTriggerAction");
            _unhandledTriggerAction = new UnhandledTriggerAction.Async((s, t, c) => unhandledTriggerAction(s, t));
        }


        public void OnUnhandledTriggerAsync(Func<TState, TTrigger, ICollection<string>, Task> unhandledTriggerAction)
        {
            if (unhandledTriggerAction == null) throw new ArgumentNullException("unhandledTriggerAction");
            _unhandledTriggerAction = new UnhandledTriggerAction.Async(unhandledTriggerAction);
        }


        public void OnTransitionedAsync(Func<Transition, Task> onTransitionAction)
        {
            if (onTransitionAction == null) throw new ArgumentNullException("onTransitionAction");
            _onTransitionedEvent.Register(onTransitionAction);
        }
    }
}