namespace System.Workflow.Activities
{
    #region Imports

    using System;
    using System.Diagnostics;
    using System.CodeDom;
    using System.Drawing;
    using System.Collections;
    using System.ComponentModel;
    using System.ComponentModel.Design;
    using System.Workflow.ComponentModel;
    using System.Workflow.ComponentModel.Design;
    using System.Collections.Generic;
    using System.Workflow.ComponentModel.Compiler;
    using System.Workflow.Runtime;
    using System.Workflow.Activities.Common;

    #endregion

    [ToolboxItem(false)]
    [Designer(typeof(EventHandlersDesigner), typeof(IDesigner))]
    [ToolboxBitmap(typeof(EventHandlersActivity), "Resources.events.png")]
    [ActivityValidator(typeof(EventHandlersValidator))]
    [SRCategory(SR.Standard)]
    [AlternateFlowActivityAttribute]
    [Obsolete("The System.Workflow.* types are deprecated.  Instead, please use the new types from System.Activities.*")]
    public sealed class EventHandlersActivity : CompositeActivity, IActivityEventListener<ActivityExecutionStatusChangedEventArgs>
    {
        public EventHandlersActivity()
        {
        }

        public EventHandlersActivity(string name)
            : base(name)
        {
        }

        #region Runtime State Specific Dependency Property
        static DependencyProperty ActivityStateProperty = DependencyProperty.Register("ActivityState", typeof(List<EventHandlerEventActivitySubscriber>), typeof(EventHandlersActivity));
        static DependencyProperty IsScopeCompletedProperty = DependencyProperty.Register("IsScopeCompleted", typeof(bool), typeof(EventHandlersActivity), new PropertyMetadata(false));

        private List<EventHandlerEventActivitySubscriber> ActivityState
        {
            get
            {
                return (List<EventHandlerEventActivitySubscriber>)base.GetValue(ActivityStateProperty);
            }
            set
            {
                if (value == null)
                    base.RemoveProperty(ActivityStateProperty);
                else
                    base.SetValue(ActivityStateProperty, value);
            }
        }

        private bool IsScopeCompleted
        {
            get
            {
                return (bool)base.GetValue(IsScopeCompletedProperty);
            }
            set
            {
                base.SetValue(IsScopeCompletedProperty, value);
            }
        }
        #endregion

        internal void UnsubscribeAndClose()
        {
            base.Invoke<EventArgs>(this.OnUnsubscribeAndClose, EventArgs.Empty);
        }

        #region Protected Methods
        protected override void OnClosed(IServiceProvider provider)
        {
            base.RemoveProperty(EventHandlersActivity.ActivityStateProperty);
            base.RemoveProperty(EventHandlersActivity.IsScopeCompletedProperty);
        }

        protected override void Initialize(IServiceProvider provider)
        {
            if (this.Parent == null)
                throw new InvalidOperationException(SR.GetString(SR.Error_MustHaveParent));

            base.Initialize(provider);
        }

