using System;
using System.Collections.Generic;
using System.Linq;
using Chernobyl.Collections.Generic;

namespace Chernobyl.Destruction
{
    /// <summary>
    /// A collection of <see cref="IDisposable"/> represented as a single instance.
    /// </summary>
    public interface ICompositeDisposable : IDisposable
    {
        /// <summary>
        /// The instances to be disposed of.
        /// </summary>
        IEnumerable<IDisposable> Disposables { get; }
    }

    /// <summary>
    /// Wraps an object to make it disposable. When <see cref="IDisposable.Dispose()"/> is invoked
    /// on this object, the type is checked to see if it is <see cref="IDisposable"/> before attempting
    /// to dispose of it.
    /// </summary>
    public class TryDisposable<T> : IDisposable
    {
        /// <param name="value">The instance to be disposed.</param>
        public TryDisposable(T value)
        {
            Value = value;
        }

        /// <inheritdoc />
        public void Dispose() => (Value as IDisposable)?.Dispose();

        /// <summary>
        /// The instance to be disposed.
        /// </summary>
        T Value { get; }
    }

    /// <summary>
    /// Invokes a method when <see cref="IDisposable.Dispose()"/> is called.
    /// </summary>
    public class ActionDisposable : IDisposable
    {
        /// <param name="action">The method to invoke when disposed is called.</param>
        public ActionDisposable(Action action)
        {
            _action = action;
        }

        /// <inheritdoc />m
        public void Dispose() => _action();

        readonly Action _action;
    }

    /// <summary>
    /// A collection of <see cref="IDisposable"/> represented as a single instance.
    /// </summary>
    public class CompositeDisposable<TDisposable> : ICompositeDisposable where TDisposable : IDisposable
    {
        /// <param name="disposables">The instances to dispose of.</param>
        public CompositeDisposable(IEnumerable<TDisposable> disposables)
        {
            Disposables = disposables;
        }

        /// <inheritdoc />
        public void Dispose()
        {
            // Convert to array in case the Disposables enumerable is modified during the dispose
            // process which would cause a InvalidOperationException.
            Disposables.ToArray().Dispose();
        }

        /// <summary>
        /// The instances to be disposed of.
        /// </summary>
        public IEnumerable<TDisposable> Disposables { get; }

        IEnumerable<IDisposable> ICompositeDisposable.Disposables =>
            Disposables.Select<TDisposable, IDisposable>(x => x);
    }

    /// <summary>
    /// An <see cref="IDisposable"/> where the instance being disposed of is separate of the object
    /// doing the disposing (the disposal is delegated to another object).
    /// </summary>
    /// <typeparam name="T">The type being disposed of.</typeparam>
    public class DelegatedDisposable<T> : IDisposable
    {
        /// <param name="disposable">The instance to dispose in place of <paramref name="item"/>.</param>
        /// <param name="item">The instance whose disposal is represented by <paramref name="disposable"/>.</param>
        public DelegatedDisposable(IDisposable disposable, T item)
        {
            _disposable = disposable;
            Item = item;
        }

        /// <inheritdoc />
        public void Dispose() => _disposable.Dispose();

        /// <summary>
        /// The item being disposed of.
        /// </summary>
        public T Item { get; }

        readonly IDisposable _disposable;
    }

    /// <summary>
    /// Extension and utility methods for <see cref="IDisposable"/>.
    /// </summary>
    public static class Disposable
    {
        /// <summary>
        /// Returns a disposable that invokes <paramref name="action"/> when disposed.
        /// </summary>
        public static IDisposable From(Action action) => new ActionDisposable(action);

        /// <summary>
        /// Wraps an object to make it disposable. When <see cref="IDisposable.Dispose()"/> is invoked
        /// on this object, the type is checked to see if it is <see cref="IDisposable"/> before attempting
        /// to dispose of it.
        /// </summary>
        public static IDisposable AsDisposable<T>(this T value) => new TryDisposable<T>(value);

        /// <summary>
        /// Invokes <paramref name="action"/> when <see cref="IDisposable.Dispose()"/> is called.
        /// </summary>
        public static IDisposable AsDisposable(this Action action) => From(action);

        /// <summary>
        /// Returns a single instance that disposes of all provided instances.
        /// </summary>
        public static IDisposable Join<T>(this IEnumerable<T> disposables) where T : IDisposable =>
            new CompositeDisposable<T>(disposables);

        /// <summary>
        /// Returns a single instance that disposes of all provided instances.
        /// </summary>
        public static IDisposable Join(this IEnumerable<IDisposable> disposables) =>
            Join<IDisposable>(disposables);

        /// <summary>
        /// Returns a single instance that disposes of all provided instances.
        /// </summary>
        public static IDisposable Join<T>(params T[] disposables) where T : IDisposable =>
            Join(disposables.AsEnumerable());

        /// <summary>
        /// Returns a single instance that disposes of all provided instances.
        /// </summary>
        public static IDisposable Join(params IDisposable[] disposables) =>
            Join(disposables.AsEnumerable());

        /// <summary>
        /// Returns an <see cref="IDisposable"/> that invokes <paramref name="action"/> and then
        /// disposes of <paramref name="disposable"/>.
        /// </summary>
        public static IDisposable BeforeDispose<T>(this IDisposable disposable, Action action) =>
            new[] { new ActionDisposable(action), disposable }.Join();

        /// <summary>
        /// A non-existent disposable object. Useful for avoiding the use of nulls.
        /// </summary>
        public static readonly IDisposable Empty = new EmptyDisposable();
        class EmptyDisposable : IDisposable { public void Dispose() { } }

        /// <summary>
        /// Disposes of all instances in <paramref name="disposables"/>.
        /// </summary>
        public static void Dispose<T>(this IEnumerable<T> disposables) where T : IDisposable =>
            disposables.For(d => d.Dispose());

        /// <summary>
        /// Disposes of <paramref name="disposable"/> if it has been created.
        /// </summary>
        public static void Dispose<T>(this Lazy<T> disposable) where T : IDisposable
        {
            if(disposable.IsValueCreated) disposable.Value.Dispose();
        }

        /// <summary>
        /// Returns all of the instances under and including <paramref name="disposable"/>.
        /// Instances are casted to <see cref="ICompositeDisposable"/> to create the tree being
        /// generated.
        /// </summary>
        public static IEnumerable<IDisposable> Decompose(this IDisposable disposable)
        {
            return disposable is ICompositeDisposable composite
                ? composite.Disposables.SelectMany(Decompose)
                : disposable.ToEnumerable();
        }
    }
}