//-----------------------------------------------------------------------------
// Copyright (c) Microsoft Corporation.  All rights reserved.
//-----------------------------------------------------------------------------

namespace System.Activities
{
    using System;
    using System.Activities.Expressions;
    using System.Activities.Runtime;
    using System.Activities.Validation;
    using System.Collections;
    using System.Collections.Generic;
    using System.Collections.ObjectModel;
    using System.ComponentModel;
    using System.Globalization;
    using System.Reflection;
    using System.Runtime;
    using System.Text;

    static class ActivityUtilities
    {
        static Pop popActivity = new Pop();
        static Type activityType = typeof(Activity);
        static Type activityGenericType = typeof(Activity<>);
        static Type activityDelegateType = typeof(ActivityDelegate);
        static Type constraintType = typeof(Constraint);
        static Type variableType = typeof(Variable);
        static Type variableGenericType = typeof(Variable<>);
        static Type delegateInArgumentType = typeof(DelegateInArgument);
        static Type delegateOutArgumentType = typeof(DelegateOutArgument);
        static Type delegateInArgumentGenericType = typeof(DelegateInArgument<>);
        static Type delegateOutArgumentGenericType = typeof(DelegateOutArgument<>);
        static Type inArgumentType = typeof(InArgument);
        static Type inArgumentGenericType = typeof(InArgument<>);
        static Type inOutArgumentType = typeof(InOutArgument);
        static Type inOutArgumentGenericType = typeof(InOutArgument<>);
        static Type outArgumentType = typeof(OutArgument);
        static Type outArgumentGenericType = typeof(OutArgument<>);
        static Type argumentType = typeof(Argument);
        static Type argumentReferenceGenericType = typeof(ArgumentReference<>);
        static Type argumentValueGenericType = typeof(ArgumentValue<>);
        static Type runtimeArgumentType = typeof(RuntimeArgument);
        static Type locationGenericType = typeof(Location<>);
        static Type variableReferenceGenericType = typeof(VariableReference<>);
        static Type variableValueGenericType = typeof(VariableValue<>);
        static Type delegateArgumentValueGenericType = typeof(DelegateArgumentValue<>);
        static Type handleType = typeof(Handle);
        static Type iDictionaryGenericType = typeof(IDictionary<,>);
        static Type locationReferenceValueType = typeof(LocationReferenceValue<>);
        static Type environmentLocationValueType = typeof(EnvironmentLocationValue<>);
        static Type environmentLocationReferenceType = typeof(EnvironmentLocationReference<>); 
        static IList<Type> collectionInterfaces;
        static Type inArgumentOfObjectType = typeof(InArgument<object>);
        static Type outArgumentOfObjectType = typeof(OutArgument<object>);
        static Type inOutArgumentOfObjectType = typeof(InOutArgument<object>);
        static PropertyChangedEventArgs propertyChangedEventArgs;

        // Can't delay create this one because we use object.ReferenceEquals on it in WorkflowInstance
        static ReadOnlyDictionaryInternal<string, object> emptyParameters = new ReadOnlyDictionaryInternal<string, object>(new Dictionary<string, object>(0));

        public static ReadOnlyDictionaryInternal<string, object> EmptyParameters
        {
            get
            {
                return emptyParameters;
            }
        }

        internal static PropertyChangedEventArgs ValuePropertyChangedEventArgs
        {
            get
            {
                if (propertyChangedEventArgs == null)
                {
                    propertyChangedEventArgs = new PropertyChangedEventArgs("Value");
                }
                return propertyChangedEventArgs;
            }
        }

        static IList<Type> CollectionInterfaces
        {
            get
            {
                if (collectionInterfaces == null)
                {
                    collectionInterfaces = new List<Type>(2)
                        {
                            typeof(IList<>),
                            typeof(ICollection<>)
                        };
                }
                return collectionInterfaces;
            }
        }

        public static bool IsInScope(ActivityInstance potentialChild, ActivityInstance scope)
        {
            if (scope == null)
            {
                // No scope means we're in scope
                return true;
            }

            ActivityInstance walker = potentialChild;

            while (walker != null && walker != scope)
            {
                walker = walker.Parent;
            }

            return walker != null;
        }

        public static bool IsHandle(Type type)
        {
            return handleType.IsAssignableFrom(type);
        }

        public static bool IsCompletedState(ActivityInstanceState state)
        {
            return state != ActivityInstanceState.Executing;
        }

        public static bool TryGetArgumentDirectionAndType(Type propertyType, out ArgumentDirection direction, out Type argumentType)
        {
            direction = ArgumentDirection.In; // default to In
            argumentType = TypeHelper.ObjectType;  // default to object

            if (propertyType.IsGenericType)
            {
                argumentType = propertyType.GetGenericArguments()[0];

                Type genericType = propertyType.GetGenericTypeDefinition();

                if (genericType == inArgumentGenericType)
                {
                    return true;
                }

                if (genericType == outArgumentGenericType)
                {
                    direction = ArgumentDirection.Out;
                    return true;
                }

                if (genericType == inOutArgumentGenericType)
                {
                    direction = ArgumentDirection.InOut;
                    return true;
                }
            }
            else
            {
                if (propertyType == inArgumentType)
                {
                    return true;
                }

                if (propertyType == outArgumentType)
                {
                    direction = ArgumentDirection.Out;
                    return true;
                }

                if (propertyType == inOutArgumentType)
                {
                    direction = ArgumentDirection.InOut;
                    return true;
                }
            }

            return false;
        }

        public static bool IsArgumentType(Type propertyType)
        {
            return TypeHelper.AreTypesCompatible(propertyType, argumentType);
        }

        public static bool IsRuntimeArgumentType(Type propertyType)
        {
            return TypeHelper.AreTypesCompatible(propertyType, runtimeArgumentType);
        }

