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

namespace System.Activities
{
    using System;
    using System.Activities.DynamicUpdate;
    using System.Activities.Runtime;
    using System.Activities.Tracking;
    using System.Activities.XamlIntegration;
    using System.Collections;
    using System.Collections.Generic;
    using System.Collections.ObjectModel;
    using System.Diagnostics.CodeAnalysis;
    using System.Globalization;
    using System.Runtime;
    using System.Runtime.Serialization;

    [DataContract(Name = XD.ActivityInstance.Name, Namespace = XD.Runtime.Namespace)]
    [Fx.Tag.XamlVisible(false)]
    public sealed class ActivityInstance : ActivityInstanceMap.IActivityReferenceWithEnvironment
    {
        Activity activity;

        ChildList childList;
        ReadOnlyCollection<ActivityInstance> childCache;

        CompletionBookmark completionBookmark;

        ActivityInstanceMap instanceMap;
        ActivityInstance parent;

        string ownerName;
        int busyCount;
        ExtendedData extendedData;

        // most activities will have a symbol (either variable or argument, so optimize for that case)
        bool noSymbols;

        ActivityInstanceState state;
        bool isCancellationRequested;
        bool performingDefaultCancelation;
        Substate substate;

        long id;

        bool initializationIncomplete;

        // This is serialized through the SerializedEnvironment property
        LocationEnvironment environment;

        ExecutionPropertyManager propertyManager;

        internal ActivityInstance(Activity activity)
        {
            this.activity = activity;
            this.state = ActivityInstanceState.Executing;
            this.substate = Substate.Created;

            this.ImplementationVersion = activity.ImplementationVersion;
        }

        public Activity Activity
        {
            get
            {
                return this.activity;
            }

            internal set
            {
                Fx.Assert(value != null || this.state == ActivityInstanceState.Closed, "");
                this.activity = value;
            }
        }

        Activity ActivityInstanceMap.IActivityReference.Activity
        {
            get
            {
                return this.Activity;
            }
        }

        internal Substate SubState
        {
            get
            {
                return this.substate;
            }
        }

        [DataMember(EmitDefaultValue = false)]
        internal LocationEnvironment SerializedEnvironment
        {
            get
            {
                if (this.IsCompleted)
                {
                    return null;
                }
                else
                {
                    return this.environment;
                }
            }
            set
            {
                Fx.Assert(value != null, "We should never get null here.");

                this.environment = value;
            }
        }

        [DataMember(EmitDefaultValue = false, Name = "busyCount")]
        internal int SerializedBusyCount
        {
            get { return this.busyCount; }
            set { this.busyCount = value; }
        }

        [DataMember(EmitDefaultValue = false, Name = "extendedData")]
        internal ExtendedData SerializedExtendedData
        {
            get { return this.extendedData; }
            set { this.extendedData = value; }
        }

        [DataMember(EmitDefaultValue = false, Name = "noSymbols")]
        internal bool SerializedNoSymbols
        {
            get { return this.noSymbols; }
            set { this.noSymbols = value; }
        }

        [DataMember(EmitDefaultValue = false, Name = "state")]
        internal ActivityInstanceState SerializedState
        {
            get { return this.state; }
            set { this.state = value; }
        }

        [DataMember(EmitDefaultValue = false, Name = "isCancellationRequested")]
        internal bool SerializedIsCancellationRequested
        {
            get { return this.isCancellationRequested; }
            set { this.isCancellationRequested = value; }
        }

        [DataMember(EmitDefaultValue = false, Name = "performingDefaultCancelation")]
        internal bool SerializedPerformingDefaultCancelation
        {
            get { return this.performingDefaultCancelation; }
            set { this.performingDefaultCancelation = value; }
        }

        [DataMember(EmitDefaultValue = false, Name = "substate")]
        internal Substate SerializedSubstate
        {
            get { return this.substate; }
            set { this.substate = value; }
        }

        [DataMember(EmitDefaultValue = false, Name = "id")]
        internal long SerializedId
        {
            get { return this.id; }
            set { this.id = value; }
        }

        [DataMember(EmitDefaultValue = false, Name = "initializationIncomplete")]
        internal bool SerializedInitializationIncomplete
        {
            get { return this.initializationIncomplete; }
            set { this.initializationIncomplete = value; }
        }

        internal LocationEnvironment Environment
        {
            get
            {
                Fx.Assert(this.environment != null, "There should always be an environment");
                return this.environment;
            }
        }

        internal ActivityInstanceMap InstanceMap
        {
            get
            {
                return this.instanceMap;
            }
        }

        public bool IsCompleted
        {
            get
            {
                return ActivityUtilities.IsCompletedState(this.State);
            }
        }

        public ActivityInstanceState State
        {
            get
            {
                return this.state;
            }
        }

        internal bool IsCancellationRequested
        {
            get
            {
                return this.isCancellationRequested;
            }
            set
            {
                // This is set at the time of scheduling the cancelation work item

                Fx.Assert(!this.isCancellationRequested, "We should not set this if we have already requested cancel.");
                Fx.Assert(value != false, "We should only set this to true.");

                this.isCancellationRequested = value;
            }
        }

        internal bool IsPerformingDefaultCancelation
        {
            get
            {
                return this.performingDefaultCancelation;
            }
        }

        public string Id
        {
            get
            {
                return this.id.ToString(CultureInfo.InvariantCulture);
            }
        }

        internal long InternalId
        {
            get
            {
                return this.id;
            }
        }

        internal bool IsEnvironmentOwner
        {
            get
            {
                return !this.noSymbols;
            }
        }

        internal bool IsResolvingArguments
        {
            get
            {
                return this.substate == Substate.ResolvingArguments;
            }
        }

        internal bool HasNotExecuted
        {
            get
            {
                return (this.substate & Substate.PreExecuting) != 0;
            }
        }

