namespace System.Threading.Tasks
{
	internal abstract class TaskActionInvoker
	{
		private sealed class EmptyTaskActionInvoker : TaskActionInvoker
		{
			public override Delegate Action => null;

			public override void Invoke(Task owner, object state, Task context)
			{
			}
		}

		private sealed class ActionInvoke : TaskActionInvoker
		{
			private readonly Action action;

			public override Delegate Action => action;

			public ActionInvoke(Action action)
			{
				this.action = action;
			}

			public override void Invoke(Task owner, object state, Task context)
			{
				action();
			}
		}

		private sealed class ActionObjectInvoke : TaskActionInvoker
		{
			private readonly Action<object> action;

			public override Delegate Action => action;

			public ActionObjectInvoke(Action<object> action)
			{
				this.action = action;
			}

			public override void Invoke(Task owner, object state, Task context)
			{
				action(state);
			}
		}

		private sealed class ActionTaskInvoke : TaskActionInvoker
		{
			private readonly Action<Task> action;

			public override Delegate Action => action;

			public ActionTaskInvoke(Action<Task> action)
			{
				this.action = action;
			}

			public override void Invoke(Task owner, object state, Task context)
			{
				action(owner);
			}
		}

		private sealed class ActionTasksInvoke : TaskActionInvoker
		{
			private readonly Action<Task[]> action;

			private readonly Task[] tasks;

			public override Delegate Action => action;

			public ActionTasksInvoke(Action<Task[]> action, Task[] tasks)
			{
				this.action = action;
				this.tasks = tasks;
			}

			public override void Invoke(Task owner, object state, Task context)
			{
				action(tasks);
			}
		}

		private sealed class ActionTaskObjectInvoke : TaskActionInvoker
		{
			private readonly Action<Task, object> action;

			public override Delegate Action => action;

			public ActionTaskObjectInvoke(Action<Task, object> action)
			{
				this.action = action;
			}

			public override void Invoke(Task owner, object state, Task context)
			{
				action(owner, state);
			}
		}

		private sealed class ActionTaskObjectInvoke<TResult> : TaskActionInvoker
		{
			private readonly Action<Task<TResult>, object> action;

			public override Delegate Action => action;

			public ActionTaskObjectInvoke(Action<Task<TResult>, object> action)
			{
				this.action = action;
			}

			public override void Invoke(Task owner, object state, Task context)
			{
				action((Task<TResult>)owner, state);
			}
		}

		private sealed class ActionTaskInvoke<TResult> : TaskActionInvoker
		{
			private readonly Action<Task<TResult>> action;

			public override Delegate Action => action;

			public ActionTaskInvoke(Action<Task<TResult>> action)
			{
				this.action = action;
			}

			public override void Invoke(Task owner, object state, Task context)
			{
				action((Task<TResult>)owner);
			}
		}

		private sealed class ActionTaskSelected : TaskActionInvoker
		{
			private readonly Action<Task> action;

			private readonly Task[] tasks;

			public override Delegate Action => action;

			public ActionTaskSelected(Action<Task> action, Task[] tasks)
			{
				this.action = action;
				this.tasks = tasks;
			}

			public override void Invoke(Task owner, object state, Task context)
			{
				int result = ((Task<int>)owner).Result;
				action(tasks[result]);
			}
		}

		private sealed class FuncInvoke<TResult> : TaskActionInvoker
		{
			private readonly Func<TResult> action;

			public override Delegate Action => action;

			public FuncInvoke(Func<TResult> action)
			{
				this.action = action;
			}

			public override void Invoke(Task owner, object state, Task context)
			{
				((Task<TResult>)context).Result = action();
			}
		}

		private sealed class FuncTaskInvoke<TResult> : TaskActionInvoker
		{
			private readonly Func<Task, TResult> action;

			public override Delegate Action => action;

			public FuncTaskInvoke(Func<Task, TResult> action)
			{
				this.action = action;
			}

			public override void Invoke(Task owner, object state, Task context)
			{
				((Task<TResult>)context).Result = action(owner);
			}
		}

		private sealed class FuncTasksInvoke<TResult> : TaskActionInvoker
		{
			private readonly Func<Task[], TResult> action;

			private readonly Task[] tasks;

			public override Delegate Action => action;

			public FuncTasksInvoke(Func<Task[], TResult> action, Task[] tasks)
			{
				this.action = action;
				this.tasks = tasks;
			}

			public override void Invoke(Task owner, object state, Task context)
			{
				((Task<TResult>)context).Result = action(tasks);
			}
		}

		private sealed class FuncTaskSelected<TResult> : TaskActionInvoker
		{
			private readonly Func<Task, TResult> action;

			private readonly Task[] tasks;

			public override Delegate Action => action;