        protected override ActivityExecutionStatus Execute(ActivityExecutionContext executionContext)
        {
            if (executionContext == null)
                throw new ArgumentNullException("executionContext");

            List<EventHandlerEventActivitySubscriber> eventActivitySubscribers = new List<EventHandlerEventActivitySubscriber>();
            this.ActivityState = eventActivitySubscribers;

            for (int i = 0; i < this.EnabledActivities.Count; ++i)
            {
                EventDrivenActivity childActivity = this.EnabledActivities[i] as EventDrivenActivity;
                EventHandlerEventActivitySubscriber eventDrivenSubscriber = new EventHandlerEventActivitySubscriber(childActivity);
                eventActivitySubscribers.Add(eventDrivenSubscriber);
                childActivity.EventActivity.Subscribe(executionContext, eventDrivenSubscriber);
            }
            return ActivityExecutionStatus.Executing;
        }
        protected override ActivityExecutionStatus Cancel(ActivityExecutionContext executionContext)
        {
            if (executionContext == null)
                throw new ArgumentNullException("executionContext");

            if (this.ActivityState == null)
                return ActivityExecutionStatus.Closed;

            bool scopeCompleted = this.IsScopeCompleted;
            bool canCloseNow = true;

            for (int i = 0; i < this.EnabledActivities.Count; ++i)
            {
                EventDrivenActivity childActivity = this.EnabledActivities[i] as EventDrivenActivity;
                EventHandlerEventActivitySubscriber eventActivitySubscriber = this.ActivityState[i] as EventHandlerEventActivitySubscriber;

                eventActivitySubscriber.PendingExecutionCount = 0;

                ActivityExecutionContextManager contextManager = executionContext.ExecutionContextManager;
                ActivityExecutionContext childContext = contextManager.GetExecutionContext(childActivity);

                if (childContext != null)
                {
                    switch (childContext.Activity.ExecutionStatus)
                    {
                        case ActivityExecutionStatus.Canceling:
                        case ActivityExecutionStatus.Faulting:
                            canCloseNow = false;
                            break;
                        case ActivityExecutionStatus.Executing:
                            childContext.CancelActivity(childContext.Activity);
                            canCloseNow = false;
                            break;
                    }
                }

                if (!scopeCompleted) //UnSubscribe from event.
                {
                    childActivity.EventActivity.Unsubscribe(executionContext, eventActivitySubscriber);
                }
            }

            if (canCloseNow)
            {
                this.ActivityState = null;
                return ActivityExecutionStatus.Closed;
            }
            else
            {
                return this.ExecutionStatus;
            }
        }
        protected override void OnActivityChangeAdd(ActivityExecutionContext executionContext, Activity addedActivity)
        {
            if (executionContext == null)
                throw new ArgumentNullException("executionContext");

            if (addedActivity == null)
                throw new ArgumentNullException("addedActivity");

            EventDrivenActivity eda = addedActivity as EventDrivenActivity;

            EventHandlersActivity activity = (EventHandlersActivity)executionContext.Activity as EventHandlersActivity;
            EventHandlerEventActivitySubscriber eventActivitySubscriber = new EventHandlerEventActivitySubscriber(eda);

            if (activity.ExecutionStatus == ActivityExecutionStatus.Executing && activity.ActivityState != null && !activity.IsScopeCompleted)
            {
                eda.EventActivity.Subscribe(executionContext, eventActivitySubscriber);
                activity.ActivityState.Insert(activity.EnabledActivities.IndexOf(addedActivity), eventActivitySubscriber);
            }
        }
        protected override void OnActivityChangeRemove(ActivityExecutionContext executionContext, Activity removedActivity)
        {
            if (executionContext == null)
                throw new ArgumentNullException("executionContext");
            if (removedActivity == null)
                throw new ArgumentNullException("removedActivity");

            EventDrivenActivity eda = removedActivity as EventDrivenActivity;

            // find out the status of the scope
            EventHandlersActivity activity = (EventHandlersActivity)executionContext.Activity as EventHandlersActivity;

            if (activity.ExecutionStatus == ActivityExecutionStatus.Executing && activity.ActivityState != null && !activity.IsScopeCompleted)
            {
                for (int i = 0; i < activity.ActivityState.Count; ++i)
                {
                    EventHandlerEventActivitySubscriber eventSubscriber = activity.ActivityState[i];
                    if (eventSubscriber.eventDrivenActivity.QualifiedName.Equals(removedActivity.QualifiedName))
                    {
                        eda.EventActivity.Unsubscribe(executionContext, eventSubscriber);
                        activity.ActivityState.RemoveAt(i);
                        return;
                    }
                }
            }
        }

        protected override void OnWorkflowChangesCompleted(ActivityExecutionContext executionContext)
        {
            if (executionContext == null)
                throw new ArgumentNullException("executionContext");

            base.OnWorkflowChangesCompleted(executionContext);

            if (this.ActivityState != null)
            {
                switch (this.ExecutionStatus)
                {
                    case ActivityExecutionStatus.Executing:
                        if (this.IsScopeCompleted && AllHandlersAreQuiet(this, executionContext))
                            executionContext.CloseActivity();
                        break;
                    case ActivityExecutionStatus.Faulting:
                    case ActivityExecutionStatus.Canceling:
                        if (AllHandlersAreQuiet(this, executionContext))
                            executionContext.CloseActivity();
                        break;
                    default:
                        break;
                }
            }
        }
        #endregion

        #region Private Impls

        #region IActivityEventListener<ActivityExecutionStatusChangedEventArgs> Members

