#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
{
    internal static class StateMachineHelpers
    {
        internal static bool IsStateMachine(StateActivity state)
        {
            if (state == null)
                throw new ArgumentNullException("state");

            return (state is StateMachineWorkflowActivity);
        }

        internal static bool IsRootState(StateActivity state)
        {
            if (state == null)
                throw new ArgumentNullException("state");

            StateActivity parent = state.Parent as StateActivity;
            return parent == null;
        }

        internal static bool IsLeafState(StateActivity state)
        {
            if (state == null)
                throw new ArgumentNullException("state");

            if (IsRootState(state))
                return false;

            foreach (Activity child in state.EnabledActivities)
            {
                if (child is StateActivity)
                    return false;
            }
            return true;
        }

        internal static bool IsRootExecutionContext(ActivityExecutionContext context)
        {
            return (context.Activity.Parent == null);
        }

        /// <summary>
        /// Finds the enclosing state for this activity
        /// </summary>
        /// <param name="activity"></param>
        /// <returns></returns>
        internal static StateActivity FindEnclosingState(Activity activity)
        {
            Debug.Assert(activity != null);
            Debug.Assert(activity.Parent != activity);

            StateActivity state = activity as StateActivity;
            if (state != null)
                return state;

            if (activity.Parent == null)
                return null;

            return FindEnclosingState(activity.Parent);
        }

        /// <summary>
        /// Returns the root State activity
        /// </summary>
        /// <param name="state"></param>
        /// <returns></returns>
        internal static StateActivity GetRootState(StateActivity state)
        {
            Debug.Assert(state != null);
            Debug.Assert(state.Parent != state);

            if (state.Parent == null)
                return state;

            // this handles the case when the StateMachineWorkflow
            // is called using an Invoke activity
            if (!(state.Parent is StateActivity))
                return state;

            return GetRootState((StateActivity)state.Parent);
        }

        internal static bool IsInitialState(StateActivity state)
        {
            Debug.Assert(state != null);

            string initialStateName = GetInitialStateName(state);
            if (initialStateName == null)
                return false;

            return state.QualifiedName.Equals(initialStateName);
        }

        internal static bool IsCompletedState(StateActivity state)
        {
            Debug.Assert(state != null);

            string completedStateName = GetCompletedStateName(state);
            if (completedStateName == null)
                return false;

            return state.QualifiedName.Equals(completedStateName);
        }

        internal static string GetInitialStateName(StateActivity state)
        {
            StateActivity rootState = GetRootState(state);
            return (string)rootState.GetValue(StateMachineWorkflowActivity.InitialStateNameProperty);
        }

        internal static string GetCompletedStateName(StateActivity state)
        {
            Debug.Assert(state != null);
            StateActivity rootState = GetRootState(state);
            return (string)rootState.GetValue(StateMachineWorkflowActivity.CompletedStateNameProperty);
        }

        /*
        internal static bool IsInInitialStatePath(StateActivity state)
        {
            StateActivity rootState = GetRootState(state);
            string initialStateName = GetInitialStateName(rootState);

            StateActivity initialState = FindStateByName(rootState, initialStateName);
            CompositeActivity current = initialState;
            while (current != null)
            {
                if (current.QualifiedName == state.QualifiedName)
                    return true;
                current = current.Parent;
            }
            return false;
        }
         */

        /// <summary>
        /// Returns the State activity that is currently executing
        /// </summary>
        /// <param name="context"></param>
        /// <returns></returns>
        static internal StateActivity GetCurrentState(ActivityExecutionContext context)
        {
            StateActivity state = context.Activity as StateActivity;
            if (state == null)
                state = FindEnclosingState(context.Activity);
            Debug.Assert(state != null, "StateMachineHelpers.GetCurrentState: only valid to call this method from a State executor or a contained EventDriven");
            StateActivity rootState = GetRootState(state);

            StateMachineExecutionState executionState = StateMachineExecutionState.Get(rootState);
            string currentStateName = executionState.CurrentStateName;
            if (currentStateName == null)
                return null;

            StateActivity currentState = FindDynamicStateByName(rootState, currentStateName);
            Debug.Assert(currentState == null || IsLeafState(currentState));
            return currentState;
        }

        static internal StateActivity FindDynamicStateByName(StateActivity state, string stateQualifiedName)
        {
            while (!state.QualifiedName.Equals(stateQualifiedName) && ContainsState(state, stateQualifiedName))
            {
                foreach (Activity activity in state.EnabledActivities)
                {
                    StateActivity childState = activity as StateActivity;
                    if (childState == null)
                        continue;

                    if (ContainsState(childState, stateQualifiedName))
                    {
                        StateActivity dynamicChildState = (StateActivity)state.GetDynamicActivity(childState);
                        if (dynamicChildState == null)
                            return null;
                        state = dynamicChildState;
                        break;
                    }
                }
            }
            if (state.QualifiedName.Equals(stateQualifiedName))
                return state;
            else
                return null;
        }

        static internal StateActivity FindStateByName(StateActivity state, string qualifiedName)
        {
            Debug.Assert(state != null);
            Debug.Assert(qualifiedName != null);
            StateActivity found = FindActivityByName(state, qualifiedName) as StateActivity;
            return found;
        }

        static internal Activity FindActivityByName(CompositeActivity parentActivity, string qualifiedName)
        {
            return parentActivity.GetActivityByName(qualifiedName, true);
        }

        static internal bool ContainsEventActivity(CompositeActivity compositeActivity)
        {
            Debug.Assert(compositeActivity != null);

            Queue<Activity> activities = new Queue<Activity>();
            activities.Enqueue(compositeActivity);
            while (activities.Count > 0)
            {
                Activity activity = activities.Dequeue();
                if (activity is IEventActivity)
                    return true;

                compositeActivity = activity as CompositeActivity;
                if (compositeActivity != null)
                {
                    foreach (Activity child in compositeActivity.Activities)
                    {
                        if (child.Enabled)
                            activities.Enqueue(child);
                    }
                }
            }
            return false;
        }

        static internal IEventActivity GetEventActivity(EventDrivenActivity eventDriven)
        {
            CompositeActivity sequenceActivity = eventDriven as CompositeActivity;
            Debug.Assert(eventDriven.EnabledActivities.Count > 0);
            IEventActivity eventActivity = sequenceActivity.EnabledActivities[0] as IEventActivity;
            Debug.Assert(eventActivity != null);
            return eventActivity;
        }

        static internal EventDrivenActivity GetParentEventDriven(IEventActivity eventActivity)
        {
            Activity activity = ((Activity)eventActivity).Parent;
            while (activity != null)
            {
                EventDrivenActivity eventDriven = activity as EventDrivenActivity;
                if (eventDriven != null)
                    return eventDriven;

                activity = activity.Parent;
            }
            return null;
        }

        static internal bool ContainsState(StateActivity state, string stateName)
        {
            if (state == null)
                throw new ArgumentNullException("state");
            if (String.IsNullOrEmpty(stateName))
                throw new ArgumentNullException("stateName");

            Queue<StateActivity> states = new Queue<StateActivity>();
            states.Enqueue(state);
            while (states.Count > 0)
            {
                state = states.Dequeue();
                if (state.QualifiedName.Equals(stateName))
                    return true;

                foreach (Activity childActivity in state.EnabledActivities)
                {
                    StateActivity childState = childActivity as StateActivity;
                    if (childState != null)
                    {
                        states.Enqueue(childState);
                    }
                }
            }
            return false;
        }
    }

    #region StateMachineMessages
#if DEBUG
    /*
     * this is only used for testing the State Machine related resource messages
     *
    internal class StateMachineMessages
    {
        internal static void PrintMessages()
        {
            Console.WriteLine("GetInvalidUserDataInStateChangeTrackingRecord: {0}\n", SR.GetInvalidUserDataInStateChangeTrackingRecord());
            Console.WriteLine("GetError_EventDrivenInvalidFirstActivity: {0}\n", SR.GetError_EventDrivenInvalidFirstActivity());
            Console.WriteLine("GetError_InvalidLeafStateChild: {0}\n", SR.GetError_InvalidLeafStateChild());
            Console.WriteLine("GetError_InvalidCompositeStateChild: {0}\n", SR.GetError_InvalidCompositeStateChild());
            Console.WriteLine("GetError_SetStateOnlyWorksOnStateMachineWorkflow: {0}\n", SR.GetError_SetStateOnlyWorksOnStateMachineWorkflow());
            Console.WriteLine("GetError_SetStateMustPointToAState: {0}\n", SR.GetError_SetStateMustPointToAState());
            Console.WriteLine("GetError_InitialStateMustPointToAState: {0}\n", SR.GetError_InitialStateMustPointToAState());
            Console.WriteLine("GetError_CompletedStateMustPointToAState: {0}\n", SR.GetError_CompletedStateMustPointToAState());

            Console.WriteLine("GetError_SetStateMustPointToALeafNodeState: {0}\n", SR.GetError_SetStateMustPointToALeafNodeState());
            Console.WriteLine("GetError_InitialStateMustPointToALeafNodeState: {0}\n", SR.GetError_InitialStateMustPointToALeafNodeState());
            Console.WriteLine("GetError_CompletedStateMustPointToALeafNodeState: {0}\n", SR.GetError_CompletedStateMustPointToALeafNodeState());

            Console.WriteLine("GetError_StateInitializationParentNotState: {0}\n", SR.GetError_StateInitializationParentNotState());
            Console.WriteLine("GetError_StateFinalizationParentNotState: {0}\n", SR.GetError_StateFinalizationParentNotState());

            Console.WriteLine("GetError_EventActivityNotValidInStateInitialization: {0}\n", SR.GetError_EventActivityNotValidInStateInitialization());
            Console.WriteLine("GetError_EventActivityNotValidInStateFinalization: {0}\n", SR.GetError_EventActivityNotValidInStateFinalization());

            Console.WriteLine("GetError_MultipleStateInitializationActivities: {0}\n", SR.GetError_MultipleStateInitializationActivities());
            Console.WriteLine("GetError_MultipleStateFinalizationActivities: {0}\n", SR.GetError_MultipleStateFinalizationActivities());

            Console.WriteLine("GetError_InvalidTargetStateInStateInitialization: {0}\n", SR.GetError_InvalidTargetStateInStateInitialization());
            Console.WriteLine("GetError_CantRemoveState: {0}\n", SR.GetError_CantRemoveState());
            Console.WriteLine("GetSqlTrackingServiceRequired: {0}\n", SR.GetSqlTrackingServiceRequired());

            Console.WriteLine("GetStateMachineWorkflowMustHaveACurrentState: {0}\n", SR.GetStateMachineWorkflowMustHaveACurrentState());

            Console.WriteLine("GetInvalidActivityStatus: {0}\n", SR.GetInvalidActivityStatus(new Activity("Hello")));
            Console.WriteLine("GetStateMachineWorkflowRequired: {0}\n", SR.GetStateMachineWorkflowRequired());
            Console.WriteLine("GetError_EventDrivenParentNotListen: {0}\n", SR.GetError_EventDrivenParentNotListen());

            Console.WriteLine("GetGetUnableToTransitionToState: {0}\n", SR.GetUnableToTransitionToState("StateName"));
            Console.WriteLine("GetInvalidStateTransitionPath: {0}\n", SR.GetInvalidStateTransitionPath());
            Console.WriteLine("GetInvalidSetStateInStateInitialization: {0}\n", SR.GetInvalidSetStateInStateInitialization());
            Console.WriteLine("GetStateAlreadySubscribesToThisEvent: {0}\n", SR.GetStateAlreadySubscribesToThisEvent("StateName", "QueueName"));
        }
    }
    */

#endif
    #endregion
}