			public FuncTaskSelected(Func<Task, TResult> action, Task[] tasks)
			{
				this.action = action;
				this.tasks = tasks;
			}

			public override void Invoke(Task owner, object state, Task context)
			{
				int result = ((Task<int>)owner).Result;
				((Task<TResult>)context).Result = action(tasks[result]);
			}
		}

		private sealed class FuncTaskInvoke<TResult, TNewResult> : TaskActionInvoker
		{
			private readonly Func<Task<TResult>, TNewResult> action;

			public override Delegate Action => action;

			public FuncTaskInvoke(Func<Task<TResult>, TNewResult> action)
			{
				this.action = action;
			}

			public override void Invoke(Task owner, object state, Task context)
			{
				((Task<TNewResult>)context).Result = action((Task<TResult>)owner);
			}
		}

		private sealed class FuncObjectInvoke<TResult> : TaskActionInvoker
		{
			private readonly Func<object, TResult> action;

			public override Delegate Action => action;

			public FuncObjectInvoke(Func<object, TResult> action)
			{
				this.action = action;
			}

			public override void Invoke(Task owner, object state, Task context)
			{
				((Task<TResult>)context).Result = action(state);
			}
		}

		private sealed class FuncTaskObjectInvoke<TResult> : TaskActionInvoker
		{
			private readonly Func<Task, object, TResult> action;

			public override Delegate Action => action;

			public FuncTaskObjectInvoke(Func<Task, object, TResult> action)
			{
				this.action = action;
			}

			public override void Invoke(Task owner, object state, Task context)
			{
				((Task<TResult>)context).Result = action(owner, state);
			}
		}

		private sealed class FuncTaskObjectInvoke<TResult, TNewResult> : TaskActionInvoker
		{
			private readonly Func<Task<TResult>, object, TNewResult> action;

			public override Delegate Action => action;

			public FuncTaskObjectInvoke(Func<Task<TResult>, object, TNewResult> action)
			{
				this.action = action;
			}

			public override void Invoke(Task owner, object state, Task context)
			{
				((Task<TNewResult>)context).Result = action((Task<TResult>)owner, state);
			}
		}

		public static readonly TaskActionInvoker Empty = new EmptyTaskActionInvoker();

		public abstract Delegate Action { get; }

		public static TaskActionInvoker Create(Action action)
		{
			return new ActionInvoke(action);
		}

		public static TaskActionInvoker Create(Action<object> action)
		{
			return new ActionObjectInvoke(action);
		}

		public static TaskActionInvoker Create(Action<Task> action)
		{
			return new ActionTaskInvoke(action);
		}

		public static TaskActionInvoker Create(Action<Task, object> action)
		{
			return new ActionTaskObjectInvoke(action);
		}

		public static TaskActionInvoker Create<TResult>(Action<Task<TResult>> action)
		{
			return new ActionTaskInvoke<TResult>(action);
		}

		public static TaskActionInvoker Create<TResult>(Action<Task<TResult>, object> action)
		{
			return new ActionTaskObjectInvoke<TResult>(action);
		}

		public static TaskActionInvoker Create<TResult>(Func<TResult> action)
		{
			return new FuncInvoke<TResult>(action);
		}

		public static TaskActionInvoker Create<TResult>(Func<object, TResult> action)
		{
			return new FuncObjectInvoke<TResult>(action);
		}

		public static TaskActionInvoker Create<TResult>(Func<Task, TResult> action)
		{
			return new FuncTaskInvoke<TResult>(action);
		}

		public static TaskActionInvoker Create<TResult>(Func<Task, object, TResult> action)
		{
			return new FuncTaskObjectInvoke<TResult>(action);
		}

		public static TaskActionInvoker Create<TResult, TNewResult>(Func<Task<TResult>, TNewResult> action)
		{
			return new FuncTaskInvoke<TResult, TNewResult>(action);
		}

		public static TaskActionInvoker Create<TResult, TNewResult>(Func<Task<TResult>, object, TNewResult> action)
		{
			return new FuncTaskObjectInvoke<TResult, TNewResult>(action);
		}

		public static TaskActionInvoker Create(Action<Task[]> action, Task[] tasks)
		{
			return new ActionTasksInvoke(action, tasks);
		}

		public static TaskActionInvoker Create<TResult>(Func<Task[], TResult> action, Task[] tasks)
		{
			return new FuncTasksInvoke<TResult>(action, tasks);
		}

		public static TaskActionInvoker Create(Action<Task> action, Task[] tasks)
		{
			return new ActionTaskSelected(action, tasks);
		}

		public static TaskActionInvoker Create<TResult>(Func<Task, TResult> action, Task[] tasks)
		{
			return new FuncTaskSelected<TResult>(action, tasks);
		}

		public abstract void Invoke(Task owner, object state, Task context);
	}
}