        internal bool HasPendingWork
        {
            get
            {
                if (this.HasChildren)
                {
                    return true;
                }

                // check if we have pending bookmarks or outstanding OperationControlContexts/WorkItems
                if (this.busyCount > 0)
                {
                    return true;
                }

                return false;
            }
        }

        internal bool OnlyHasOutstandingBookmarks
        {
            get
            {
                // If our whole busy count is because of blocking bookmarks then
                // we should return true
                return !this.HasChildren && this.extendedData != null && (this.extendedData.BlockingBookmarkCount == this.busyCount);
            }
        }

        internal ActivityInstance Parent
        {
            get
            {
                return this.parent;
            }
        }

        internal bool WaitingForTransactionContext
        {
            get
            {
                if (this.extendedData == null)
                {
                    return false;
                }
                else
                {
                    return this.extendedData.WaitingForTransactionContext;
                }
            }
            set
            {
                EnsureExtendedData();

                this.extendedData.WaitingForTransactionContext = value;
            }
        }

        [DataMember(EmitDefaultValue = false)]
        internal CompletionBookmark CompletionBookmark
        {
            get
            {
                return this.completionBookmark;
            }

            set
            {
                this.completionBookmark = value;
            }
        }

        internal FaultBookmark FaultBookmark
        {
            get
            {
                if (this.extendedData == null)
                {
                    return null;
                }

                return this.extendedData.FaultBookmark;
            }

            set
            {
                Fx.Assert(value != null || (this.extendedData == null || this.extendedData.FaultBookmark == null), "cannot go from non-null to null");
                if (value != null)
                {
                    EnsureExtendedData();
                    this.extendedData.FaultBookmark = value;
                }
            }
        }

        internal bool HasChildren
        {
            get
            {
                return (this.childList != null && this.childList.Count > 0);
            }
        }

        internal ExecutionPropertyManager PropertyManager
        {
            get
            {
                return this.propertyManager;
            }
            set
            {
                this.propertyManager = value;
            }
        }

        internal WorkflowDataContext DataContext
        {
            get
            {
                if (this.extendedData != null)
                {
                    return this.extendedData.DataContext;
                }
                return null;
            }
            set
            {
                EnsureExtendedData();
                this.extendedData.DataContext = value;
            }
        }

        internal object CompiledDataContexts
        {
            get;
            set;
        }

        internal object CompiledDataContextsForImplementation
        {
            get;
            set;
        }

        internal bool HasActivityReferences
        {
            get
            {
                return this.extendedData != null && this.extendedData.HasActivityReferences;
            }
        }

        [DataMember(Name = XD.ActivityInstance.PropertyManager, EmitDefaultValue = false)]
        [SuppressMessage(FxCop.Category.Performance, FxCop.Rule.AvoidUncalledPrivateCode, Justification = "Called from Serialization")]
        internal ExecutionPropertyManager SerializedPropertyManager
        {
            get
            {
                if (this.propertyManager == null || !this.propertyManager.ShouldSerialize(this))
                {
                    return null;
                }
                else
                {
                    return this.propertyManager;
                }
            }
            set
            {
                Fx.Assert(value != null, "We don't emit the default value so this should never be null.");
                this.propertyManager = value;
            }
        }

        [DataMember(Name = XD.ActivityInstance.Children, EmitDefaultValue = false)]
        internal ChildList SerializedChildren
        {
            get
            {
                if (this.HasChildren)
                {
                    this.childList.Compress();
                    return this.childList;
                }

                return null;
            }

            set
            {
                Fx.Assert(value != null, "value from Serialization should not be null");
                this.childList = value;
            }
        }

        [DataMember(Name = XD.ActivityInstance.Owner, EmitDefaultValue = false)]
        internal string OwnerName
        {
            get
            {
                if (this.ownerName == null)
                {
                    this.ownerName = this.Activity.GetType().Name;
                }
                return this.ownerName;
            }
            set
            {
                Fx.Assert(value != null, "value from Serialization should not be null");
                this.ownerName = value;
            }
        }

        [DataMember(EmitDefaultValue = false)]
        public Version ImplementationVersion
        {
            get;
            internal set;
        }

        internal static ActivityInstance CreateCompletedInstance(Activity activity)
        {
            ActivityInstance instance = new ActivityInstance(activity);
            instance.state = ActivityInstanceState.Closed;

            return instance;
        }

        internal static ActivityInstance CreateCanceledInstance(Activity activity)
        {
            ActivityInstance instance = new ActivityInstance(activity);
            instance.state = ActivityInstanceState.Canceled;

            return instance;
        }

        internal ReadOnlyCollection<ActivityInstance> GetChildren()
        {
            if (!this.HasChildren)
            {
                return ChildList.Empty;
            }

            if (this.childCache == null)
            {
                this.childCache = this.childList.AsReadOnly();
            }
            return this.childCache;
        }

        internal HybridCollection<ActivityInstance> GetRawChildren()
        {
            return this.childList;
        }

        void EnsureExtendedData()
        {
            if (this.extendedData == null)
            {
                this.extendedData = new ExtendedData();
            }
        }

        // Busy Count includes the following:
        //   1. Active OperationControlContexts.
        //   2. Active work items.
        //   3. Blocking bookmarks.
        internal void IncrementBusyCount()
        {
            this.busyCount++;
        }

        internal void DecrementBusyCount()
        {
            Fx.Assert(this.busyCount > 0, "something went wrong with our bookkeeping");
            this.busyCount--;
        }

        internal void DecrementBusyCount(int amount)
        {
            Fx.Assert(this.busyCount >= amount, "something went wrong with our bookkeeping");
            this.busyCount -= amount;
        }

        internal void AddActivityReference(ActivityInstanceReference reference)
        {
            EnsureExtendedData();
            this.extendedData.AddActivityReference(reference);
        }

        internal void AddBookmark(Bookmark bookmark, BookmarkOptions options)
        {
            bool affectsBusyCount = false;

            if (!BookmarkOptionsHelper.IsNonBlocking(options))
            {
                IncrementBusyCount();
                affectsBusyCount = true;
            }

            EnsureExtendedData();
            this.extendedData.AddBookmark(bookmark, affectsBusyCount);
        }

