using Wayne.Lib;
using Wayne.Lib.StateEngine;
using Wayne.Lib.StateEngine.Generic;

namespace Wayne.ForecourtControl.Fusion.ReadDeviceStatus.States
{
    [StateDescription(StateDescriptionType.Summary,"Gets Device status information from Forecourt")]
    [TimeoutDescription("Forecourt took too long to answer", BasicTransitionType.Timeout)]
    [EnterDescription("No information to get", BasicTransitionType.Done)]
    [EventDescription(EventType.GetStatus,"Information returned", BasicTransitionType.Done)]
    [EventDescription(EventType.ReadDeviceStatus,"Do nothing", null)]
    abstract class GetStatusFromForecourt: TimeoutState<ReadDeviceStatusController>
    {
        private object _userToken;


        #region Overrides of TimeoutState<ReadDeviceStatusController>

        /// <summary>
        /// See State.Enter
        /// </summary>
        /// <param name="stateEntry"></param>
        /// <param name="transition"></param>
        protected override void Enter(StateEntry stateEntry, ref Transition transition)
        {
            base.Enter(stateEntry, ref transition);

           _userToken =SendStatusRequestToForecourt();
        }

        protected virtual object SendStatusRequestToForecourt()
        {
            object userToken;
            var eventHandler = Main.CreateEventHandler<AsyncCompletedEventArgs>(EventType.GetStatus, out userToken);
            Main.GetDeviceState(TargetDeviceType(),eventHandler, userToken);
            return userToken;
        }

        protected abstract string TargetDeviceType();
        #endregion

        

        #region Overrides of TimeoutState<ReadDeviceStatusController>

        /// <summary>
        /// Method that is implemented by descendant classes to receive events that were not the timeout event.
        /// </summary>
        /// <param name="stateEngineEvent"></param>
        /// <param name="transition"></param>
        protected override void HandleNonTimeoutEvent(StateEngineEvent stateEngineEvent, ref Transition transition)
        {
            if (stateEngineEvent.Type.Equals(EventType.ReadDeviceStatus))
            {
                stateEngineEvent.Handled = true;//ignore.
            }
            else if (stateEngineEvent.Type.Equals(EventType.GetStatus))
            {
                var genericEvent = stateEngineEvent as GenericEvent<AsyncCompletedEventArgs>;
                if (genericEvent != null)
                {
                    if (genericEvent.EventArgs.UserToken.Equals(_userToken))
                    {
                        genericEvent.Handled = true;
                        _userToken = null;
                        transition = new Transition(this, BasicTransitionType.Done);
                    }
                }
            }
        }

        /// <summary>
        /// Method that is used by descendant classes to set the timeout of the state.
        /// </summary>
        /// <returns></returns>
        protected override int TimeoutInterval
        {
            get { return 10000; }
        }

        /// <summary>
        /// Method that is used by descendant classes to be signaled when the timeout has fired.
        /// </summary>
        /// <param name="transition"></param>
        protected override void Timeout(ref Transition transition)
        {
            transition = new Transition(this, BasicTransitionType.Timeout);
        }

        #endregion

        #region Overrides of TimeoutState<ReadDeviceStatusController>

        /// <summary>
        /// See State.Exit
        /// </summary>
        protected override void Exit()
        {
            base.Exit();
            if (_userToken != null)
            {
                Main.CancelEventHandler(_userToken);
                _userToken = null;
            }
        }

        #endregion
    }
}