// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
 
using System;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Runtime.CompilerServices;
using Microsoft.CodeAnalysis.PooledObjects;
using Microsoft.CodeAnalysis.Utilities;
using Roslyn.Utilities;
 
namespace Microsoft.CodeAnalysis;
 
/// <summary>
/// Helpers used for public API argument validation.
/// </summary>
internal static class PublicContract
{
    // Guidance on inlining:
    // Inline implementation of condition checking but don't inline the code that is only executed on failure.
    // This approach makes the common path efficient (both execution time and code size) 
    // while keeping the rarely executed code in a separate method.
 
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    internal static IEnumerable<T> RequireNonNullItems<T>([NotNull] IEnumerable<T>? sequence, string argumentName) where T : class
    {
        if (sequence == null)
        {
            throw new ArgumentNullException(argumentName);
        }
 
        if (sequence.Contains((T)null!))
        {
            ThrowArgumentItemNullException(sequence, argumentName);
        }
 
        return sequence;
    }
 
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    internal static void RequireUniqueNonNullItems<T>([NotNull] IEnumerable<T>? sequence, string argumentName) where T : class
    {
        if (sequence == null)
        {
            throw new ArgumentNullException(argumentName);
        }
 
        if (sequence.IndexOfNullOrDuplicateItem() >= 0)
        {
            ThrowArgumentItemNullOrDuplicateException(sequence, argumentName);
        }
    }
 
    /// <summary>
    /// Use to validate public API input for properties that are exposed as <see cref="IReadOnlyList{T}"/>.
    /// </summary>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    internal static IReadOnlyList<T> ToBoxedImmutableArrayWithNonNullItems<T>(IEnumerable<T>? sequence, string argumentName) where T : class
    {
        var list = sequence.ToBoxedImmutableArray();
 
        if (list.Contains((T)null!))
        {
            ThrowArgumentItemNullException(list, argumentName);
        }
 
        return list;
    }
 
    /// <summary>
    /// Use to validate public API input for properties that are exposed as <see cref="IReadOnlyList{T}"/> and 
    /// whose items should be unique.
    /// </summary>
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    internal static IReadOnlyList<T> ToBoxedImmutableArrayWithDistinctNonNullItems<T>(IEnumerable<T>? sequence, string argumentName) where T : class
    {
        var list = sequence.ToBoxedImmutableArray();
 
        if (list.IndexOfNullOrDuplicateItem() >= 0)
        {
            ThrowArgumentItemNullOrDuplicateException(list, argumentName);
        }
 
        return list;
    }
 
    private static int IndexOfNullOrDuplicateItem<T>(this IEnumerable<T> sequence) where T : class
        => (sequence is IReadOnlyList<T> list) ? IndexOfNullOrDuplicateItem(list) : EnumeratingIndexOfNullOrDuplicateItem(sequence);
 
    private static int EnumeratingIndexOfNullOrDuplicateItem<T>(IEnumerable<T> sequence) where T : class
    {
        using var _ = PooledHashSet<T>.GetInstance(out var set);
 
        var i = 0;
        foreach (var item in sequence)
        {
            if (item is null || !set.Add(item))
            {
                return i;
            }
 
            i++;
        }
 
        return -1;
    }
 
    private static int IndexOfNullOrDuplicateItem<T>(this IReadOnlyList<T> list) where T : class
    {
        var length = list.Count;
 
        if (length == 0)
        {
            return -1;
        }
 
        if (length == 1)
        {
            return (list[0] is null) ? 0 : -1;
        }
 
        using var _ = PooledHashSet<T>.GetInstance(out var set);
 
        for (var i = 0; i < length; i++)
        {
            var item = list[i];
            if (item is null || !set.Add(item))
            {
                return i;
            }
        }
 
        return -1;
    }
 
    private static string MakeIndexedArgumentName(string argumentName, int index)
        => $"{argumentName}[{index}]";
 
    [DoesNotReturn]
    [MethodImpl(MethodImplOptions.NoInlining)]
    private static void ThrowArgumentItemNullOrDuplicateException<T>(IEnumerable<T> sequence, string argumentName) where T : class
    {
        var list = sequence.ToList();
        var index = list.IndexOfNullOrDuplicateItem();
 
        argumentName = MakeIndexedArgumentName(argumentName, index);
 
        throw (list[index] is null)
             ? new ArgumentNullException(argumentName)
             : new ArgumentException(CompilerExtensionsResources.Specified_sequence_has_duplicate_items, argumentName);
    }
 
    [DoesNotReturn]
    [MethodImpl(MethodImplOptions.NoInlining)]
    private static void ThrowArgumentItemNullException<T>(IEnumerable<T> sequence, string argumentName) where T : class
        => throw new ArgumentNullException(MakeIndexedArgumentName(argumentName, sequence.IndexOf(null!)));
}