        public static bool IsArgumentDictionaryType(Type type, out Type innerType)
        {
            if (type.IsGenericType)
            {
                bool implementsIDictionary = false;
                Type dictionaryInterfaceType = null;

                if (type.GetGenericTypeDefinition() == iDictionaryGenericType)
                {
                    implementsIDictionary = true;
                    dictionaryInterfaceType = type;
                }
                else
                {
                    foreach (Type interfaceType in type.GetInterfaces())
                    {
                        if (interfaceType.IsGenericType &&
                            interfaceType.GetGenericTypeDefinition() == iDictionaryGenericType)
                        {
                            implementsIDictionary = true;
                            dictionaryInterfaceType = interfaceType;
                            break;
                        }
                    }
                }

                if (implementsIDictionary == true)
                {
                    Type[] genericArguments = dictionaryInterfaceType.GetGenericArguments();
                    if (genericArguments[0] == TypeHelper.StringType &&
                        IsArgumentType(genericArguments[1]))
                    {
                        innerType = genericArguments[1];
                        return true;
                    }
                }
            }

            innerType = null;
            return false;
        }

        public static bool IsKnownCollectionType(Type type, out Type innerType)
        {
            if (type.IsGenericType)
            {
                if (type.IsInterface)
                {
                    Type localInterface = type.GetGenericTypeDefinition();
                    foreach (Type knownInterface in CollectionInterfaces)
                    {
                        if (localInterface == knownInterface)
                        {
                            Type[] genericArguments = type.GetGenericArguments();
                            if (genericArguments.Length == 1)
                            {
                                innerType = genericArguments[0];
                                return true;
                            }
                        }
                    }
                }
                else
                {
                    // Ask the type whether or not it implements any known collections.
                    Type[] interfaceTypes = type.GetInterfaces();
                    foreach (Type interfaceType in interfaceTypes)
                    {
                        if (interfaceType.IsGenericType)
                        {
                            Type localInterface = interfaceType.GetGenericTypeDefinition();

                            foreach (Type knownInterface in CollectionInterfaces)
                            {
                                if (localInterface == knownInterface)
                                {
                                    Type[] genericArguments = interfaceType.GetGenericArguments();
                                    if (genericArguments.Length == 1)
                                    {
                                        innerType = genericArguments[0];
                                        return true;
                                    }
                                }
                            }
                        }
                    }
                }
            }

            innerType = null;
            return false;
        }

        public static bool IsActivityDelegateType(Type propertyType)
        {
            return TypeHelper.AreTypesCompatible(propertyType, activityDelegateType);
        }
        
        public static bool IsActivityType(Type propertyType)
        {
            return IsActivityType(propertyType, true);
        }

        public static bool IsActivityType(Type propertyType, bool includeConstraints)
        {
            if (!TypeHelper.AreTypesCompatible(propertyType, activityType))
            {
                return false;
            }

            // sometimes (for reflection analysis of Activity properties) we don't want constraints to count
            return includeConstraints || !TypeHelper.AreTypesCompatible(propertyType, constraintType);
        }

        public static bool TryGetDelegateArgumentDirectionAndType(Type propertyType, out ArgumentDirection direction, out Type argumentType)
        {
            direction = ArgumentDirection.In; // default to In
            argumentType = TypeHelper.ObjectType;  // default to object

            if (propertyType.IsGenericType)
            {
                argumentType = propertyType.GetGenericArguments()[0];

                Type genericType = propertyType.GetGenericTypeDefinition();

                if (genericType == delegateInArgumentGenericType)
                {
                    return true;
                }

                if (genericType == delegateOutArgumentGenericType)
                {
                    direction = ArgumentDirection.Out;
                    return true;
                }
            }
            else
            {
                if (propertyType == delegateInArgumentType)
                {
                    return true;
                }

                if (propertyType == delegateOutArgumentType)
                {
                    direction = ArgumentDirection.Out;
                    return true;
                }
            }

            return false;
        }

        public static bool IsVariableType(Type propertyType, out Type innerType)
        {
            if (propertyType.IsGenericType && propertyType.GetGenericTypeDefinition() == variableGenericType)
            {
                innerType = propertyType.GetGenericArguments()[0];
                return true;
            }

            innerType = null;
            return TypeHelper.AreTypesCompatible(propertyType, variableType);
        }

        public static bool IsVariableType(Type propertyType)
        {
            if (propertyType.IsGenericType && propertyType.GetGenericTypeDefinition() == variableGenericType)
            {
                return true;
            }

            return TypeHelper.AreTypesCompatible(propertyType, variableType);
        }

        public static bool IsLocationGenericType(Type type, out Type genericArgumentType)
        {
            if (type.IsGenericType && type.GetGenericTypeDefinition() == locationGenericType)
            {
                genericArgumentType = type.GetGenericArguments()[0];
                return true;
            }

            genericArgumentType = null;
            return false;
        }

        public static object CreateVariableReference(Variable variable)
        {
            Type genericVariableReferenceType = variableReferenceGenericType.MakeGenericType(variable.Type);
            object variableReference = Activator.CreateInstance(genericVariableReferenceType);
            genericVariableReferenceType.GetProperty("Variable").SetValue(variableReference, variable, null);
            return variableReference;
        }

        public static ActivityWithResult CreateLocationAccessExpression(LocationReference locationReference, bool isReference, bool useLocationReferenceValue)
        {
            return LocationAccessExpressionTypeDefinitionsCache.CreateNewLocationAccessExpression(locationReference.Type, isReference, useLocationReferenceValue, locationReference);
        }

        public static Argument CreateArgument(Type type, ArgumentDirection direction)
        {
            Type argumentType = ArgumentTypeDefinitionsCache.GetArgumentType(type, direction);

            Argument argument = (Argument)Activator.CreateInstance(argumentType);

            return argument;
        }

        public static Argument CreateArgumentOfObject(ArgumentDirection direction)
        {
            Argument argument = null;

            if (direction == ArgumentDirection.In)
            {
                argument = (Argument)Activator.CreateInstance(inArgumentOfObjectType);
            }
            else if (direction == ArgumentDirection.Out)
            {
                argument = (Argument)Activator.CreateInstance(outArgumentOfObjectType);
            }
            else
            {
                argument = (Argument)Activator.CreateInstance(inOutArgumentOfObjectType);
            }

            return argument;
        }

        public static Type CreateLocation(Type locationType)
        {
            return locationGenericType.MakeGenericType(locationType);
        }

        public static Type CreateActivityWithResult(Type resultType)
        {
            return activityGenericType.MakeGenericType(resultType);
        }