        void IActivityEventListener<ActivityExecutionStatusChangedEventArgs>.OnEvent(object sender, ActivityExecutionStatusChangedEventArgs e)
        {
            if (sender == null)
                throw new ArgumentNullException("sender");
            if (e == null)
                throw new ArgumentNullException("e");

            ActivityExecutionContext context = sender as ActivityExecutionContext;
            if (context == null)
                throw new ArgumentException(SR.Error_SenderMustBeActivityExecutionContext, "sender");

            EventDrivenActivity eda = e.Activity as EventDrivenActivity;
            EventHandlersActivity eventHandlers = context.Activity as EventHandlersActivity;

            e.Activity.UnregisterForStatusChange(Activity.ClosedEvent, this);

            ActivityExecutionContextManager contextManager = context.ExecutionContextManager;
            contextManager.CompleteExecutionContext(contextManager.GetExecutionContext(eda));

            switch (eventHandlers.ExecutionStatus)
            {
                case ActivityExecutionStatus.Executing:
                    for (int i = 0; i < eventHandlers.EnabledActivities.Count; ++i)
                    {
                        if (eventHandlers.EnabledActivities[i].QualifiedName.Equals(eda.QualifiedName))
                        {
                            EventHandlerEventActivitySubscriber eventActivitySubscriber = eventHandlers.ActivityState[i];

                            if (eventActivitySubscriber.PendingExecutionCount > 0)
                            {
                                eventActivitySubscriber.PendingExecutionCount--;
                                eventActivitySubscriber.IsBlocked = false;

                                ActivityExecutionContext childContext = contextManager.CreateExecutionContext(eventHandlers.EnabledActivities[i]);
                                childContext.Activity.RegisterForStatusChange(Activity.ClosedEvent, this);
                                childContext.ExecuteActivity(childContext.Activity);
                            }
                            else
                            {
                                eventActivitySubscriber.IsBlocked = true;
                                if (eventHandlers.IsScopeCompleted && AllHandlersAreQuiet(eventHandlers, context))
                                    context.CloseActivity();
                            }
                            break;
                        }
                    }
                    break;

                case ActivityExecutionStatus.Canceling:
                case ActivityExecutionStatus.Faulting:
                    if (AllHandlersAreQuiet(eventHandlers, context))
                        context.CloseActivity();
                    break;
            }
        }

        #endregion

        #region Helpers
        private bool AllHandlersAreQuiet(EventHandlersActivity handlers, ActivityExecutionContext context)
        {
            ActivityExecutionContextManager contextManager = context.ExecutionContextManager;

            for (int i = 0; i < handlers.EnabledActivities.Count; ++i)
            {
                EventDrivenActivity eventDriven = handlers.EnabledActivities[i] as EventDrivenActivity;
                if (contextManager.GetExecutionContext(eventDriven) != null || (handlers.ActivityState != null && handlers.ActivityState[i].PendingExecutionCount > 0))
                    return false;
            }
            return true;
        }
        private void OnUnsubscribeAndClose(object sender, EventArgs args)
        {
            if (sender == null)
                throw new ArgumentNullException("sender");
            if (args == null)
                throw new ArgumentNullException("args");

            ActivityExecutionContext context = (ActivityExecutionContext)sender;
            if (context == null)
                throw new ArgumentException("sender");

            EventHandlersActivity handlers = context.Activity as EventHandlersActivity;
            if (context.Activity.ExecutionStatus != ActivityExecutionStatus.Executing)
                return;

            Debug.Assert(!handlers.IsScopeCompleted, "Only notified of scope body completion once");
            handlers.IsScopeCompleted = true;

            ActivityExecutionContextManager contextManager = context.ExecutionContextManager;
            bool readyToClose = true;
            for (int i = 0; i < handlers.EnabledActivities.Count; ++i)
            {
                EventDrivenActivity evtDriven = handlers.EnabledActivities[i] as EventDrivenActivity;
                EventHandlerEventActivitySubscriber eventSubscriber = handlers.ActivityState[i];
                evtDriven.EventActivity.Unsubscribe(context, eventSubscriber);

                if (contextManager.GetExecutionContext(evtDriven) != null || handlers.ActivityState[i].PendingExecutionCount != 0)
                    readyToClose = false;
            }

            if (readyToClose)
            {
                handlers.ActivityState = null;
                context.CloseActivity();
            }
        }
        #endregion

        #region EventSubscriber
        [Serializable]
        private sealed class EventHandlerEventActivitySubscriber : IActivityEventListener<QueueEventArgs>
        {
            bool isBlocked;
            int numOfMsgs;

            internal EventDrivenActivity eventDrivenActivity;

