// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.

using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;

namespace System.Linq
{
    public static partial class AsyncEnumerable
    {
        /// <summary>Returns the maximum value in a generic sequence.</summary>
        /// <typeparam name="TSource">The type of the elements of <paramref name="source" />.</typeparam>
        /// <param name="source">A sequence of values to determine the maximum value of.</param>
        /// <param name="comparer">The <see cref="IComparer{T}" /> to compare values.</param>
        /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
        /// <returns>The maximum value in the sequence.</returns>
        /// <exception cref="ArgumentNullException"><paramref name="source" /> is <see langword="null" />.</exception>
        /// <exception cref="ArgumentException">No object in <paramref name="source" /> implements the <see cref="IComparable" /> or <see cref="IComparable{T}" /> interface (via the returned task).</exception>
        /// <remarks>
        /// <para>If type <typeparamref name="TSource" /> implements <see cref="IComparable{T}" />, the <see cref="MaxAsync{TSource}(IAsyncEnumerable{TSource}, IComparer{TSource}?, CancellationToken)" /> method uses that implementation to compare values. Otherwise, if type <typeparamref name="TSource" /> implements <see cref="IComparable" />, that implementation is used to compare values.</para>
        /// <para>If <typeparamref name="TSource" /> is a reference type and the source sequence is empty or contains only values that are <see langword="null" />, this method returns <see langword="null" />.</para>
        /// </remarks>
        public static ValueTask<TSource?> MaxAsync<TSource>(
            this IAsyncEnumerable<TSource> source,
            IComparer<TSource>? comparer = null,
            CancellationToken cancellationToken = default)
        {
            ArgumentNullException.ThrowIfNull(source);

            comparer ??= Comparer<TSource>.Default;

            // Special-case float/double/float?/double? to maintain compatibility
            // with System.Linq.Enumerable implementations.
#pragma warning disable CA2012 // Use ValueTasks correctly
            if (typeof(TSource) == typeof(float) && comparer == Comparer<TSource>.Default)
            {
                return (ValueTask<TSource?>)(object)MaxAsync((IAsyncEnumerable<float>)(object)source, cancellationToken);
            }

            if (typeof(TSource) == typeof(double) && comparer == Comparer<TSource>.Default)
            {
                return (ValueTask<TSource?>)(object)MaxAsync((IAsyncEnumerable<double>)(object)source, cancellationToken);
            }

            if (typeof(TSource) == typeof(float?) && comparer == Comparer<TSource>.Default)
            {
                return (ValueTask<TSource?>)(object)MaxAsync((IAsyncEnumerable<float?>)(object)source, cancellationToken);
            }

            if (typeof(TSource) == typeof(double?) && comparer == Comparer<TSource>.Default)
            {
                return (ValueTask<TSource?>)(object)MaxAsync((IAsyncEnumerable<double?>)(object)source, cancellationToken);
            }
#pragma warning restore CA2012

            return Impl(source, comparer, cancellationToken);

            static async ValueTask<TSource?> Impl(
                IAsyncEnumerable<TSource> source,
                IComparer<TSource> comparer,
                CancellationToken cancellationToken)
            {
                await using IAsyncEnumerator<TSource> e = source.GetAsyncEnumerator(cancellationToken);

                TSource? value = default;
                if (default(TSource) is null)
                {
                    do
                    {
                        if (!await e.MoveNextAsync())
                        {
                            return value;
                        }

                        value = e.Current;
                    }
                    while (value is null);

                    while (await e.MoveNextAsync())
                    {
                        TSource next = e.Current;
                        if (next is not null && comparer.Compare(next, value) > 0)
                        {
                            value = next;
                        }
                    }
                }
                else
                {
                    if (!await e.MoveNextAsync())
                    {
                        ThrowHelper.ThrowNoElementsException();
                    }

                    value = e.Current;
                    if (comparer == Comparer<TSource>.Default)
                    {
                        while (await e.MoveNextAsync())
                        {
                            TSource next = e.Current;
                            if (Comparer<TSource>.Default.Compare(next, value) > 0)
                            {
                                value = next;
                            }
                        }
                    }
                    else
                    {
                        while (await e.MoveNextAsync())
                        {
                            TSource next = e.Current;
                            if (comparer.Compare(next, value) > 0)
                            {
                                value = next;
                            }
                        }
                    }
                }

                return value;
            }
        }