        public static Argument CreateReferenceArgument(Type argumentType, ArgumentDirection direction, string referencedArgumentName)
        {
            Argument argument = Argument.Create(argumentType, direction);
            
            object argumentReference = null;

            if (direction == ArgumentDirection.In)
            {
                // If it is an In then we need an ArgumentValue<T>
                argumentReference = Activator.CreateInstance(argumentValueGenericType.MakeGenericType(argumentType), referencedArgumentName);
            }
            else
            {
                // If it is InOut or Out we need an ArgumentReference<T>
                argumentReference = Activator.CreateInstance(argumentReferenceGenericType.MakeGenericType(argumentType), referencedArgumentName);
            }

            argument.Expression = (ActivityWithResult)argumentReference;
            return argument;
        }

        public static Variable CreateVariable(string name, Type type, VariableModifiers modifiers)
        {
            Type variableType = variableGenericType.MakeGenericType(type);
            Variable variable = (Variable)Activator.CreateInstance(variableType);
            variable.Name = name;
            variable.Modifiers = modifiers;

            return variable;
        }

        // The argumentConsumer is the activity that is attempting to reference the argument
        // with argumentName.  That means that argumentConsumer must be in the Implementation
        // of an activity that defines an argument with argumentName.
        public static RuntimeArgument FindArgument(string argumentName, Activity argumentConsumer)
        {
            if (argumentConsumer.MemberOf != null && argumentConsumer.MemberOf.Owner != null)
            {
                Activity targetActivity = argumentConsumer.MemberOf.Owner;

                for (int i = 0; i < targetActivity.RuntimeArguments.Count; i++)
                {
                    RuntimeArgument argument = targetActivity.RuntimeArguments[i];

                    if (argument.Name == argumentName)
                    {
                        return argument;
                    }
                }
            }

            return null;
        }

        public static string GetDisplayName(object source)
        {
            Fx.Assert(source != null, "caller must verify");
            return GetDisplayName(source.GetType());
        }

        static string GetDisplayName(Type sourceType)
        {
            if (sourceType.IsGenericType)
            {
                // start with the type name
                string displayName = sourceType.Name;
                int tickIndex = displayName.IndexOf('`');

                // remove the tick+number of parameters "generics format". Note that the
                // tick won't exist for nested implicitly generic classes, such as Foo`1+Bar
                if (tickIndex > 0) 
                {
                    displayName = displayName.Substring(0, tickIndex);
                }
    
                // and provide a more readable version based on the closure type names
                Type[] genericArguments = sourceType.GetGenericArguments();
                StringBuilder stringBuilder = new StringBuilder(displayName);
                stringBuilder.Append("<");
                for (int i = 0; i < genericArguments.Length - 1; i++)
                {
                    stringBuilder.AppendFormat("{0},", GetDisplayName(genericArguments[i]));
                }
                stringBuilder.AppendFormat("{0}>", GetDisplayName(genericArguments[genericArguments.Length - 1]));
                return stringBuilder.ToString();
            }
            else
            {
                Fx.Assert(!sourceType.IsGenericTypeDefinition, "we have an actual object, so we should never have a generic type definition");
                return sourceType.Name;
            }
        }

        internal static void ValidateOrigin(object origin, Activity activity)
        {
            if (origin != null &&
                (origin is Activity || origin is Argument || origin is ActivityDelegate || origin is LocationReference))
            {
                activity.AddTempValidationError(new ValidationError(SR.OriginCannotBeRuntimeIntrinsic(origin)));
            }
        }

        // Returns true if there are any children
        static void ProcessChildren(Activity parent, IList<Activity> children, ActivityCollectionType collectionType, bool addChildren, ref ChildActivity nextActivity, ref Stack<ChildActivity> activitiesRemaining, ref IList<ValidationError> validationErrors)
        {
            for (int i = 0; i < children.Count; i++)
            {
                Activity childActivity = children[i];
                if (childActivity.InitializeRelationship(parent, collectionType, ref validationErrors))
                {
                    if (addChildren)
                    {
                        SetupForProcessing(childActivity, collectionType != ActivityCollectionType.Imports, ref nextActivity, ref activitiesRemaining);
                    }
                }
            }
        }

        // Note that we do not need an "isPublicCollection" parameter since all arguments are public
        // Returns true if there are any non-null expressions
        static void ProcessArguments(Activity parent, IList<RuntimeArgument> arguments, bool addChildren, ref ActivityLocationReferenceEnvironment environment, ref int nextEnvironmentId, ref ChildActivity nextActivity, ref Stack<ChildActivity> activitiesRemaining, ref IList<ValidationError> validationErrors)
        {
            if (arguments.Count > 0)
            {
                if (environment == null)
                {
                    environment = new ActivityLocationReferenceEnvironment(parent.GetParentEnvironment());
                }

                for (int i = 0; i < arguments.Count; i++)
                {
                    RuntimeArgument argument = arguments[i];
                    if (argument.InitializeRelationship(parent, ref validationErrors))
                    {
                        argument.Id = nextEnvironmentId;
                        nextEnvironmentId++;

                        // This must be called after InitializeRelationship since it makes
                        // use of RuntimeArgument.Owner;
                        environment.Declare(argument, argument.Owner, ref validationErrors);

                        if (addChildren)
                        {
                            SetupForProcessing(argument, ref nextActivity, ref activitiesRemaining);
                        }
                    }
                }
            }
        }

        // Returns true if there are any non-null defaults
        static void ProcessVariables(Activity parent, IList<Variable> variables, ActivityCollectionType collectionType, bool addChildren, ref ActivityLocationReferenceEnvironment environment, ref int nextEnvironmentId, ref ChildActivity nextActivity, ref Stack<ChildActivity> activitiesRemaining, ref IList<ValidationError> validationErrors)
        {
            if (variables.Count > 0)
            {
                if (environment == null)
                {
                    environment = new ActivityLocationReferenceEnvironment(parent.GetParentEnvironment());
                }

                for (int i = 0; i < variables.Count; i++)
                {
                    Variable variable = variables[i];
                    if (variable.InitializeRelationship(parent, collectionType == ActivityCollectionType.Public, ref validationErrors))
                    {
                        variable.Id = nextEnvironmentId;
                        nextEnvironmentId++;

                        // This must be called after InitializeRelationship since it makes
                        // use of Variable.Owner;
                        environment.Declare(variable, variable.Owner, ref validationErrors);

                        if (addChildren)
                        {
                            SetupForProcessing(variable, ref nextActivity, ref activitiesRemaining);
                        }
                    }
                }
            }
        }

