using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using Chernobyl.Collections.Generic;
using Chernobyl.Destruction;
using Enumerable = System.Linq.Enumerable;

namespace Chernobyl
{
    /// <summary>
    /// Encapsulates a method that has four parameters and does not return a value.
    /// </summary>
    public delegate void Action<in T1, in T2, in T3, in T4, in T5>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5);

    /// <summary>
    /// Utility and extension methods for the action delegates.
    /// </summary>
    public static class ActionExt
    {
        /// <summary>
        /// Returns <paramref name="action"/>. This method makes writing in a fluent style a little easier.
        /// </summary>
        public static Action This(Action action) => action;

        /// <summary>
        /// Returns <paramref name="action"/>. This method makes writing in a fluent style a little easier.
        /// </summary>
        public static Action<T1> This<T1>(Action<T1> action) => action;

        /// <summary>
        /// Returns <paramref name="action"/>. This method makes writing in a fluent style a little easier.
        /// </summary>
        public static Action<T1, T2> This<T1, T2>(Action<T1, T2> action) => action;

        /// <summary>
        /// Joins together multiple actions into a single action.
        /// </summary>
        public static Action<T1> Join<T1>(IEnumerable<Action<T1>> actions) =>
            arg1 => actions.For(a => a(arg1));

        /// <summary>
        /// Joins together multiple actions into a single action.
        /// </summary>
        public static Action<T1> Join<T1>(params Action<T1>[] actions) => Join(actions.AsEnumerable());

        /// <summary>
        /// Invokes all of the methods in the list.
        /// </summary>
        public static void Invoke(this IEnumerable<Action> actions) => actions.For(a => a());

        /// <summary>
        /// Invokes all of the methods in the list with the provided argument.
        /// </summary>
        public static void Invoke<T1>(this IEnumerable<Action<T1>> actions, T1 arg1) => actions.For(a => a(arg1));

        /// <summary>
        /// Returns a method that projects the argument given to it using <paramref name="selector"/>
        /// before passing the projection onto <paramref name="action"/>.
        /// </summary>
        public static Action<TSource> Select<TSource, TResult>(this Action<TResult> action, Func<TSource, TResult> selector) =>
            arg1 => action(selector(arg1));

        /// <summary>
        /// Returns a method that invokes <paramref name="action"/> with its first argument replaced
        /// by the result of <paramref name="selector"/>.
        /// </summary>
        public static Action<T1, T2> SelectArg1<T1, T2, T1Selected>(this Action<T1Selected, T2> action, Func<T1, T1Selected> selector) =>
            (arg1, arg2) => action(selector(arg1), arg2);

        /// <summary>
        /// Returns a method that invokes <paramref name="action"/> with its second argument replaced
        /// by the result of <paramref name="selector"/>.
        /// </summary>
        public static Action<T1, T2> SelectArg2<T1, T2, T2Selected>(this Action<T1, T2Selected> action, Func<T2, T2Selected> selector) =>
            (arg1, arg2) => action(arg1, selector(arg2));

        /// <summary>
        /// Returns a method that, when invoked, invokes <paramref name="action"/> but only if
        /// <paramref name="predicate"/> returns true.
        /// </summary>
        public static Action<T> Where<T>(this Action<T> action, Func<T, bool> predicate) =>
            v =>
            {
                if (predicate(v)) action(v);
            };

        /// <summary>
        /// Returns a method that, when invoked, invokes <paramref name="action"/> but only if
        /// <paramref name="predicate"/> returns true.
        /// </summary>
        public static Action<T1, T2> Where<T1, T2>(this Action<T1, T2> action, Func<T1, T2, bool> predicate)
        {
            return (arg1, arg2) =>
            {
                if (predicate(arg1, arg2)) action(arg1, arg2);
            };
        }

        /// <summary>
        /// Returns a method that, when invoked, invokes <paramref name="action"/> but only if
        /// <paramref name="predicate"/> returns true.
        /// </summary>
        public static Action<T1, T2> WhereArg2<T1, T2>(this Action<T1, T2> action, Func<T2, bool> predicate)
        {
            return (arg1, arg2) =>
            {
                if (predicate(arg2)) action(arg1, arg2);
            };
        }

        /// <summary>
        /// Returns a method that, when invoked, invokes <paramref name="action"/> but only if
        /// <paramref name="predicate"/> returns true.
        /// </summary>
        public static Action<T1, T2, T3> Where<T1, T2, T3>(this Action<T1, T2, T3> action, Func<T1, T2, T3, bool> predicate)
        {
            return (arg1, arg2, arg3) =>
            {
                if (predicate(arg1, arg2, arg3)) action(arg1, arg2, arg3);
            };
        }

        /// <summary>
        /// Returns a method that uses the provided value as the second argument to the provided method.
        /// </summary>
        public static Action<T2> BindArg1<T1, T2>(this Action<T1, T2> action, Arg<T1> arg1) =>
            arg2 => action(arg1.Func(), arg2);

        /// <summary>
        /// Returns a method that uses the provided value as the second argument to the provided method.
        /// </summary>
        public static Action<T1> BindArg2<T1, T2>(this Action<T1, T2> action, Arg<T2> arg2) =>
            arg1 => action(arg1, arg2.Func());

        /// <summary>
        /// Returns a method two parameter that invokes <paramref name="action"/> with the second
        /// argument but not the first.
        /// </summary>
        public static Action<T1, T2> PrependArg<T1, T2>(this Action<T2> action) => (arg1, arg2) => action(arg2);

        /// <summary>
        /// Returns a no-operation <see cref="Action{T}"/>.
        /// </summary>
        public static Action<T1> None<T1>() => arg1 => {};

        /// <summary>
        /// Returns a no-operation <see cref="Action{T1, T2}"/>.
        /// </summary>
        public static Action<T1, T2> None<T1, T2>() => (arg1, arg2) => {};
    }

    /// <summary>
    /// An instance that can be converted to an <see cref="Action"/> that, when invoked,
    /// invokes a set of <see cref="Action"/> and allows removal from that list when
    /// dictated by an <see cref="IDisposable"/>. This type is thread safe.
    /// </summary>
    public class CompositeAction : CompositeAction<int>
    {
        /// <summary>
        /// Adds an <see cref="Action"/> to be updated which can be removed by calling
        /// <see cref="IDisposable.Dispose()"/> on the returned instance. This method and the returned
        /// <see cref="IDisposable"/> is thread safe.
        /// </summary>
        public IDisposable Register(Action action) => Register(arg1 => action());

        /// <summary>
        /// Converts this instance to an <see cref="Action"/> so that can be invoked like one.
        /// </summary>
        public static implicit operator Action(CompositeAction a) => a.Invoke;

        /// <summary>
        /// Invokes all of the instances. This call is thread safe.
        /// </summary>
        public void Invoke() => Invoke(0);
    }

    /// <summary>
    /// An instance that can be converted to an <see cref="Action{T1}"/> that, when invoked,
    /// invokes a set of <see cref="Action{T1}"/> and allows removal from that list when
    /// dictated by an <see cref="IDisposable"/>. This type is thread safe.
    /// </summary>
    public class CompositeAction<T1>
    {
        /// <summary>
        /// Adds an <see cref="Action{T1}"/> to be updated which can be removed by calling
        /// <see cref="IDisposable.Dispose()"/> on the returned instance. This method and the returned
        /// <see cref="IDisposable"/> is thread safe.
        /// </summary>
        public IDisposable Register(Action<T1> action)
        {
            _actions.TryAdd(action, action);
            return ActionExt.This(() => _actions.TryRemove(action, out _)).AsDisposable();
        }

        /// <summary>
        /// Converts this instance to an <see cref="Action{T}"/> so that can be invoked like one.
        /// </summary>
        public static implicit operator Action<T1>(CompositeAction<T1> action) => action.Action;

        /// <summary>
        /// Invokes all of the instances. This call is thread safe.
        /// </summary>
        public void Invoke(T1 arg1) => _actions.For(a => a.Value(arg1));

        /// <summary>
        /// Performs the same function as <see cref="Invoke(T1)"/>. This property makes fluent
        /// programming easier.
        /// </summary>
        public Action<T1> Action => Invoke;

        // Using ConcurrentDictionary because it is the only concurrent collection that allows for
        // removal by value (i.e. TryRemove).
        readonly ConcurrentDictionary<Action<T1>, Action<T1>> _actions =
            new ConcurrentDictionary<Action<T1>, Action<T1>>();
    }

    /// <summary>
    /// An <see cref="Action{T1}"/> functor that holds onto the last value it was given. This type
    /// can be implicitly converted to an <see cref="Action{T1}"/>.
    /// </summary>
    /// <remarks>This type is NOT thread safe.</remarks>
    public class LastValue<T>
    {
        /// <summary>
        /// The last value given to the this <see cref="Action{T1}"/>.
        /// </summary>
        public T Value { get; private set; }

        /// <summary>
        /// Converts this functor to an <see cref="Action{T}"/>.
        /// </summary>
        public static implicit operator Action<T>(LastValue<T> lv) => lv.Accept;

        /// <summary>
        /// The <see cref="Action{T1}"/> that accepts the value.
        /// </summary>
        public void Accept(T value) => Value = value;
    }

    /// <summary>
    /// An <see cref="Action"/> functor that toggles between two states. This type
    /// can be implicitly converted to an <see cref="Action"/>.
    /// </summary>
    /// <remarks>This type is NOT thread safe.</remarks>
    public class Toggle
    {
        /// <summary>
        /// Constructs the toggle with an initial state of false.
        /// </summary>
        public Toggle() : this(false, null) { }

        /// <param name="state">The initial state of this instance.</param>
        /// <param name="onStateChange">Method to invoke when value is toggled.</param>
        public Toggle(bool state, Action<bool> onStateChange = null)
        {
            State = state;
            _onStateChange = onStateChange ?? ActionExt.None<bool>();
        }

        /// <summary>
        /// The current state of this instance.
        /// </summary>
        public bool State { get; private set; }

        /// <summary>
        /// Converts this functor to an <see cref="Action"/>.
        /// </summary>
        public static implicit operator Action(Toggle t) => t.Invoke;

        /// <summary>
        /// The <see cref="Action"/> that accepts the value.
        /// </summary>
        public void Invoke()
        {
            State = !State;
            _onStateChange(State);
        }

        readonly Action<bool> _onStateChange;
    }

    /// <summary>
    /// An <see cref="Action{T1}"/> functor that can be disposed of.
    /// </summary>
    public class DisposableAction<T1> : IDisposable
    {
        /// <param name="action">The action to be invoked.</param>
        /// <param name="onDispose">The result of disposing the action.</param>
        public DisposableAction(Action<T1> action, Action onDispose)
        {
            Action = action;
            _onDispose = onDispose;
        }

        /// <summary>
        /// Projects this functor into another form.
        /// </summary>
        /// <param name="selector">The method that projects the action.</param>
        /// <returns>The new form of the functor.</returns>
        public DisposableAction<T2> Select<T2>(Func<Action<T1>, Action<T2>> selector) =>
            new DisposableAction<T2>(selector(Action), _onDispose);

        /// <summary>
        /// Converts this instance into its <see cref="Action{T1}"/>.
        /// </summary>
        public static implicit operator Action<T1>(DisposableAction<T1> da) => da.Action;

        /// <summary>
        /// The <see cref="Action{T1}"/> of this functor.
        /// </summary>
        public Action<T1> Action { get; }

        /// <inheritdoc />
        public void Dispose() => _onDispose();

        readonly Action _onDispose;
    }
}