        internal void RemoveBookmark(Bookmark bookmark, BookmarkOptions options)
        {
            bool affectsBusyCount = false;

            if (!BookmarkOptionsHelper.IsNonBlocking(options))
            {
                DecrementBusyCount();
                affectsBusyCount = true;
            }

            Fx.Assert(this.extendedData != null, "something went wrong with our bookkeeping");
            this.extendedData.RemoveBookmark(bookmark, affectsBusyCount);
        }

        internal void RemoveAllBookmarks(BookmarkScopeManager bookmarkScopeManager, BookmarkManager bookmarkManager)
        {
            if (this.extendedData != null)
            {
                this.extendedData.PurgeBookmarks(bookmarkScopeManager, bookmarkManager, this);
            }
        }

        internal void SetInitializationIncomplete()
        {
            this.initializationIncomplete = true;
        }

        internal void MarkCanceled()
        {
            Fx.Assert(this.substate == Substate.Executing || this.substate == Substate.Canceling, "called from an unexpected state");
            this.substate = Substate.Canceling;
        }

        void MarkExecuted()
        {
            this.substate = Substate.Executing;
        }

        internal void MarkAsComplete(BookmarkScopeManager bookmarkScopeManager, BookmarkManager bookmarkManager)
        {
            if (this.extendedData != null)
            {
                this.extendedData.PurgeBookmarks(bookmarkScopeManager, bookmarkManager, this);

                if (this.extendedData.DataContext != null)
                {
                    this.extendedData.DataContext.Dispose();
                }
            }

            if (this.instanceMap != null)
            {
                this.instanceMap.RemoveEntry(this);

                if (this.HasActivityReferences)
                {
                    this.extendedData.PurgeActivityReferences(this.instanceMap);
                }
            }

            if (this.Parent != null)
            {
                this.Parent.RemoveChild(this);
            }
        }

        internal void Abort(ActivityExecutor executor, BookmarkManager bookmarkManager, Exception terminationReason, bool isTerminate)
        {
            // This is a gentle abort where we try to keep the runtime in a
            // usable state.
            AbortEnumerator abortEnumerator = new AbortEnumerator(this);

            while (abortEnumerator.MoveNext())
            {
                ActivityInstance currentInstance = abortEnumerator.Current;

                if (!currentInstance.HasNotExecuted)
                {
                    currentInstance.Activity.InternalAbort(currentInstance, executor, terminationReason);
                    executor.DebugActivityCompleted(currentInstance);
                }

                if (currentInstance.PropertyManager != null)
                {
                    currentInstance.PropertyManager.UnregisterProperties(currentInstance, currentInstance.Activity.MemberOf, true);
                }

                executor.TerminateSpecialExecutionBlocks(currentInstance, terminationReason);

                executor.CancelPendingOperation(currentInstance);

                executor.HandleRootCompletion(currentInstance);

                currentInstance.MarkAsComplete(executor.RawBookmarkScopeManager, bookmarkManager);

                currentInstance.state = ActivityInstanceState.Faulted;

                currentInstance.FinalizeState(executor, false, !isTerminate);
            }
        }

        internal void BaseCancel(NativeActivityContext context)
        {
            // Default cancelation logic starts here, but is also performed in
            // UpdateState and through special completion work items

            Fx.Assert(this.IsCancellationRequested, "This should be marked to true at this point.");

            this.performingDefaultCancelation = true;

            CancelChildren(context);
        }

        internal void CancelChildren(NativeActivityContext context)
        {
            if (this.HasChildren)
            {
                foreach (ActivityInstance child in this.GetChildren())
                {
                    context.CancelChild(child);
                }
            }
        }

        internal void Cancel(ActivityExecutor executor, BookmarkManager bookmarkManager)
        {
            this.Activity.InternalCancel(this, executor, bookmarkManager);
        }

        internal void Execute(ActivityExecutor executor, BookmarkManager bookmarkManager)
        {
            if (this.initializationIncomplete)
            {
                throw FxTrace.Exception.AsError(new InvalidOperationException(SR.InitializationIncomplete));
            }

            MarkExecuted();
            this.Activity.InternalExecute(this, executor, bookmarkManager);
        }

        internal void AddChild(ActivityInstance item)
        {
            if (this.childList == null)
            {
                this.childList = new ChildList();
            }

            this.childList.Add(item);
            this.childCache = null;
        }

        internal void RemoveChild(ActivityInstance item)
        {
            Fx.Assert(this.childList != null, "");
            this.childList.Remove(item, true);
            this.childCache = null;
        }

        // called by ActivityUtilities tree-walk
        internal void AppendChildren(ActivityUtilities.TreeProcessingList nextInstanceList, ref Queue<IList<ActivityInstance>> instancesRemaining)
        {
            Fx.Assert(this.HasChildren, "AppendChildren is tuned to only be called when HasChildren is true");
            this.childList.AppendChildren(nextInstanceList, ref instancesRemaining);
        }

        // called after deserialization of the workflow instance
        internal void FixupInstance(ActivityInstance parent, ActivityInstanceMap instanceMap, ActivityExecutor executor)
        {
            if (this.IsCompleted)
            {
                // We hang onto the root instance even after is it complete.  We skip the fixups
                // for a completed root.
                Fx.Assert(parent == null, "This should only happen to root instances.");

                return;
            }

            if (this.Activity == null)
            {
                throw FxTrace.Exception.AsError(new InvalidOperationException(SR.ActivityInstanceFixupFailed));
            }

            this.parent = parent;
            this.instanceMap = instanceMap;

            if (this.PropertyManager != null)
            {
                this.PropertyManager.OnDeserialized(this, parent, this.Activity.MemberOf, executor);
            }
            else if (this.parent != null)
            {
                // The current property manager is null here
                this.PropertyManager = this.parent.PropertyManager;
            }
            else
            {
                this.PropertyManager = executor.RootPropertyManager;
            }

            if (!this.noSymbols)
            {
                this.environment.OnDeserialized(executor, this);
            }
        }