        // Returns true if there are any non-null handlers
        static void ProcessDelegates(Activity parent, IList<ActivityDelegate> delegates, ActivityCollectionType collectionType, bool addChildren, ref ChildActivity nextActivity, ref Stack<ChildActivity> activitiesRemaining, ref IList<ValidationError> validationErrors)
        {
            for (int i = 0; i < delegates.Count; i++)
            {
                ActivityDelegate activityDelegate = delegates[i];
                if (activityDelegate.InitializeRelationship(parent, collectionType, ref validationErrors))
                {
                    if (addChildren)
                    {
                        SetupForProcessing(activityDelegate, collectionType != ActivityCollectionType.Imports, ref nextActivity, ref activitiesRemaining);
                    }
                }
            }
        }

        static void ProcessActivity(ChildActivity childActivity, ref ChildActivity nextActivity, ref Stack<ChildActivity> activitiesRemaining, ActivityCallStack parentChain, ref IList<ValidationError> validationErrors, ProcessActivityTreeOptions options, ProcessActivityCallback callback)
        {
            Fx.Assert(options != null, "options should not be null.");

            if (options.CancellationToken.IsCancellationRequested)
            {
                throw FxTrace.Exception.AsError(new OperationCanceledException(options.CancellationToken));
            }

            Activity activity = childActivity.Activity;
            IList<Constraint> constraints = activity.RuntimeConstraints;
            IList<ValidationError> tempValidationErrors = null;

            Fx.Assert(validationErrors == null || !options.StoreTempViolations, "Incoming violations should be null if we are storing them in Activity.tempViolations.");

            if (!activity.HasStartedCachingMetadata)
            {
                // We need to add this activity to the IdSpace first so that we have a meaningful ID
                // for any errors that may occur.
                Fx.Assert(activity.MemberOf != null, "We always set this ahead of time - the root is set in InitializeAsRoot and all others are set in InitializeRelationship.");
                activity.MemberOf.AddMember(activity);

                if (TD.InternalCacheMetadataStartIsEnabled())
                {
                    TD.InternalCacheMetadataStart(activity.Id);
                }
                activity.InternalCacheMetadata(options.CreateEmptyBindings, ref tempValidationErrors);
                if (TD.InternalCacheMetadataStopIsEnabled())
                {
                    TD.InternalCacheMetadataStop(activity.Id);
                }

                ActivityValidationServices.ValidateArguments(activity, activity.Parent == null, ref tempValidationErrors);

                ActivityLocationReferenceEnvironment newPublicEnvironment = null;
                ActivityLocationReferenceEnvironment newImplementationEnvironment = new ActivityLocationReferenceEnvironment(activity.HostEnvironment)
                {
                    InternalRoot = activity
                };

                int nextEnvironmentId = 0;

                ProcessChildren(activity, activity.Children, ActivityCollectionType.Public, true, ref nextActivity, ref activitiesRemaining, ref tempValidationErrors);
                ProcessChildren(activity, activity.ImportedChildren, ActivityCollectionType.Imports, true, ref nextActivity, ref activitiesRemaining, ref tempValidationErrors);
                ProcessChildren(activity, activity.ImplementationChildren, ActivityCollectionType.Implementation, !options.SkipPrivateChildren, ref nextActivity, ref activitiesRemaining, ref tempValidationErrors);

                ProcessArguments(activity, activity.RuntimeArguments, true, ref newImplementationEnvironment, ref nextEnvironmentId, ref nextActivity, ref activitiesRemaining, ref tempValidationErrors);

                ProcessVariables(activity, activity.RuntimeVariables, ActivityCollectionType.Public, true, ref newPublicEnvironment, ref nextEnvironmentId, ref nextActivity, ref activitiesRemaining, ref tempValidationErrors);
                ProcessVariables(activity, activity.ImplementationVariables, ActivityCollectionType.Implementation, !options.SkipPrivateChildren, ref newImplementationEnvironment, ref nextEnvironmentId, ref nextActivity, ref activitiesRemaining, ref tempValidationErrors);

                if (activity.HandlerOf != null)
                {
                    // Since we are a delegate handler we have to do some processing
                    // of the handlers parameters.  This is the one part of the tree
                    // walk that actually reaches _up_ to process something we've
                    // already passed.

                    for (int i = 0; i < activity.HandlerOf.RuntimeDelegateArguments.Count; i++)
                    {
                        RuntimeDelegateArgument delegateArgument = activity.HandlerOf.RuntimeDelegateArguments[i];
                        DelegateArgument boundArgument = delegateArgument.BoundArgument;
                        if (boundArgument != null)
                        {
                            // At runtime, delegate arguments end up owned by the Handler
                            // and are scoped like public variables of the handler.
                            //
                            // And since they don't own an expression, there's no equivalent
                            // SetupForProcessing method for DelegateArguments
                            if (boundArgument.InitializeRelationship(activity, ref tempValidationErrors))
                            {
                                boundArgument.Id = nextEnvironmentId;
                                nextEnvironmentId++;
                            }
                        }
                    }
                }

                // NOTE: At this point the declared environment is complete (either we're using the parent or we've got a new one)
                if (newPublicEnvironment == null)
                {
                    activity.PublicEnvironment = new ActivityLocationReferenceEnvironment(activity.GetParentEnvironment());
                }
                else
                {
                    if (newPublicEnvironment.Parent == null)
                    {
                        newPublicEnvironment.InternalRoot = activity;
                    }

                    activity.PublicEnvironment = newPublicEnvironment;
                }

                activity.ImplementationEnvironment = newImplementationEnvironment;

                // ProcessDelegates uses activity.Environment
                ProcessDelegates(activity, activity.Delegates, ActivityCollectionType.Public, true, ref nextActivity, ref activitiesRemaining, ref tempValidationErrors);
                ProcessDelegates(activity, activity.ImportedDelegates, ActivityCollectionType.Imports, true, ref nextActivity, ref activitiesRemaining, ref tempValidationErrors);
                ProcessDelegates(activity, activity.ImplementationDelegates, ActivityCollectionType.Implementation, !options.SkipPrivateChildren, ref nextActivity, ref activitiesRemaining, ref tempValidationErrors);

                if (callback != null)
                {
                    callback(childActivity, parentChain);
                }

                // copy validation errors in ValidationErrors list
                if (tempValidationErrors != null)
                {
                    if (validationErrors == null)
                    {
                        validationErrors = new List<ValidationError>();
                    }
                    Activity source;
                    string prefix = ActivityValidationServices.GenerateValidationErrorPrefix(childActivity.Activity, parentChain, options, out source);

                    for (int i = 0; i < tempValidationErrors.Count; i++)
                    {
                        ValidationError validationError = tempValidationErrors[i];

                        validationError.Source = source;
                        validationError.Id = source.Id;

                        if (!string.IsNullOrEmpty(prefix))
                        {
                            validationError.Message = prefix + validationError.Message;
                        }

                        validationErrors.Add(validationError);
                    }

                    tempValidationErrors = null;
                }

                if (options.StoreTempViolations)
                {
                    if (validationErrors != null)
                    {
                        childActivity.Activity.SetTempValidationErrorCollection(validationErrors);
                        validationErrors = null;
                    }
                }
            }
            else
            {
                // We're processing a reference


                // Add all the children for processing even though they've already
                // been seen.
                SetupForProcessing(activity.Children, true, ref nextActivity, ref activitiesRemaining);
                SetupForProcessing(activity.ImportedChildren, false, ref nextActivity, ref activitiesRemaining);

                SetupForProcessing(activity.RuntimeArguments, ref nextActivity, ref activitiesRemaining);

                SetupForProcessing(activity.RuntimeVariables, ref nextActivity, ref activitiesRemaining);

                SetupForProcessing(activity.Delegates, true, ref nextActivity, ref activitiesRemaining);
                SetupForProcessing(activity.ImportedDelegates, false, ref nextActivity, ref activitiesRemaining);

                if (!options.SkipPrivateChildren)
                {
                    SetupForProcessing(activity.ImplementationChildren, true, ref nextActivity, ref activitiesRemaining);
                    SetupForProcessing(activity.ImplementationDelegates, true, ref nextActivity, ref activitiesRemaining);
                    SetupForProcessing(activity.ImplementationVariables, ref nextActivity, ref activitiesRemaining);
                }

                if (callback != null && !options.OnlyCallCallbackForDeclarations)
                {
                    callback(childActivity, parentChain);
                }

                if (childActivity.Activity.HasTempViolations && !options.StoreTempViolations)
                {
                    childActivity.Activity.TransferTempValidationErrors(ref validationErrors);
                }
            }           

            // We only run constraints if the activity could possibly
            // execute and we aren't explicitly skipping them.
            if (!options.SkipConstraints && parentChain.WillExecute && childActivity.CanBeExecuted && constraints.Count > 0)
            {
                ActivityValidationServices.RunConstraints(childActivity, parentChain, constraints, options, false, ref validationErrors);
            }           
        }

