using System;

namespace Chernobyl
{
    /// <summary>
    /// Instance that enables implicit conversion when using func extensions.
    /// </summary>
    public struct Arg<T>
    {
        /// <param name="func"></param>
        public Arg(Func<T> func)
        {
            Func = func;
        }

        /// <summary>
        /// Converts any instance to an <see cref="Arg{T}"/>.
        /// </summary>
        public static implicit operator Arg<T>(T value) => new Arg<T>(() => value);
        /// <summary>
        /// Converts a <see cref="Lazy{T}"/> to an <see cref="Arg{T}"/>.
        /// </summary>
        public static implicit operator Arg<T>(Lazy<T> lazy) => new Arg<T>(() => lazy.Value);
        /// <summary>
        /// Converts a value to an <see cref="Arg{T}"/>.
        /// </summary>
        public static implicit operator Arg<T>(Func<T> func) => new Arg<T>(func);

        /// <summary>
        /// Returns the value of the argument.
        /// </summary>
        public Func<T> Func { get; }
    }

    /// <summary>
    /// Utility and extension methods for <see cref="Arg{T}"/>.
    /// </summary>
    public static class Arg
    {
        /// <summary>
        /// Returns an <see cref="Arg{T}"/> that returns the default value of <typeparamref name="T"/>.
        /// </summary>
        public static Arg<T> Default<T>() => new Arg<T>(() => default);

        // TODO: There appears to a bug where generic conversion sometimes does not work properly so
        // we added the "AsArg" methods to get around this. Remove the "AsArg" methods once C#
        // generic conversion bugs are fixed.

        /// <summary>
        /// Converts any instance to an <see cref="Arg{T}"/>.
        /// </summary>
        /// <remarks>This method exists because C# support of generic implicit conversions doesn't
        /// always work. Use this method if that is the case.</remarks>
        public static Arg<T> AsArg<T>(this T value) => value;
        /// <summary>
        /// Converts <see cref="Lazy{T}"/> to an <see cref="Arg{T}"/>.
        /// </summary>
        /// <remarks>This method exists because C# support of generic implicit conversions doesn't
        /// always work. Use this method if that is the case.</remarks>
        public static Arg<T> AsArg<T>(this Lazy<T> lazy) => lazy;
        /// <summary>
        /// Converts a <see cref="Func{TResult}"/> to an <see cref="Arg{T}"/>.
        /// </summary>
        /// <remarks>This method exists because C# support of generic implicit conversions doesn't
        /// always work. Use this method if that is the case.</remarks>
        public static Arg<T> AsArg<T>(this Func<T> func) => func;
    }
}