            internal EventHandlerEventActivitySubscriber(EventDrivenActivity eventDriven)
            {
                isBlocked = true;
                numOfMsgs = 0;
                this.eventDrivenActivity = eventDriven;
            }

            internal bool IsBlocked
            {
                get
                {
                    return isBlocked;
                }
                set
                {
                    isBlocked = value;
                }
            }

            internal int PendingExecutionCount
            {
                get
                {
                    return numOfMsgs;
                }
                set
                {
                    numOfMsgs = value;
                }
            }

            void IActivityEventListener<QueueEventArgs>.OnEvent(object sender, QueueEventArgs e)
            {
                if (sender == null)
                    throw new ArgumentNullException("sender");
                if (e == null)
                    throw new ArgumentNullException("e");
                ActivityExecutionContext context = sender as ActivityExecutionContext;

                if (context == null)
                    throw new ArgumentException("sender");

                EventHandlersActivity handlers = context.Activity as EventHandlersActivity;

                if (handlers.ExecutionStatus != ActivityExecutionStatus.Executing)
                    return;

                if (!handlers.EnabledActivities.Contains(eventDrivenActivity))
                    return; //Activity is dynamically removed.

                if (IsBlocked)
                {
                    IsBlocked = false;
                    ActivityExecutionContextManager contextManager = context.ExecutionContextManager;
                    ActivityExecutionContext childContext = contextManager.CreateExecutionContext(eventDrivenActivity);
                    childContext.Activity.RegisterForStatusChange(Activity.ClosedEvent, handlers);
                    childContext.ExecuteActivity(childContext.Activity);
                }
                else
                {
                    PendingExecutionCount++;
                }
            }
        }
        #endregion
        #endregion

        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        private Activity GetDynamicActivity(Activity childActivity)
        {
            if (childActivity == null)
                throw new ArgumentNullException("childActivity");

            if (!this.EnabledActivities.Contains(childActivity))
                throw new ArgumentException(SR.GetString(SR.Error_EventHandlersChildNotFound), "childActivity");
            else
            {
                Activity[] dynamicChildActivity = this.GetDynamicActivities(childActivity);

                if (dynamicChildActivity.Length != 0)
                    return dynamicChildActivity[0];
                else
                    return null;
            }
        }

        public Activity GetDynamicActivity(String childActivityName)
        {
            if (childActivityName == null)
                throw new ArgumentNullException("childActivityName");

            Activity childActivity = null;

            for (int i = 0; i < this.EnabledActivities.Count; ++i)
            {
                if (this.EnabledActivities[i].QualifiedName.Equals(childActivityName))
                {
                    childActivity = this.EnabledActivities[i];
                    break;
                }
            }

            if (childActivity != null)
                return GetDynamicActivity(childActivity);

            throw new ArgumentException(SR.GetString(SR.Error_EventHandlersChildNotFound), "childActivityName");
        }
    }

    internal sealed class EventHandlersValidator : CompositeActivityValidator
    {
        public override ValidationErrorCollection Validate(ValidationManager manager, object obj)
        {
            ValidationErrorCollection validationErrors = base.Validate(manager, obj);

            EventHandlersActivity eventHandlers = obj as EventHandlersActivity;
            if (eventHandlers == null)
                throw new ArgumentException(SR.GetString(SR.Error_UnexpectedArgumentType, typeof(EventHandlersActivity).FullName), "obj");

            if (eventHandlers.Parent == null)
            {
                validationErrors.Add(new ValidationError(SR.GetString(SR.Error_MustHaveParent), ErrorNumbers.Error_EventHandlersDeclParentNotScope));
                return validationErrors;
            }

            // Parent must support event handlers
            if (!(eventHandlers.Parent is EventHandlingScopeActivity))
                validationErrors.Add(new ValidationError(SR.GetString(SR.Error_EventHandlersDeclParentNotScope, eventHandlers.Parent.QualifiedName), ErrorNumbers.Error_EventHandlersDeclParentNotScope));

            bool bNotAllEventHandler = false;
            foreach (Activity activity in eventHandlers.EnabledActivities)
            {
                if (!(activity is EventDrivenActivity))
                    bNotAllEventHandler = true;
            }

            // validate that all child activities are event driven activities.
            if (bNotAllEventHandler)
                validationErrors.Add(new ValidationError(SR.GetString(SR.Error_ListenNotAllEventDriven), ErrorNumbers.Error_ListenNotAllEventDriven));

            return validationErrors;
        }
    }
}