        // We explicitly call this CacheRootMetadata since it treats the provided
        // activity as the root of the tree.
        public static void CacheRootMetadata(Activity activity, LocationReferenceEnvironment hostEnvironment, ProcessActivityTreeOptions options, ProcessActivityCallback callback, ref IList<ValidationError> validationErrors)
        {
            if (TD.CacheRootMetadataStartIsEnabled())
            {
                TD.CacheRootMetadataStart(activity.DisplayName);
            }
            if (!ShouldShortcut(activity, options))
            {
                lock (activity.ThisLock)
                {
                    if (!ShouldShortcut(activity, options))
                    {
                        if (activity.HasBeenAssociatedWithAnInstance)
                        {
                            throw FxTrace.Exception.AsError(new InvalidOperationException(SR.RootActivityAlreadyAssociatedWithInstance(activity.DisplayName)));
                        }

                        activity.InitializeAsRoot(hostEnvironment);

                        ProcessActivityTreeCore(new ChildActivity(activity, true), null, options, callback, ref validationErrors);

                        // Regardless of where the violations came from we only want to
                        // set ourselves RuntimeReady if there are no errors and are
                        // fully cached.
                        if (!ActivityValidationServices.HasErrors(validationErrors) && options.IsRuntimeReadyOptions)
                        {
                            // We don't really support progressive caching at runtime so we only set ourselves
                            // as runtime ready if we cached the whole workflow and created empty bindings.
                            // In order to support progressive caching we need to deal with the following
                            // issues:
                            //   * We need a mechanism for supporting activities which supply extensions
                            //   * We need to understand when we haven't created empty bindings so that
                            //     we can progressively create them
                            //   * We need a mechanism for making sure that we've validated parent related
                            //     constraints at all possible callsites
                            activity.SetRuntimeReady();
                        }
                    }
                }
            }
            if (TD.CacheRootMetadataStopIsEnabled())
            {
                TD.CacheRootMetadataStop(activity.DisplayName);
            }
        }

        // This API is only valid from ProcessActivityCallbacks.  It will cache the rest of the subtree rooted at the
        // provided activity allowing inspection of child metadata before the normal caching pass hits it.
        public static void FinishCachingSubtree(ChildActivity subtreeRoot, ActivityCallStack parentChain, ProcessActivityTreeOptions options)
        {
            IList<ValidationError> discardedValidationErrors = null;
            ProcessActivityTreeCore(subtreeRoot, parentChain, ProcessActivityTreeOptions.GetFinishCachingSubtreeOptions(options), new ProcessActivityCallback(NoOpCallback), ref discardedValidationErrors);
        }

        public static void FinishCachingSubtree(ChildActivity subtreeRoot, ActivityCallStack parentChain, ProcessActivityTreeOptions options, ProcessActivityCallback callback)
        {
            IList<ValidationError> discardedValidationErrors = null;
            ProcessActivityTreeCore(subtreeRoot, parentChain, ProcessActivityTreeOptions.GetFinishCachingSubtreeOptions(options), callback, ref discardedValidationErrors);
        }

