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

namespace System.Activities.Statements
{
    using System.Activities;
    using System.Activities.DynamicUpdate;
    using System.Activities.Validation;
    using System.Collections.Generic;
    using System.Collections.ObjectModel;
    using System.ComponentModel;
    using System.Linq;
    using System.Runtime;
    using System.Runtime.Collections;
    using System.Windows.Markup;

    [ContentProperty("Nodes")]
    public sealed class Flowchart : NativeActivity
    {
        Collection<Variable> variables;
        Collection<FlowNode> nodes;
        Collection<FlowNode> reachableNodes;

        CompletionCallback onStepCompleted;
        CompletionCallback<bool> onDecisionCompleted;

        Variable<int> currentNode;
        public Flowchart()
        {
            this.currentNode = new Variable<int>();
            this.reachableNodes = new Collection<FlowNode>();
        }

        [DefaultValue(false)]
        public bool ValidateUnconnectedNodes
        {
            get;
            set;
        }

        public Collection<Variable> Variables
        {
            get
            {
                if (this.variables == null)
                {
                    this.variables = new ValidatingCollection<Variable>
                    {
                        // disallow null values
                        OnAddValidationCallback = item =>
                        {
                            if (item == null)
                            {
                                throw FxTrace.Exception.ArgumentNull("item");
                            }
                        }
                    };
                }
                return this.variables;
            }
        }

        [DependsOn("Variables")]
        public FlowNode StartNode
        {
            get;
            set;
        }

        [DependsOn("StartNode")]
        public Collection<FlowNode> Nodes
        {
            get
            {
                if (this.nodes == null)
                {
                    this.nodes = new ValidatingCollection<FlowNode>
                    {
                        // disallow null values
                        OnAddValidationCallback = item =>
                        {
                            if (item == null)
                            {
                                throw FxTrace.Exception.ArgumentNull("item");
                            }
                        }
                    };
                }

                return this.nodes;
            }
        }

        protected override void OnCreateDynamicUpdateMap(NativeActivityUpdateMapMetadata metadata, Activity originalActivity)
        {
            Flowchart originalFlowchart = (Flowchart)originalActivity;
            Dictionary<Activity, int> originalActivities = new Dictionary<Activity, int>();
            foreach (FlowNode node in originalFlowchart.reachableNodes)
            {
                if (node.ChildActivity == null)
                {
                    continue;
                }
                if (metadata.IsReferenceToImportedChild(node.ChildActivity))
                {
                    // We can't save original values for referenced children. Also, we can't reliably combine
                    // implementation changes with changes to referenced children. For now, we just disable 
                    // this scenario altogether; if we want to support it, we'll need deeper runtime support.
                    metadata.DisallowUpdateInsideThisActivity(SR.FlowchartContainsReferences);
                    return;
                }
                if (originalActivities.ContainsKey(node.ChildActivity))
                {
                    metadata.DisallowUpdateInsideThisActivity(SR.MultipleFlowNodesSharingSameChildBlockDU);
                    return;
                }

                originalActivities[node.ChildActivity] = node.Index;
            }

            HashSet<Activity> updatedActivities = new HashSet<Activity>();
            foreach (FlowNode node in this.reachableNodes)
            {
                if (node.ChildActivity != null)
                {
                    if (metadata.IsReferenceToImportedChild(node.ChildActivity))
                    {
                        metadata.DisallowUpdateInsideThisActivity(SR.FlowchartContainsReferences);
                        return;
                    }

                    if (updatedActivities.Contains(node.ChildActivity))
                    {
                        metadata.DisallowUpdateInsideThisActivity(SR.MultipleFlowNodesSharingSameChildBlockDU);
                        return;
                    }
                    else
                    {
                        updatedActivities.Add(node.ChildActivity);
                    }

                    Activity originalChild = metadata.GetMatch(node.ChildActivity);
                    int originalIndex;
                    if (originalChild != null && originalActivities.TryGetValue(originalChild, out originalIndex))
                    {
                        if (originalFlowchart.reachableNodes[originalIndex].GetType() != node.GetType())
                        {
                            metadata.DisallowUpdateInsideThisActivity(SR.CannotMoveChildAcrossDifferentFlowNodeTypes);
                            return;
                        }

                        if (originalIndex != node.Index)
                        {
                            metadata.SaveOriginalValue(node.ChildActivity, originalIndex);
                        }
                    }
                }
            }
        }

