using System;
using System.Collections.Generic;

namespace Chernobyl
{
    /// <summary>
    /// Utility and extension methods for <see cref="Lazy{T}"/>.
    /// </summary>
    public static class LazyExt
    {
        /// <summary>
        /// Returns a function that returns the value of the <see cref="Lazy{T}"/> when invoked.
        /// </summary>
        public static Func<T> AsFunc<T>(this Lazy<T> lazy) => () => lazy.Value;

        /// <summary>
        /// Wraps the specified object in a <see cref="Lazy{T}"/>.
        /// </summary>
        public static Lazy<T> AsLazy<T>(this T instance) => new Lazy<T>(() => instance);

        /// <summary>
        /// Returns the function in the form of a <see cref="Lazy{T}"/>.
        /// </summary>
        public static Lazy<TResult> AsLazy<TResult>(this Func<TResult> func) => new Lazy<TResult>(func);

        /// <summary>
        /// Returns a <see cref="Lazy{T}"/> that returns a projection of <paramref name="source"/>
        /// using <paramref name="selector"/> as the projector.
        /// </summary>
        public static Lazy<TResult> Select<TSource, TResult>(this Lazy<TSource> source, Func<TSource, TResult> selector) =>
            source.AsFunc().Select(selector).AsLazy();

        /// <summary>
        /// Performs an upcast from <typeparamref name="TSource"/> to <typeparamref name="TReturn"/>.
        /// </summary>
        public static Lazy<TReturn> Upcast<TSource, TReturn>(this Lazy<TSource> func) where TSource : TReturn =>
            func.Select<TSource, TReturn>(v => v);

        /// <summary>
        /// Returns the <see cref="IEnumerable{T}"/> within the <see cref="Lazy{T}"/> without
        /// creating the value within the <see cref="Lazy{T}"/>.
        /// </summary>
        public static IEnumerable<T> Switch<T>(this Lazy<IEnumerable<T>> lazy) =>
            lazy.AsFunc().Switch();

        /// <summary>
        /// Causes the <see cref="Lazy{T}"/> to create its value.
        /// </summary>
        public static void Create<T>(this Lazy<T> lazy) => lazy.AsFunc().Invoke();

        /// <summary>
        /// Returns a <see cref="Lazy{T}"/> that invokes <paramref name="action"/> with the value
        /// returned by <paramref name="lazy"/>.
        /// </summary>
        /// <param name="lazy">The instance to take the value from.</param>
        /// <param name="action">The method to invoke after a value is created from <paramref name="lazy"/>.</param>
        public static Lazy<T> AfterCreate<T>(this Lazy<T> lazy, Action<T> action) =>
            new Lazy<T>(() =>
            {
                var result = lazy.Value;
                action(result);
                return result;
            });

        /// <summary>
        /// Returns a <see cref="Lazy{T}"/> that, when accessed, returns the result of a call to
        /// <paramref name="func"/>.
        /// </summary>
        public static Lazy<T> Invoke<T>(this Lazy<Func<T>> func) => func.Select(f => f());

        /// <summary>
        /// Returns a <see cref="Lazy{T}"/> that, when accessed, returns the result of a call to
        /// <paramref name="func"/>.
        /// </summary>
        public static Lazy<TReturn> Invoke<T1, TReturn>(this Lazy<Func<T1, TReturn>> func, T1 arg1) =>
            func.Select(f => f(arg1));
    }
}