        internal bool TryFixupChildren(ActivityInstanceMap instanceMap, ActivityExecutor executor)
        {
            if (!this.HasChildren)
            {
                return false;
            }

            this.childList.FixupList(this, instanceMap, executor);
            return true;
        }

        internal void FillInstanceMap(ActivityInstanceMap instanceMap)
        {
            if (this.IsCompleted)
            {
                // We don't bother adding completed roots to the map
                return;
            }

            Fx.Assert(this.instanceMap == null, "We should never call this unless the current map is null.");
            Fx.Assert(this.Parent == null, "Can only generate a map from a root instance.");

            this.instanceMap = instanceMap;
            ActivityUtilities.ProcessActivityInstanceTree(this, null, new Func<ActivityInstance, ActivityExecutor, bool>(GenerateInstanceMapCallback));
        }

        bool GenerateInstanceMapCallback(ActivityInstance instance, ActivityExecutor executor)
        {
            this.instanceMap.AddEntry(instance);
            instance.instanceMap = this.instanceMap;

            if (instance.HasActivityReferences)
            {
                instance.extendedData.FillInstanceMap(instance.instanceMap);
            }
         
            return true;
        }

        internal bool Initialize(ActivityInstance parent, ActivityInstanceMap instanceMap, LocationEnvironment parentEnvironment, long instanceId, ActivityExecutor executor)
        {
            return this.Initialize(parent, instanceMap, parentEnvironment, instanceId, executor, 0);
        }

        internal bool Initialize(ActivityInstance parent, ActivityInstanceMap instanceMap, LocationEnvironment parentEnvironment, long instanceId, ActivityExecutor executor, int delegateParameterCount)
        {
            this.parent = parent;
            this.instanceMap = instanceMap;
            this.id = instanceId;

            if (this.instanceMap != null)
            {
                this.instanceMap.AddEntry(this);
            }

            // propagate necessary information from our parent
            if (this.parent != null)
            {
                if (this.parent.PropertyManager != null)
                {
                    this.PropertyManager = this.parent.PropertyManager;
                }

                if (parentEnvironment == null)
                {
                    parentEnvironment = this.parent.Environment;
                }
            }

            int symbolCount = this.Activity.SymbolCount + delegateParameterCount;

            if (symbolCount == 0)
            {
                if (parentEnvironment == null)
                {
                    // We create an environment for a root activity that otherwise would not have one
                    // to simplify environment management.
                    this.environment = new LocationEnvironment(executor, this.Activity);
                }
                else
                {
                    this.noSymbols = true;
                    this.environment = parentEnvironment;
                }

                // We don't set Initialized here since the tracking/tracing would be too early
                return false;
            }
            else
            {
                this.environment = new LocationEnvironment(executor, this.Activity, parentEnvironment, symbolCount);
                this.substate = Substate.ResolvingArguments;
                return true;
            }
        }

        internal void ResolveNewArgumentsDuringDynamicUpdate(ActivityExecutor executor, IList<int> dynamicUpdateArgumentIndexes)
        {
            Fx.Assert(!this.noSymbols, "Can only resolve arguments if we created an environment");
            Fx.Assert(this.substate == Substate.Executing, "Dynamically added arguments are to be resolved only in Substate.Executing.");

            if (this.Activity.SkipArgumentResolution)
            {
                return;
            }

            IList<RuntimeArgument> runtimeArguments = this.Activity.RuntimeArguments;

            for (int i = 0; i < dynamicUpdateArgumentIndexes.Count; i++)
            {
                RuntimeArgument argument = runtimeArguments[dynamicUpdateArgumentIndexes[i]];
                Fx.Assert(this.Environment.GetSpecificLocation(argument.Id) == null, "This is a newly added argument so the location should be null");

                this.InternalTryPopulateArgumentValueOrScheduleExpression(argument, -1, executor, null, null, true);
            }
        }

        private bool InternalTryPopulateArgumentValueOrScheduleExpression(RuntimeArgument argument, int nextArgumentIndex, ActivityExecutor executor, IDictionary<string, object> argumentValueOverrides, Location resultLocation, bool isDynamicUpdate)
        {
            object overrideValue = null;
            if (argumentValueOverrides != null)
            {
                argumentValueOverrides.TryGetValue(argument.Name, out overrideValue);
            }

            if (argument.TryPopulateValue(this.environment, this, executor, overrideValue, resultLocation, isDynamicUpdate))
            {
                return true;
            }

            ResolveNextArgumentWorkItem workItem = null;
            Location location = this.environment.GetSpecificLocation(argument.Id);

            if (isDynamicUpdate)
            {
                //1. Check if this argument has a temporary location that needs to be collapsed
                if (location.TemporaryResolutionEnvironment != null)
                {
                    // 2. Add a workitem to collapse the temporary location
                    executor.ScheduleItem(new CollapseTemporaryResolutionLocationWorkItem(location, this));
                }
            }
            else
            {
                //1. Check if there are more arguments to process
                nextArgumentIndex = nextArgumentIndex + 1;

                // 2. Add a workitem to resume argument resolution when
                // work related to 3 below either completes or it hits an async point.           
                int totalArgumentCount = this.Activity.RuntimeArguments.Count;

                if (nextArgumentIndex < totalArgumentCount)
                {
                    workItem = executor.ResolveNextArgumentWorkItemPool.Acquire();
                    workItem.Initialize(this, nextArgumentIndex, argumentValueOverrides, resultLocation);
                }
            }

            // 3. Schedule the argument expression.
            executor.ScheduleExpression(argument.BoundArgument.Expression, this, this.Environment, location, workItem);

            return false;
        }