        protected override void UpdateInstance(NativeActivityUpdateContext updateContext)
        {
            int oldNodeIndex = updateContext.GetValue(this.currentNode);

            foreach (FlowNode node in this.reachableNodes)
            {
                if (node.ChildActivity != null)
                {
                    object originalValue = updateContext.GetSavedOriginalValue(node.ChildActivity);
                    if (originalValue != null)
                    {
                        int originalIndex = (int)originalValue;
                        if (originalIndex == oldNodeIndex)
                        {
                            updateContext.SetValue(this.currentNode, node.Index);
                            break;
                        }
                    }
                }
            }
        }

        protected override void CacheMetadata(NativeActivityMetadata metadata)
        {
            metadata.SetVariablesCollection(this.Variables);
            metadata.AddImplementationVariable(this.currentNode);

            this.GatherReachableNodes(metadata);
            if (this.ValidateUnconnectedNodes && (this.reachableNodes.Count < this.Nodes.Count))
            {
                metadata.AddValidationError(SR.FlowchartContainsUnconnectedNodes(this.DisplayName));
            }
            HashSet<Activity> uniqueChildren = new HashSet<Activity>();
            IEnumerable<FlowNode> childrenNodes = this.ValidateUnconnectedNodes ? this.Nodes.Distinct() : this.reachableNodes;
            foreach (FlowNode node in childrenNodes)
            {
                if (this.ValidateUnconnectedNodes)
                {
                    node.OnOpen(this, metadata);
                }
                node.GetChildActivities(uniqueChildren);
            }

            List<Activity> children = new List<Activity>(uniqueChildren.Count);
            foreach (Activity child in uniqueChildren)
            {
                children.Add(child);
            }

            metadata.SetChildrenCollection(new Collection<Activity>(children));
        }

        void GatherReachableNodes(NativeActivityMetadata metadata)
        {
            // Clear out our cached list of all nodes
            this.reachableNodes.Clear();

            if (this.StartNode == null && this.Nodes.Count > 0)
            {
                metadata.AddValidationError(SR.FlowchartMissingStartNode(this.DisplayName));
            }
            else
            {
                this.DepthFirstVisitNodes((n) => this.VisitNode(n, metadata), this.StartNode);
            }
        }

        // Returns true if we should visit connected nodes
        bool VisitNode(FlowNode node, NativeActivityMetadata metadata)
        {
            if (node.Open(this, metadata))
            {
                Fx.Assert(node.Index == -1 && !this.reachableNodes.Contains(node), "Corrupt Flowchart.reachableNodes.");

                node.Index = this.reachableNodes.Count;
                this.reachableNodes.Add(node);

                return true;
            }

            return false;
        }

        void DepthFirstVisitNodes(Func<FlowNode, bool> visitNodeCallback, FlowNode start)
        {
            Fx.Assert(visitNodeCallback != null, "This must be supplied since it stops us from infinitely looping.");

            List<FlowNode> connected = new List<FlowNode>();
            Stack<FlowNode> stack = new Stack<FlowNode>();
            if (start == null)
            {
                return;
            }
            stack.Push(start);
            while (stack.Count > 0)
            {
                FlowNode current = stack.Pop();

                if (current == null)
                {
                    continue;
                }

                if (visitNodeCallback(current))
                {
                    connected.Clear();
                    current.GetConnectedNodes(connected);

                    for (int i = 0; i < connected.Count; i++)
                    {
                        stack.Push(connected[i]);
                    }
                }
            }
        }


