namespace Neovolve.Toolkit.Workflow.Activities
{
    using System;
    using System.Activities;
    using System.Activities.Presentation;
    using System.Activities.Statements;
    using System.Activities.Validation;
    using System.Collections.ObjectModel;
    using System.ComponentModel;
    using System.Diagnostics;
    using System.Drawing;
    using System.Windows;
    using System.Windows.Markup;
    using Neovolve.Toolkit.Workflow.Properties;
    
    [ToolboxBitmap(typeof(Retry), "arrow_retry.png")]
    [ContentProperty("Body")]
    public sealed class Retry : NativeActivity, IActivityTemplateFactory
    {
        private static readonly TimeSpan _defaultRetryInterval = new TimeSpan(0, 0, 0, 1);
    
        private readonly Variable<Int32> _attemptCount = new Variable<Int32>();
    
        private readonly Variable<TimeSpan> _delayDuration = new Variable<TimeSpan>();
    
        private readonly Delay _internalDelay;
    
        public Retry()
        {
            _internalDelay = new Delay
                                {
                                    Duration = new InArgument<TimeSpan>(_delayDuration)
                                };
            Body = new ActivityAction();
            MaxAttempts = 5;
            ExceptionType = typeof(TimeoutException);
            RetryInterval = _defaultRetryInterval;
        }
    
        [DebuggerNonUserCode]
        public Activity Create(DependencyObject target)
        {
            return new Retry
                    {
                        Body =
                            {
                                Handler = new Sequence()
                            }
                    };
        }
    
        protected override void CacheMetadata(NativeActivityMetadata metadata)
        {
            metadata.AddDelegate(Body);
            metadata.AddImplementationChild(_internalDelay);
            metadata.AddImplementationVariable(_attemptCount);
            metadata.AddImplementationVariable(_delayDuration);
    
            RuntimeArgument maxAttemptsArgument = new RuntimeArgument("MaxAttempts", typeof(Int32), ArgumentDirection.In, true);
            RuntimeArgument retryIntervalArgument = new RuntimeArgument("RetryInterval", typeof(TimeSpan), ArgumentDirection.In, true);
    
            metadata.Bind(MaxAttempts, maxAttemptsArgument);
            metadata.Bind(RetryInterval, retryIntervalArgument);
    
            Collection<RuntimeArgument> arguments = new Collection<RuntimeArgument>
                                                    {
                                                        maxAttemptsArgument, 
                                                        retryIntervalArgument
                                                    };
    
            metadata.SetArgumentsCollection(arguments);
    
            if (Body == null)
            {
                ValidationError validationError = new ValidationError(Resources.Retry_NoChildActivitiesDefined, true, "Body");
    
                metadata.AddValidationError(validationError);
            }
    
            if (typeof(Exception).IsAssignableFrom(ExceptionType) == false)
            {
                ValidationError validationError = new ValidationError(Resources.Retry_InvalidExceptionType, false, "ExceptionType");
    
                metadata.AddValidationError(validationError);
            }
        }
    
        protected override void Execute(NativeActivityContext context)
        {
            ExecuteAttempt(context);
        }
    
        private static Boolean ShouldRetryAction(Type exceptionType, Exception thrownException)
        {
            if (exceptionType == null)
            {
                return false;
            }
    
            return exceptionType.IsAssignableFrom(thrownException.GetType());
        }
    
        private void ActionFailed(NativeActivityFaultContext faultcontext, Exception propagatedexception, ActivityInstance propagatedfrom)
        {
            Int32 currentAttemptCount = _attemptCount.Get(faultcontext);
    
            currentAttemptCount++;
    
            _attemptCount.Set(faultcontext, currentAttemptCount);
    
            Int32 maxAttempts = MaxAttempts.Get(faultcontext);
    
            if (currentAttemptCount >= maxAttempts)
            {
                // There are no further attempts to make
                return;
            }
    
            if (ShouldRetryAction(ExceptionType, propagatedexception) == false)
            {
                return;
            }
    
            faultcontext.CancelChild(propagatedfrom);
            faultcontext.HandleFault();
    
            TimeSpan retryInterval = RetryInterval.Get(faultcontext);
    
            if (retryInterval == TimeSpan.Zero)
            {
                ExecuteAttempt(faultcontext);
            }
            else
            {
                // We are going to wait before trying again
                _delayDuration.Set(faultcontext, retryInterval);
    
                faultcontext.ScheduleActivity(_internalDelay, DelayCompleted);
            }
        }
    
        private void DelayCompleted(NativeActivityContext context, ActivityInstance completedinstance)
        {
            ExecuteAttempt(context);
        }
    
        private void ExecuteAttempt(NativeActivityContext context)
        {
            if (Body == null)
            {
                return;
            }
    
            context.ScheduleAction(Body, null, ActionFailed);
        }
    
        [Browsable(false)]
        public ActivityAction Body
        {
            get;
            set;
        }
    
        [DefaultValue(typeof(TimeoutException))]
        public Type ExceptionType
        {
            get;
            set;
        }
    
        public InArgument<Int32> MaxAttempts
        {
            get;
            set;
        }
    
        public InArgument<TimeSpan> RetryInterval
        {
            get;
            set;
        }
    }
}