#region Using directives

using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Reflection;
using System.Diagnostics;
using System.Runtime.Remoting.Messaging;
using System.Workflow.ComponentModel;
using System.Workflow.ComponentModel.Design;
using System.Workflow.Runtime;
using System.Workflow.Runtime.Hosting;

#endregion Using directives

namespace System.Workflow.Activities
{
    [Serializable]
    internal class StateMachineExecutionState
    {
        #region Member Variables

        internal const string StateMachineExecutionStateKey = "StateMachineExecutionState";
        private StateMachineSubscriptionManager _subscriptionManager;
        private Queue<StateMachineAction> _actions;
        private string _currentStateName;
        private string _previousStateName;
        private string _nextStateName;
        private bool _completed = false;
        private bool _queueLocked = false;
        private bool _schedulerBusy = false;

        #endregion Member Variables

        #region Properties

        internal StateMachineSubscriptionManager SubscriptionManager
        {
            get
            {
                return _subscriptionManager;
            }
        }

        private Queue<StateMachineAction> Actions
        {
            get
            {
                if (_actions == null)
                    _actions = new Queue<StateMachineAction>();
                return _actions;
            }
        }

        internal bool SchedulerBusy
        {
            get
            {
                return _schedulerBusy;
            }
            set
            {
                _schedulerBusy = value;
            }
        }

        internal string CurrentStateName
        {
            get
            {
                return _currentStateName;
            }
            set
            {
                _currentStateName = value;
            }
        }

        internal string PreviousStateName
        {
            get
            {
                return _previousStateName;
            }
            set
            {
                _previousStateName = value;
            }
        }

        internal string NextStateName
        {
            get
            {
                return _nextStateName;
            }
            set
            {
                _nextStateName = value;
            }
        }

        internal bool Completed
        {
            get
            {
                return _completed;
            }
            set
            {
                _completed = value;
            }
        }

        internal bool HasEnqueuedActions
        {
            get
            {
                return this.Actions.Count > 0;
            }
        }

        #endregion Properties

        #region Constructors

        internal StateMachineExecutionState(Guid instanceId)
        {
            _subscriptionManager = new StateMachineSubscriptionManager(this, instanceId);
        }

        #endregion

        internal void LockQueue()
        {
            _queueLocked = true;
        }

        internal void EnqueueAction(StateMachineAction action)
        {
            Debug.Assert(!this._queueLocked);
            this.Actions.Enqueue(action);
        }

        internal StateMachineAction DequeueAction()
        {
            StateMachineAction action = this.Actions.Dequeue();
            if (this.Actions.Count == 0)
                _queueLocked = false;
            return action;
        }

        internal void ProcessActions(ActivityExecutionContext context)
        {
            if (context == null)
                throw new ArgumentNullException("context");

            if (this.SchedulerBusy)
                return;

            StateActivity state = (StateActivity)context.Activity;

            if (this.Actions.Count == 0)
            {
                this.SubscriptionManager.ProcessQueue(context);
                return;
            }

            StateMachineAction action = this.Actions.Peek();
            while (action.StateName.Equals(state.QualifiedName))
            {
                action = DequeueAction();
                action.Execute(context);

                // If the previous action just
                // requested something to the runtime
                // scheduler, then we quit, since
                // the scheduler takes precedence.
                // we'll pick up the processing of actions
                // after the scheduler return the control to us.
                if (this.SchedulerBusy)
                    return;

                if (this.Actions.Count == 0)
                    break;

                action = this.Actions.Peek();
            }

            if (this.Actions.Count > 0)
            {
                StateActivity rootState = StateMachineHelpers.GetRootState(state);
                StateActivity nextActionState = StateMachineHelpers.FindDynamicStateByName(rootState, action.StateName);
                if (nextActionState == null)
                    throw new InvalidOperationException(SR.GetInvalidStateMachineAction(action.StateName));

                nextActionState.RaiseProcessActionEvent(context);
            }
            else
            {
                this.SubscriptionManager.ProcessQueue(context);
            }
        }


        internal void ProcessTransitionRequest(ActivityExecutionContext context)
        {
            if (String.IsNullOrEmpty(this.NextStateName))
                return;

            StateActivity currentState = StateMachineHelpers.GetCurrentState(context);
            CalculateStateTransition(currentState, this.NextStateName);
            LockQueue();
            this.NextStateName = null;
        }

        internal void CalculateStateTransition(StateActivity currentState, string targetStateName)
        {
            if (currentState == null)
                throw new ArgumentNullException("currentState");
            if (String.IsNullOrEmpty(targetStateName))
                throw new ArgumentNullException("targetStateName");

            while (currentState != null && (currentState.QualifiedName.Equals(targetStateName) || !StateMachineHelpers.ContainsState(currentState, targetStateName)))
            {
                CloseStateAction action = new CloseStateAction(currentState.QualifiedName);
                this.Actions.Enqueue(action);
                currentState = currentState.Parent as StateActivity;
            }
            if (currentState == null)
                throw new InvalidOperationException(SR.GetUnableToTransitionToState(targetStateName));

            while (!currentState.QualifiedName.Equals(targetStateName))
            {
                foreach (Activity childActivity in currentState.EnabledActivities)
                {
                    StateActivity childState = childActivity as StateActivity;
                    if (childState != null)
                    {
                        // 
                        if (StateMachineHelpers.ContainsState(childState, targetStateName))
                        {
                            ExecuteChildStateAction action = new ExecuteChildStateAction(currentState.QualifiedName, childState.QualifiedName);
                            this.Actions.Enqueue(action);
                            currentState = childState;
                            break;
                        }
                    }
                }
            }
            if (!StateMachineHelpers.IsLeafState(currentState))
                throw new InvalidOperationException(SR.GetInvalidStateTransitionPath());
        }

        #region Static Methods

        internal static StateMachineExecutionState Get(StateActivity state)
        {
            Debug.Assert(StateMachineHelpers.IsRootState(state));
            StateMachineExecutionState executionState = (StateMachineExecutionState)state.GetValue(StateActivity.StateMachineExecutionStateProperty);
            Debug.Assert(executionState != null);
            return executionState;
        }

        #endregion
    }
}