        protected override void Execute(NativeActivityContext context)
        {
            if (this.StartNode != null)
            {
                if (TD.FlowchartStartIsEnabled())
                {
                    TD.FlowchartStart(this.DisplayName);
                }
                this.ExecuteNodeChain(context, this.StartNode, null);
            }
            else
            {
                if (TD.FlowchartEmptyIsEnabled())
                {
                    TD.FlowchartEmpty(this.DisplayName);
                }
            }
        }

        void ExecuteNodeChain(NativeActivityContext context, FlowNode node, ActivityInstance completedInstance)
        {
            if (node == null)
            {
                if (context.IsCancellationRequested)
                {
                    Fx.Assert(completedInstance != null, "cannot request cancel if we never scheduled any children");
                    // we are done but the last child didn't complete successfully
                    if (completedInstance.State != ActivityInstanceState.Closed)
                    {
                        context.MarkCanceled();
                    }
                }

                return;
            }

            if (context.IsCancellationRequested)
            {
                // we're not done and cancel has been requested
                context.MarkCanceled();
                return;
            }


            Fx.Assert(node != null, "caller should validate");
            FlowNode current = node;
            do
            {
                FlowNode next;
                if (this.ExecuteSingleNode(context, current, out next))
                {
                    current = next;
                }
                else
                {
                    this.currentNode.Set(context, current.Index);
                    current = null;
                }
            }
            while (current != null);
        }

        bool ExecuteSingleNode(NativeActivityContext context, FlowNode node, out FlowNode nextNode)
        {
            Fx.Assert(node != null, "caller should validate");
            FlowStep step = node as FlowStep;
            if (step != null)
            {
                if (this.onStepCompleted == null)
                {
                    this.onStepCompleted = new CompletionCallback(this.OnStepCompleted);
                }

                return step.Execute(context, this.onStepCompleted, out nextNode);
            }

            nextNode = null;
            FlowDecision decision = node as FlowDecision;
            if (decision != null)
            {
                if (this.onDecisionCompleted == null)
                {
                    this.onDecisionCompleted = new CompletionCallback<bool>(this.OnDecisionCompleted);
                }

                return decision.Execute(context, this.onDecisionCompleted);
            }

            IFlowSwitch switchNode = node as IFlowSwitch;
            Fx.Assert(switchNode != null, "unrecognized FlowNode");

            return switchNode.Execute(context, this);
        }

        FlowNode GetCurrentNode(NativeActivityContext context)
        {
            int index = this.currentNode.Get(context);
            FlowNode result = this.reachableNodes[index];
            Fx.Assert(result != null, "corrupt internal state");
            return result;
        }

        void OnStepCompleted(NativeActivityContext context, ActivityInstance completedInstance)
        {
            FlowStep step = this.GetCurrentNode(context) as FlowStep;
            Fx.Assert(step != null, "corrupt internal state");
            FlowNode next = step.Next;
            this.ExecuteNodeChain(context, next, completedInstance);
        }

        void OnDecisionCompleted(NativeActivityContext context, ActivityInstance completedInstance, bool result)
        {
            FlowDecision decision = this.GetCurrentNode(context) as FlowDecision;
            Fx.Assert(decision != null, "corrupt internal state");
            FlowNode next = result ? decision.True : decision.False;
            this.ExecuteNodeChain(context, next, completedInstance);
        }

        internal void OnSwitchCompleted<T>(NativeActivityContext context, ActivityInstance completedInstance, T result)
        {
            IFlowSwitch switchNode = this.GetCurrentNode(context) as IFlowSwitch;
            Fx.Assert(switchNode != null, "corrupt internal state");
            FlowNode next = switchNode.GetNextNode(result);
            this.ExecuteNodeChain(context, next, completedInstance);
        }
    }
}