        // return true if arguments were resolved synchronously
        internal bool ResolveArguments(ActivityExecutor executor, IDictionary<string, object> argumentValueOverrides, Location resultLocation, int startIndex = 0)
        {
            Fx.Assert(!this.noSymbols, "Can only resolve arguments if we created an environment");
            Fx.Assert(this.substate == Substate.ResolvingArguments, "Invalid sub-state machine");

            bool completedSynchronously = true;

            if (this.Activity.IsFastPath)
            {
                // We still need to resolve the result argument
                Fx.Assert(argumentValueOverrides == null, "We shouldn't have any overrides.");
                Fx.Assert(((ActivityWithResult)this.Activity).ResultRuntimeArgument != null, "We should have a result argument");

                RuntimeArgument argument = ((ActivityWithResult)this.Activity).ResultRuntimeArgument;

                if (!argument.TryPopulateValue(this.environment, this, executor, null, resultLocation, false))
                {
                    completedSynchronously = false;

                    Location location = this.environment.GetSpecificLocation(argument.Id);
                    executor.ScheduleExpression(argument.BoundArgument.Expression, this, this.Environment, location, null);
                }
            }
            else if (!this.Activity.SkipArgumentResolution)
            {
                IList<RuntimeArgument> runtimeArguments = this.Activity.RuntimeArguments;

                int argumentCount = runtimeArguments.Count;

                if (argumentCount > 0)
                {
                    for (int i = startIndex; i < argumentCount; i++)
                    {
                        RuntimeArgument argument = runtimeArguments[i];

                        if (!this.InternalTryPopulateArgumentValueOrScheduleExpression(argument, i, executor, argumentValueOverrides, resultLocation, false))
                        {
                            completedSynchronously = false;
                            break;
                        }
                    }
                }
            }

            if (completedSynchronously && startIndex == 0)
            {
                // We only move our state machine forward if this
                // is the first call to ResolveArguments (startIndex
                // == 0).  Otherwise, a call to UpdateState will
                // cause the substate switch (as well as a call to
                // CollapseTemporaryResolutionLocations).
                this.substate = Substate.ResolvingVariables;
            }

            return completedSynchronously;
        }

        internal void ResolveNewVariableDefaultsDuringDynamicUpdate(ActivityExecutor executor, IList<int> dynamicUpdateVariableIndexes, bool forImplementation)
        {
            Fx.Assert(!this.noSymbols, "Can only resolve variable default if we created an environment");
            Fx.Assert(this.substate == Substate.Executing, "Dynamically added variable default expressions are to be resolved only in Substate.Executing.");

            IList<Variable> runtimeVariables;
            if (forImplementation)
            {
                runtimeVariables = this.Activity.ImplementationVariables;
            }
            else
            {
                runtimeVariables = this.Activity.RuntimeVariables;
            }

            for (int i = 0; i < dynamicUpdateVariableIndexes.Count; i++)
            {
                Variable newVariable = runtimeVariables[dynamicUpdateVariableIndexes[i]];
                if (newVariable.Default != null)
                {
                    EnqueueVariableDefault(executor, newVariable, null);
                }
            }
        }

        internal bool ResolveVariables(ActivityExecutor executor)
        {
            Fx.Assert(!this.noSymbols, "can only resolve variables if we created an environment");
            Fx.Assert(this.substate == Substate.ResolvingVariables, "invalid sub-state machine");

            this.substate = Substate.ResolvingVariables;
            bool completedSynchronously = true;

            IList<Variable> implementationVariables = this.Activity.ImplementationVariables;
            IList<Variable> runtimeVariables = this.Activity.RuntimeVariables;

            int implementationVariableCount = implementationVariables.Count;
            int runtimeVariableCount = runtimeVariables.Count;

            if (implementationVariableCount > 0 || runtimeVariableCount > 0)
            {
                for (int i = 0; i < implementationVariableCount; i++)
                {
                    implementationVariables[i].DeclareLocation(executor, this);
                }

                for (int i = 0; i < runtimeVariableCount; i++)
                {
                    runtimeVariables[i].DeclareLocation(executor, this);
                }

                for (int i = 0; i < implementationVariableCount; i++)
                {
                    completedSynchronously &= ResolveVariable(implementationVariables[i], executor);
                }

                for (int i = 0; i < runtimeVariableCount; i++)
                {
                    completedSynchronously &= ResolveVariable(runtimeVariables[i], executor);
                }
            }

            return completedSynchronously;
        }

        // returns true if completed synchronously
        bool ResolveVariable(Variable variable, ActivityExecutor executor)
        {
            bool completedSynchronously = true;
            if (variable.Default != null)
            {
                Location variableLocation = this.Environment.GetSpecificLocation(variable.Id);

                if (variable.Default.UseOldFastPath)
                {
                    variable.PopulateDefault(executor, this, variableLocation);
                }
                else
                {
                    EnqueueVariableDefault(executor, variable, variableLocation);
                    completedSynchronously = false;
                }
            }

            return completedSynchronously;
        }

        void EnqueueVariableDefault(ActivityExecutor executor, Variable variable, Location variableLocation)
        {
            // Incomplete initialization detection logic relies on the fact that we
            // don't specify a completion callback.  If this changes we need to modify
            // callers of SetInitializationIncomplete().
            Fx.Assert(variable.Default != null, "If we've gone async we must have a default");
            if (variableLocation == null)
            {
                variableLocation = this.environment.GetSpecificLocation(variable.Id);
            }
            variable.SetIsWaitingOnDefaultValue(variableLocation);
            executor.ScheduleExpression(variable.Default, this, this.environment, variableLocation, null);
        }

        void ActivityInstanceMap.IActivityReference.Load(Activity activity, ActivityInstanceMap instanceMap)
        {
            if (activity.GetType().Name != this.OwnerName)
            {
                throw FxTrace.Exception.AsError(
                    new ValidationException(SR.ActivityTypeMismatch(activity.DisplayName, this.OwnerName)));
            }

            if (activity.ImplementationVersion != this.ImplementationVersion)
            {
                throw FxTrace.Exception.AsError(new VersionMismatchException(SR.ImplementationVersionMismatch(this.ImplementationVersion, activity.ImplementationVersion, activity)));
            }

            this.Activity = activity;
        }