        /// <summary>Returns the maximum value in a sequence of values.</summary>
        /// <param name="source">A sequence of values to determine the maximum value of.</param>
        /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
        /// <returns>The maximum value in the sequence.</returns>
        private static async ValueTask<float> MaxAsync(
            this IAsyncEnumerable<float> source,
            CancellationToken cancellationToken)
        {
            await using IAsyncEnumerator<float> e = source.GetAsyncEnumerator(cancellationToken);

            if (!await e.MoveNextAsync())
            {
                ThrowHelper.ThrowNoElementsException();
            }

            // NaN is ordered less than all other values. We need to do explicit checks to ensure this,
            // but once we've found a value that is not NaN we need no longer worry about it,
            // so first loop until such a value is found (or not, as the case may be).
            float value = e.Current;
            while (float.IsNaN(value))
            {
                if (!await e.MoveNextAsync())
                {
                    return value;
                }

                value = e.Current;
            }

            while (await e.MoveNextAsync())
            {
                float x = e.Current;
                if (x > value)
                {
                    value = x;
                }
            }

            return value;
        }

        /// <summary>Returns the maximum value in a sequence of values.</summary>
        /// <param name="source">A sequence of values to determine the maximum value of.</param>
        /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
        /// <returns>The maximum value in the sequence.</returns>
        private static async ValueTask<double> MaxAsync(
            this IAsyncEnumerable<double> source,
            CancellationToken cancellationToken)
        {
            await using IAsyncEnumerator<double> e = source.GetAsyncEnumerator(cancellationToken);

            if (!await e.MoveNextAsync())
            {
                ThrowHelper.ThrowNoElementsException();
            }

            // NaN is ordered less than all other values. We need to do explicit checks to ensure this,
            // but once we've found a value that is not NaN we need no longer worry about it,
            // so first loop until such a value is found (or not, as the case may be).
            double value = e.Current;
            while (double.IsNaN(value))
            {
                if (!await e.MoveNextAsync())
                {
                    return value;
                }

                value = e.Current;
            }

            while (await e.MoveNextAsync())
            {
                double x = e.Current;
                if (x > value)
                {
                    value = x;
                }
            }

            return value;
        }

        /// <summary>Returns the maximum value in a sequence of nullable values.</summary>
        /// <param name="source">A sequence of nullable values to determine the maximum value of.</param>
        /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
        /// <returns>The maximum value in the sequence.</returns>
        private static async ValueTask<float?> MaxAsync(IAsyncEnumerable<float?> source, CancellationToken cancellationToken)
        {
            float? value = null;
            await foreach (float? x in source.WithCancellation(cancellationToken))
            {
                if (x is null)
                {
                    continue;
                }

                if (value is null || x > value || float.IsNaN((float)value))
                {
                    value = x;
                }
            }

            return value;
        }

        /// <summary>Returns the maximum value in a sequence of nullable values.</summary>
        /// <param name="source">A sequence of nullable values to determine the maximum value of.</param>
        /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
        /// <returns>The maximum value in the sequence.</returns>
        private static async ValueTask<double?> MaxAsync(IAsyncEnumerable<double?> source, CancellationToken cancellationToken)
        {
            double? value = null;
            await foreach (double? x in source.WithCancellation(cancellationToken))
            {
                if (x is null)
                {
                    continue;
                }

                if (value is null || x > value || double.IsNaN((double)value))
                {
                    value = x;
                }
            }

            return value;
        }
    }
}