        static void NoOpCallback(ChildActivity element, ActivityCallStack parentChain)
        {
        }

        static bool ShouldShortcut(Activity activity, ProcessActivityTreeOptions options)
        {
            if (options.SkipIfCached && options.IsRuntimeReadyOptions)
            {
                return activity.IsRuntimeReady;
            }

            return false;
        }

        static void ProcessActivityTreeCore(ChildActivity currentActivity, ActivityCallStack parentChain, ProcessActivityTreeOptions options, ProcessActivityCallback callback, ref IList<ValidationError> validationErrors)
        {
            Fx.Assert(options != null, "We need you to explicitly specify options.");
            Fx.Assert(currentActivity.Activity.MemberOf != null, "We must have an activity with MemberOf setup or we need to skipIdGeneration.");

            ChildActivity nextActivity = ChildActivity.Empty;
            Stack<ChildActivity> activitiesRemaining = null;

            if (parentChain == null)
            {
                parentChain = new ActivityCallStack();
            }

            if (options.OnlyVisitSingleLevel)
            {
                ProcessActivity(currentActivity, ref nextActivity, ref activitiesRemaining, parentChain, ref validationErrors, options, callback);
            }
            else
            {
                while (!currentActivity.Equals(ChildActivity.Empty))
                {
                    if (object.ReferenceEquals(currentActivity.Activity, popActivity))
                    {
                        ChildActivity completedParent = parentChain.Pop();
                        completedParent.Activity.SetCached(isSkippingPrivateChildren: options.SkipPrivateChildren);
                    }
                    else
                    {
                        SetupForProcessing(popActivity, true, ref nextActivity, ref activitiesRemaining);
                        ProcessActivity(currentActivity, ref nextActivity, ref activitiesRemaining, parentChain, ref validationErrors, options, callback);
                        parentChain.Push(currentActivity);
                    }

                    // nextActivity is the top of the stack
                    //    stackTop => nextActivity => currentActivity
                    currentActivity = nextActivity;

                    if (activitiesRemaining != null && activitiesRemaining.Count > 0)
                    {
                        nextActivity = activitiesRemaining.Pop();
                    }
                    else
                    {
                        nextActivity = ChildActivity.Empty;
                    }
                }
            }
        }

        static void SetupForProcessing(IList<Activity> children, bool canBeExecuted, ref ChildActivity nextActivity, ref Stack<ChildActivity> activitiesRemaining)
        {
            for (int i = 0; i < children.Count; i++)
            {
                SetupForProcessing(children[i], canBeExecuted, ref nextActivity, ref activitiesRemaining);
            }
        }

        static void SetupForProcessing(IList<ActivityDelegate> delegates, bool canBeExecuted, ref ChildActivity nextActivity, ref Stack<ChildActivity> activitiesRemaining)
        {
            for (int i = 0; i < delegates.Count; i++)
            {
                SetupForProcessing(delegates[i], canBeExecuted, ref nextActivity, ref activitiesRemaining);
            }
        }

        static void SetupForProcessing(IList<Variable> variables, ref ChildActivity nextActivity, ref Stack<ChildActivity> activitiesRemaining)
        {
            for (int i = 0; i < variables.Count; i++)
            {
                SetupForProcessing(variables[i], ref nextActivity, ref activitiesRemaining);
            }
        }

        static void SetupForProcessing(IList<RuntimeArgument> arguments, ref ChildActivity nextActivity, ref Stack<ChildActivity> activitiesRemaining)
        {
            for (int i = 0; i < arguments.Count; i++)
            {
                SetupForProcessing(arguments[i], ref nextActivity, ref activitiesRemaining);
            }
        }

        static void SetupForProcessing(ActivityDelegate activityDelegate, bool canBeExecuted, ref ChildActivity nextActivity, ref Stack<ChildActivity> activitiesRemaining)
        {
            if (activityDelegate.Handler != null)
            {
                SetupForProcessing(activityDelegate.Handler, canBeExecuted, ref nextActivity, ref activitiesRemaining);
            }
        }

        static void SetupForProcessing(Variable variable, ref ChildActivity nextActivity, ref Stack<ChildActivity> activitiesRemaining)
        {
            if (variable.Default != null)
            {
                SetupForProcessing(variable.Default, true, ref nextActivity, ref activitiesRemaining);
            }
        }

        static void SetupForProcessing(RuntimeArgument argument, ref ChildActivity nextActivity, ref Stack<ChildActivity> activitiesRemaining)
        {
            if (argument.BoundArgument != null && !argument.BoundArgument.IsEmpty)
            {
                SetupForProcessing(argument.BoundArgument.Expression, true, ref nextActivity, ref activitiesRemaining);
            }
        }

        // nextActivity is always the top of the stack
        static void SetupForProcessing(Activity activity, bool canBeExecuted, ref ChildActivity nextActivity, ref Stack<ChildActivity> activitiesRemaining)
        {
            if (!nextActivity.Equals(ChildActivity.Empty))
            {
                if (activitiesRemaining == null)
                {
                    activitiesRemaining = new Stack<ChildActivity>();
                }

                activitiesRemaining.Push(nextActivity);
            }

            nextActivity = new ChildActivity(activity, canBeExecuted);
        }

        public static void ProcessActivityInstanceTree(ActivityInstance rootInstance, ActivityExecutor executor, Func<ActivityInstance, ActivityExecutor, bool> callback)
        {
            Queue<IList<ActivityInstance>> instancesRemaining = null;

            TreeProcessingList currentInstancesList = new TreeProcessingList();
            currentInstancesList.Add(rootInstance);

            TreeProcessingList nextInstanceList = null;
            if (rootInstance.HasChildren)
            {
                nextInstanceList = new TreeProcessingList();
            }

            while ((instancesRemaining != null && instancesRemaining.Count > 0)
                || currentInstancesList.Count != 0)
            {
                if (currentInstancesList.Count == 0)
                {
                    Fx.Assert(instancesRemaining != null && instancesRemaining.Count > 0, "This must be the clause that caused us to enter");
                    currentInstancesList.Set(instancesRemaining.Dequeue());
                }

                for (int i = 0; i < currentInstancesList.Count; i++)
                {
                    ActivityInstance instance = currentInstancesList[i];

                    if (callback(instance, executor) && instance.HasChildren)
                    {
                        Fx.Assert(nextInstanceList != null, "We should have created this list if we are going to get here.");
                        instance.AppendChildren(nextInstanceList, ref instancesRemaining);
                    }
                }

                if (nextInstanceList != null && nextInstanceList.Count > 0)
                {
                    nextInstanceList.TransferTo(currentInstancesList);
                }
                else
                {
                    // We'll just reuse this object on the next pass (Set will be called)
                    currentInstancesList.Reset();
                }
            }
        }