        // Returns true if the activity completed
        internal bool UpdateState(ActivityExecutor executor)
        {
            bool activityCompleted = false;

            if (this.HasNotExecuted)
            {
                if (this.IsCancellationRequested) // need to cancel any in-flight resolutions and bail
                {
                    if (this.HasChildren)
                    {
                        foreach (ActivityInstance child in this.GetChildren())
                        {
                            Fx.Assert(child.State == ActivityInstanceState.Executing, "should only have children if they're still executing");
                            executor.CancelActivity(child);
                        }
                    }
                    else
                    {
                        SetCanceled();
                        activityCompleted = true;
                    }
                }
                else if (!this.HasPendingWork)
                {
                    bool scheduleBody = false;

                    if (this.substate == Substate.ResolvingArguments)
                    {
                        // if we've had asynchronous resolution of Locations (Out/InOut Arguments), resolve them now
                        this.Environment.CollapseTemporaryResolutionLocations();

                        this.substate = Substate.ResolvingVariables;
                        scheduleBody = ResolveVariables(executor);
                    }
                    else if (this.substate == Substate.ResolvingVariables)
                    {
                        scheduleBody = true;
                    }

                    if (scheduleBody)
                    {
                        executor.ScheduleBody(this, false, null, null);
                    }
                }

                Fx.Assert(this.HasPendingWork || activityCompleted, "should have scheduled work pending if we're not complete");
            }
            else if (!this.HasPendingWork)
            {
                if (!executor.IsCompletingTransaction(this))
                {
                    activityCompleted = true;
                    if (this.substate == Substate.Canceling)
                    {
                        SetCanceled();
                    }
                    else
                    {
                        SetClosed();
                    }
                } 
            }
            else if (this.performingDefaultCancelation)
            {
                if (this.OnlyHasOutstandingBookmarks)
                {
                    RemoveAllBookmarks(executor.RawBookmarkScopeManager, executor.RawBookmarkManager);
                    MarkCanceled();

                    Fx.Assert(!this.HasPendingWork, "Shouldn't have pending work here.");

                    SetCanceled();
                    activityCompleted = true;
                }
            }

            return activityCompleted;
        }

        void TryCancelParent()
        {
            if (this.parent != null && this.parent.IsPerformingDefaultCancelation)
            {
                this.parent.MarkCanceled();
            }
        }

        internal void SetInitializedSubstate(ActivityExecutor executor)
        {
            Fx.Assert(this.substate != Substate.Initialized, "SetInitializedSubstate called when substate is already Initialized.");
            this.substate = Substate.Initialized;
            if (executor.ShouldTrackActivityStateRecordsExecutingState)
            {
                if (executor.ShouldTrackActivity(this.Activity.DisplayName))
                {
                    executor.AddTrackingRecord(new ActivityStateRecord(executor.WorkflowInstanceId, this, this.state));
                }
            }

            if (TD.InArgumentBoundIsEnabled())
            {
                int runtimeArgumentsCount = this.Activity.RuntimeArguments.Count;
                if (runtimeArgumentsCount > 0)
                {
                    for (int i = 0; i < runtimeArgumentsCount; i++)
                    {
                        RuntimeArgument argument = this.Activity.RuntimeArguments[i];

                        if (ArgumentDirectionHelper.IsIn(argument.Direction))
                        {
                            Location location;
                            if (this.environment.TryGetLocation(argument.Id, this.Activity, out location))
                            {
                                string argumentValue = null;

                                if (location.Value == null)
                                {
                                    argumentValue = "<Null>";
                                }
                                else
                                {
                                    argumentValue = "'" + location.Value.ToString() + "'";
                                }

                                TD.InArgumentBound(argument.Name, this.Activity.GetType().ToString(), this.Activity.DisplayName, this.Id, argumentValue);
                            }
                        }
                    }
                }
            }
        }

        internal void FinalizeState(ActivityExecutor executor, bool faultActivity)
        {
            FinalizeState(executor, faultActivity, false);
        }

        internal void FinalizeState(ActivityExecutor executor, bool faultActivity, bool skipTracking)
        {
            if (faultActivity)
            {
                TryCancelParent();

                // We can override previous completion states with this
                this.state = ActivityInstanceState.Faulted;
            }

            Fx.Assert(this.state != ActivityInstanceState.Executing, "We must be in a completed state at this point.");

            if (this.state == ActivityInstanceState.Closed)
            {
                if (executor.ShouldTrackActivityStateRecordsClosedState && !skipTracking)
                {
                    if (executor.ShouldTrackActivity(this.Activity.DisplayName))
                    {
                        executor.AddTrackingRecord(new ActivityStateRecord(executor.WorkflowInstanceId, this, this.state));
                    }
                }
            }
            else
            {
                if (executor.ShouldTrackActivityStateRecords && !skipTracking)
                {
                    executor.AddTrackingRecord(new ActivityStateRecord(executor.WorkflowInstanceId, this, this.state));
                }
            }

            if (TD.ActivityCompletedIsEnabled())
            {
                TD.ActivityCompleted(this.Activity.GetType().ToString(), this.Activity.DisplayName, this.Id, this.State.GetStateName());
            }

        }

        void SetCanceled()
        {
            Fx.Assert(!this.IsCompleted, "Should not be completed if we are changing the state.");

            TryCancelParent();

            this.state = ActivityInstanceState.Canceled;
        }

        void SetClosed()
        {
            Fx.Assert(!this.IsCompleted, "Should not be completed if we are changing the state.");

            this.state = ActivityInstanceState.Closed;
        }

        static void UpdateLocationEnvironmentHierarchy(LocationEnvironment oldParentEnvironment, LocationEnvironment newEnvironment, ActivityInstance currentInstance)
        {
            Func<ActivityInstance, ActivityExecutor, bool> processInstanceCallback = delegate(ActivityInstance instance, ActivityExecutor executor)
            {
                if (instance == currentInstance)
                {
                    return true;
                }

                if (instance.IsEnvironmentOwner)
                {
                    if (instance.environment.Parent == oldParentEnvironment)
                    {
                        // overwrite its parent with newEnvironment
                        instance.environment.Parent = newEnvironment;
                    }

                    // We do not need to process children instances beyond this point.
                    return false;
                }

                if (instance.environment == oldParentEnvironment)
                {
                    // this instance now points to newEnvironment
                    instance.environment = newEnvironment;
                }

                return true;
            };

            ActivityUtilities.ProcessActivityInstanceTree(currentInstance, null, processInstanceCallback);
        }

        void ActivityInstanceMap.IActivityReferenceWithEnvironment.UpdateEnvironment(EnvironmentUpdateMap map, Activity activity)
        {            
            Fx.Assert(this.substate != Substate.ResolvingVariables, "We must have already performed the same validations in advance.");
            Fx.Assert(this.substate != Substate.ResolvingArguments, "We must have already performed the same validations in advance.");

            if (this.noSymbols)
            {
                // create a new LocationReference and this ActivityInstance becomes the owner of the created environment.
                LocationEnvironment oldParentEnvironment = this.environment;

                Fx.Assert(oldParentEnvironment != null, "environment must never be null.");

                this.environment = new LocationEnvironment(oldParentEnvironment, map.NewArgumentCount + map.NewVariableCount + map.NewPrivateVariableCount + map.RuntimeDelegateArgumentCount);
                this.noSymbols = false;

                // traverse the activity instance chain.
                // Update all its non-environment-owning decedent instances to point to the newly created enviroment,
                // and, update all its environment-owning decendent instances to have their environment's parent to point to the newly created environment.
                UpdateLocationEnvironmentHierarchy(oldParentEnvironment, this.environment, this);
            }

            this.Environment.Update(map, activity);
        }

        internal enum Substate : byte
        {
            Executing = 0, // choose the most common persist-time state for the default
            PreExecuting = 0x80, // used for all states prior to "core execution"
            Created = 1 | Substate.PreExecuting,
            ResolvingArguments = 2 | Substate.PreExecuting,
            // ResolvedArguments = 2,
            ResolvingVariables = 3 | Substate.PreExecuting,
            // ResolvedVariables = 3,
            Initialized = 4 | Substate.PreExecuting,
            Canceling = 5,
        }

        // data necessary to support non-mainline usage of instances (i.e. creating bookmarks, using transactions)
        [DataContract]
        internal class ExtendedData
        {
            BookmarkList bookmarks;
            ActivityReferenceList activityReferences;
            int blockingBookmarkCount;

            public ExtendedData()
            {
            }
                        
            public int BlockingBookmarkCount
            {
                get
                {
                    return blockingBookmarkCount;
                }
                private set
                {
                    blockingBookmarkCount = value;
                }
            }

            [DataMember(Name = XD.ActivityInstance.WaitingForTransactionContext, EmitDefaultValue = false)]
            public bool WaitingForTransactionContext
            {
                get;
                set;
            }

            [DataMember(Name = XD.ActivityInstance.FaultBookmark, EmitDefaultValue = false)]
            public FaultBookmark FaultBookmark
            {
                get;
                set;
            }

            public WorkflowDataContext DataContext
            {
                get;
                set;
            }

            [DataMember(Name = XD.ActivityInstance.BlockingBookmarkCount, EmitDefaultValue = false)]
            internal int SerializedBlockingBookmarkCount
            {
                get { return this.BlockingBookmarkCount; }
                set { this.BlockingBookmarkCount = value; }
            }

            [DataMember(Name = XD.ActivityInstance.Bookmarks, EmitDefaultValue = false)]
            [SuppressMessage(FxCop.Category.Performance, FxCop.Rule.AvoidUncalledPrivateCode, Justification = "Called from Serialization")]
            internal BookmarkList Bookmarks
            {
                get
                {
                    if (this.bookmarks == null || this.bookmarks.Count == 0)
                    {
                        return null;
                    }
                    else
                    {
                        return this.bookmarks;
                    }
                }
                set
                {
                    Fx.Assert(value != null, "We don't emit the default value so this should never be null.");
                    this.bookmarks = value;
                }
            }

            [DataMember(Name = XD.ActivityInstance.ActivityReferences, EmitDefaultValue = false)]
            [SuppressMessage(FxCop.Category.Performance, FxCop.Rule.AvoidUncalledPrivateCode, Justification = "Called from Serialization")]
            internal ActivityReferenceList ActivityReferences
            {
                get
                {
                    if (this.activityReferences == null || this.activityReferences.Count == 0)
                    {
                        return null;
                    }
                    else
                    {
                        return this.activityReferences;
                    }
                }
                set
                {
                    Fx.Assert(value != null && value.Count > 0, "We shouldn't emit the default value or empty lists");
                    this.activityReferences = value;
                }
            }

            public bool HasActivityReferences
            {
                get
                {
                    return this.activityReferences != null && this.activityReferences.Count > 0;
                }
            }

            public void AddBookmark(Bookmark bookmark, bool affectsBusyCount)
            {
                if (this.bookmarks == null)
                {
                    this.bookmarks = new BookmarkList();
                }

                if (affectsBusyCount)
                {
                    this.BlockingBookmarkCount = this.BlockingBookmarkCount + 1;
                }

                this.bookmarks.Add(bookmark);
            }

            public void RemoveBookmark(Bookmark bookmark, bool affectsBusyCount)
            {
                Fx.Assert(this.bookmarks != null, "The bookmark list should have been initialized if we are trying to remove one.");

                if (affectsBusyCount)
                {
                    Fx.Assert(this.BlockingBookmarkCount > 0, "We should never decrement below zero.");

                    this.BlockingBookmarkCount = this.BlockingBookmarkCount - 1;
                }

                this.bookmarks.Remove(bookmark);
            }