        public delegate void ProcessActivityCallback(ChildActivity childActivity, ActivityCallStack parentChain);

        public static FaultBookmark CreateFaultBookmark(FaultCallback onFaulted, ActivityInstance owningInstance)
        {
            if (onFaulted != null)
            {
                return new FaultBookmark(new FaultCallbackWrapper(onFaulted, owningInstance));
            }
            return null;
        }

        public static CompletionBookmark CreateCompletionBookmark(CompletionCallback onCompleted, ActivityInstance owningInstance)
        {
            if (onCompleted != null)
            {
                return new CompletionBookmark(new ActivityCompletionCallbackWrapper(onCompleted, owningInstance));
            }
            return null;
        }

        public static CompletionBookmark CreateCompletionBookmark(DelegateCompletionCallback onCompleted, ActivityInstance owningInstance)
        {
            if (onCompleted != null)
            {
                return new CompletionBookmark(new DelegateCompletionCallbackWrapper(onCompleted, owningInstance));
            }
            return null;
        }

        public static CompletionBookmark CreateCompletionBookmark<TResult>(CompletionCallback<TResult> onCompleted, ActivityInstance owningInstance)
        {
            if (onCompleted != null)
            {
                return new CompletionBookmark(new FuncCompletionCallbackWrapper<TResult>(onCompleted, owningInstance));
            }

            return null;
        }

        public static string GetTraceString(Bookmark bookmark)
        {
            if (bookmark.IsNamed)
            {
                return "'" + bookmark.Name + "'";
            }
            else
            {
                return string.Format(CultureInfo.InvariantCulture, "<Unnamed Id={0}>", bookmark.Id);
            }
        }

        public static string GetTraceString(BookmarkScope bookmarkScope)
        {
            if (bookmarkScope == null)
            {
                return "<None>";
            }
            else if (bookmarkScope.IsInitialized)
            {
                return "'" + bookmarkScope.Id.ToString() + "'";
            }
            else
            {
                return string.Format(CultureInfo.InvariantCulture, "<Uninitialized TemporaryId={0}>", bookmarkScope.TemporaryId);
            }
        }

        public static void RemoveNulls(IList list)
        {
            if (list != null)
            {
                for (int i = list.Count - 1; i >= 0; i--)
                {
                    if (list[i] == null)
                    {
                        list.RemoveAt(i);
                    }
                }
            }
        }

        public static void Add<T>(ref Collection<T> collection, T data)
        {
            if (data != null)
            {
                if (collection == null)
                {
                    collection = new Collection<T>();
                }
                collection.Add(data);
            }
        }

        public static void Add<T>(ref IList<T> list, T data)
        {
            if (data != null)
            {
                if (list == null)
                {
                    list = new List<T>();
                }
                list.Add(data);
            }
        }

        public class TreeProcessingList
        {
            ActivityInstance singleItem;
            IList<ActivityInstance> multipleItems;
            bool addRequiresNewList;

            public TreeProcessingList()
            {
            }

            public int Count
            {
                get
                {
                    if (this.singleItem != null)
                    {
                        return 1;
                    }

                    if (this.multipleItems != null)
                    {
                        return this.multipleItems.Count;
                    }

                    return 0;
                }
            }

            public ActivityInstance this[int index]
            {
                get
                {
                    if (this.singleItem != null)
                    {
                        Fx.Assert(index == 0, "We expect users of TreeProcessingList never to be out of range.");
                        return this.singleItem;
                    }
                    else
                    {
                        Fx.Assert(this.multipleItems != null, "Users shouldn't call this if we have no items.");
                        Fx.Assert(this.multipleItems.Count > index, "Users should never be out of range.");

                        return this.multipleItems[index];
                    }
                }
            }

            public void Set(IList<ActivityInstance> listToSet)
            {
                Fx.Assert(singleItem == null && (this.multipleItems == null || this.multipleItems.Count == 0), "We should not have any items if calling set.");

                this.multipleItems = listToSet;
                this.addRequiresNewList = true;
            }

            public void Add(ActivityInstance item)
            {
                if (this.multipleItems != null)
                {
                    if (this.addRequiresNewList)
                    {
                        this.multipleItems = new List<ActivityInstance>(this.multipleItems);
                        this.addRequiresNewList = false;
                    }

                    this.multipleItems.Add(item);
                }
                else if (this.singleItem != null)
                {
                    this.multipleItems = new List<ActivityInstance>(2);
                    this.multipleItems.Add(this.singleItem);
                    this.multipleItems.Add(item);
                    this.singleItem = null;
                }
                else
                {
                    this.singleItem = item;
                }
            }

            // Because of how we use this we don't need a Clear().
            // Basically we gain nothing by clearing the multipleItems
            // list and hanging onto it.
            public void Reset()
            {
                this.addRequiresNewList = false;
                this.multipleItems = null;
                this.singleItem = null;
            }

            public void TransferTo(TreeProcessingList otherList)
            {
                otherList.singleItem = this.singleItem;
                otherList.multipleItems = this.multipleItems;
                otherList.addRequiresNewList = this.addRequiresNewList;

                Reset();
            }
        }

        // We don't implement anything in this class.  We just use it as
        // a placeholder for when to pop off our parent stack.
        class Pop : Activity
        {
            internal override void InternalExecute(ActivityInstance instance, ActivityExecutor executor, BookmarkManager bookmarkManager)
            {
                throw Fx.AssertAndThrow("should never get here");
            }