            public void PurgeBookmarks(BookmarkScopeManager bookmarkScopeManager, BookmarkManager bookmarkManager, ActivityInstance owningInstance)
            {
                if (this.bookmarks != null)
                {
                    if (this.bookmarks.Count > 0)
                    {
                        Bookmark singleBookmark;
                        IList<Bookmark> multipleBookmarks;
                        this.bookmarks.TransferBookmarks(out singleBookmark, out multipleBookmarks);
                        this.bookmarks = null;

                        if (bookmarkScopeManager != null)
                        {
                            bookmarkScopeManager.PurgeBookmarks(bookmarkManager, singleBookmark, multipleBookmarks);
                        }
                        else
                        {
                            bookmarkManager.PurgeBookmarks(singleBookmark, multipleBookmarks);
                        }

                        // Clean up the busy count
                        owningInstance.DecrementBusyCount(this.BlockingBookmarkCount);
                        this.BlockingBookmarkCount = 0;
                    }
                }
            }

            public void AddActivityReference(ActivityInstanceReference reference)
            {
                if (this.activityReferences == null)
                {
                    this.activityReferences = new ActivityReferenceList();
                }

                this.activityReferences.Add(reference);
            }

            public void FillInstanceMap(ActivityInstanceMap instanceMap)
            {
                Fx.Assert(this.HasActivityReferences, "Must have references to have called this.");

                this.activityReferences.FillInstanceMap(instanceMap);
            }

            public void PurgeActivityReferences(ActivityInstanceMap instanceMap)
            {
                Fx.Assert(this.HasActivityReferences, "Must have references to have called this.");

                this.activityReferences.PurgeActivityReferences(instanceMap);
            }

            [DataContract]
            internal class ActivityReferenceList : HybridCollection<ActivityInstanceReference>
            {
                public ActivityReferenceList()
                    : base()
                {
                }

                public void FillInstanceMap(ActivityInstanceMap instanceMap)
                {
                    Fx.Assert(this.Count > 0, "Should only call this when we have items");

                    if (this.SingleItem != null)
                    {
                        instanceMap.AddEntry(this.SingleItem);
                    }
                    else
                    {
                        for (int i = 0; i < this.MultipleItems.Count; i++)
                        {
                            ActivityInstanceReference reference = this.MultipleItems[i];

                            instanceMap.AddEntry(reference);
                        }
                    }
                }

                public void PurgeActivityReferences(ActivityInstanceMap instanceMap)
                {
                    Fx.Assert(this.Count > 0, "Should only call this when we have items");

                    if (this.SingleItem != null)
                    {
                        instanceMap.RemoveEntry(this.SingleItem);
                    }
                    else
                    {
                        for (int i = 0; i < this.MultipleItems.Count; i++)
                        {
                            instanceMap.RemoveEntry(this.MultipleItems[i]);
                        }
                    }
                }
            }
        }

        [DataContract]
        internal class ChildList : HybridCollection<ActivityInstance>
        {
            static ReadOnlyCollection<ActivityInstance> emptyChildren;

            public ChildList()
                : base()
            {
            }

            public static ReadOnlyCollection<ActivityInstance> Empty
            {
                get
                {
                    if (emptyChildren == null)
                    {
                        emptyChildren = new ReadOnlyCollection<ActivityInstance>(new ActivityInstance[0]);
                    }

                    return emptyChildren;
                }
            }

            public void AppendChildren(ActivityUtilities.TreeProcessingList nextInstanceList, ref Queue<IList<ActivityInstance>> instancesRemaining)
            {
                // This is only called if there is at least one item in the list.

                if (base.SingleItem != null)
                {
                    nextInstanceList.Add(base.SingleItem);
                }
                else if (nextInstanceList.Count == 0)
                {
                    nextInstanceList.Set(base.MultipleItems);
                }
                else
                {
                    // Next instance list already has some stuff and we have multiple
                    // items.  Let's enqueue them for later processing.

                    if (instancesRemaining == null)
                    {
                        instancesRemaining = new Queue<IList<ActivityInstance>>();
                    }

                    instancesRemaining.Enqueue(base.MultipleItems);
                }
            }

            public void FixupList(ActivityInstance parent, ActivityInstanceMap instanceMap, ActivityExecutor executor)
            {
                if (base.SingleItem != null)
                {
                    base.SingleItem.FixupInstance(parent, instanceMap, executor);
                }
                else
                {
                    for (int i = 0; i < base.MultipleItems.Count; i++)
                    {
                        base.MultipleItems[i].FixupInstance(parent, instanceMap, executor);
                    }
                }
            }
        }

        // Does a depth first walk and uses some knowledge of
        // the abort process to determine which child to visit next
        class AbortEnumerator : IEnumerator<ActivityInstance>
        {
            ActivityInstance root;
            ActivityInstance current;

            bool initialized;

            public AbortEnumerator(ActivityInstance root)
            {
                this.root = root;
            }

            public ActivityInstance Current
            {
                get
                {
                    return this.current;
                }
            }

            object IEnumerator.Current
            {
                get
                {
                    return this.Current;
                }
            }

            public bool MoveNext()
            {
                if (!this.initialized)
                {
                    this.current = root;

                    // We start by diving down the tree along the
                    // "first child" path
                    while (this.current.HasChildren)
                    {
                        this.current = this.current.GetChildren()[0];
                    }

                    this.initialized = true;

                    return true;
                }
                else
                {
                    if (this.current == this.root)
                    {
                        // We're done if we returned all the way to the root last time
                        return false;
                    }
                    else
                    {
                        Fx.Assert(!this.current.Parent.GetChildren().Contains(this.current), "We should always have removed the current one from the parent's list by now.");

                        this.current = this.current.Parent;

                        // Dive down the tree of remaining first children
                        while (this.current.HasChildren)
                        {
                            this.current = this.current.GetChildren()[0];
                        }

                        return true;
                    }
                }
            }

            public void Reset()
            {
                this.current = null;
                this.initialized = false;
            }

            public void Dispose()
            {
                // no op
            }
        }
    }    
}