            internal override void OnInternalCacheMetadata(bool createEmptyBindings)
            {
                throw Fx.AssertAndThrow("should never get here");
            }
        }

        public struct ChildActivity : IEquatable<ChildActivity>
        {
            public ChildActivity(Activity activity, bool canBeExecuted)
                : this()
            {
                Activity = activity;
                CanBeExecuted = canBeExecuted;
            }

            public static ChildActivity Empty
            {
                get
                {
                    return new ChildActivity();
                }
            }

            public Activity Activity
            {
                get;
                set;
            }

            public bool CanBeExecuted
            {
                get;
                set;
            }

            public bool Equals(ChildActivity other)
            {
                return object.ReferenceEquals(Activity, other.Activity) && CanBeExecuted == other.CanBeExecuted;
            }
        }

        public class ActivityCallStack
        {
            int nonExecutingParentCount;
            Quack<ChildActivity> callStack;

            public ActivityCallStack()
            {
                callStack = new Quack<ChildActivity>();
            }

            public bool WillExecute
            {
                get
                {
                    return nonExecutingParentCount == 0;
                }
            }

            public ChildActivity this[int index]
            {
                get
                {
                    return this.callStack[index];
                }
            }

            public int Count
            {
                get
                {
                    return this.callStack.Count;
                }
            }

            public void Push(ChildActivity childActivity)
            {
                if (!childActivity.CanBeExecuted)
                {
                    this.nonExecutingParentCount++;
                }

                this.callStack.PushFront(childActivity);
            }

            public ChildActivity Pop()
            {
                ChildActivity childActivity = this.callStack.Dequeue();

                if (!childActivity.CanBeExecuted)
                {
                    this.nonExecutingParentCount--;
                }

                return childActivity;
            }
        }

        static class ArgumentTypeDefinitionsCache
        {
            static Hashtable inArgumentTypeDefinitions = new Hashtable();
            static Hashtable outArgumentTypeDefinitions = new Hashtable();
            static Hashtable inOutArgumentTypeDefinitions = new Hashtable();

            public static Type GetArgumentType(Type type, ArgumentDirection direction)
            {
                Hashtable lookupTable = null;

                if (direction == ArgumentDirection.In)
                {
                    lookupTable = inArgumentTypeDefinitions;
                }
                else if (direction == ArgumentDirection.Out)
                {
                    lookupTable = outArgumentTypeDefinitions;
                }
                else
                {
                    lookupTable = inOutArgumentTypeDefinitions;
                }

                Type argumentType = lookupTable[type] as Type;
                if (argumentType == null)
                {
                    argumentType = CreateArgumentType(type, direction);
                    lock (lookupTable)
                    {
                        lookupTable[type] = argumentType;
                    }
                }

                return argumentType;
            }

            static Type CreateArgumentType(Type type, ArgumentDirection direction)
            {
                Type argumentType = null;

                if (direction == ArgumentDirection.In)
                {
                    argumentType = ActivityUtilities.inArgumentGenericType.MakeGenericType(type);
                }
                else if (direction == ArgumentDirection.Out)
                {
                    argumentType = ActivityUtilities.outArgumentGenericType.MakeGenericType(type);
                }
                else
                {
                    argumentType = ActivityUtilities.inOutArgumentGenericType.MakeGenericType(type);
                }

                return argumentType;
            }
        }

        static class LocationAccessExpressionTypeDefinitionsCache
        {
            static object locationReferenceValueTypeDefinitionsLock = new object();
            static Dictionary<Type, ILocationReferenceExpression> locationReferenceValueTypeDefinitions = new Dictionary<Type, ILocationReferenceExpression>();

            static object environmentLocationReferenceTypeDefinitionsLock = new object();
            static Dictionary<Type, ILocationReferenceExpression> environmentLocationReferenceTypeDefinitions = new Dictionary<Type, ILocationReferenceExpression>();

            static object environmentLocationValueTypeDefinitionsLock = new object();
            static Dictionary<Type, ILocationReferenceExpression> environmentLocationValueTypeDefinitions = new Dictionary<Type, ILocationReferenceExpression>();

            public static ActivityWithResult CreateNewLocationAccessExpression(Type type, bool isReference, bool useLocationReferenceValue, LocationReference locationReference)
            {
                Dictionary<Type, ILocationReferenceExpression> lookupTable = null;
                object tableLock = null;

                if (useLocationReferenceValue)
                {
                    lookupTable = locationReferenceValueTypeDefinitions;
                    tableLock = locationReferenceValueTypeDefinitionsLock;
                }
                else
                {
                    lookupTable = isReference ? environmentLocationReferenceTypeDefinitions : environmentLocationValueTypeDefinitions;
                    tableLock = isReference ? environmentLocationReferenceTypeDefinitionsLock : environmentLocationValueTypeDefinitionsLock;
                }

                ILocationReferenceExpression existingInstance;
                lock (tableLock)
                {                    
                    if (!lookupTable.TryGetValue(type, out existingInstance))
                    {
                        Type locationAccessExpressionType = CreateLocationAccessExpressionType(type, isReference, useLocationReferenceValue);                        

                        // Create an "empty" (locationReference = null) instance to put in the cache. This empty instance will only be used to create other instances,
                        // including the instance returned from this method. The cached instance will never be included in an activity tree, so the cached instance's
                        // rootActivity field will not be filled in and thus will not pin all the objects in the activity tree. The cached empty instance has a null
                        // locationReference because locationReference also pins parts of activity tree.
                        existingInstance = (ILocationReferenceExpression)Activator.CreateInstance(
                            locationAccessExpressionType, BindingFlags.Instance | BindingFlags.NonPublic, null, new object[] { null }, null);

                        lookupTable[type] = existingInstance;
                    }                  
                }

                return existingInstance.CreateNewInstance(locationReference);
            }

            static Type CreateLocationAccessExpressionType(Type type, bool isReference, bool useLocationReferenceValue)
            {
                Type openType;
                if (useLocationReferenceValue)
                {
                    openType = locationReferenceValueType;
                }
                else
                {
                    openType = isReference ? environmentLocationReferenceType : environmentLocationValueType;
                }

                return openType.MakeGenericType(type);
            }
        }
    }
}