// 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.Collections.Generic;
using System.Collections.Immutable;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.CodeAnalysis.Shared.Utilities;

#if !NETCOREAPP
using Roslyn.Utilities;
#endif

namespace Microsoft.CodeAnalysis.FindSymbols;

public static partial class SymbolFinder
{
    /// <summary>
    /// Finds all the callers of a specified symbol.
    /// </summary>
    public static Task<IEnumerable<SymbolCallerInfo>> FindCallersAsync(
        ISymbol symbol, Solution solution, CancellationToken cancellationToken = default)
    {
        return FindCallersAsync(symbol, solution, documents: null, cancellationToken: cancellationToken);
    }

    /// <summary>
    /// Finds all the callers of a specified symbol.
    /// </summary>
    public static async Task<IEnumerable<SymbolCallerInfo>> FindCallersAsync(
        ISymbol symbol, Solution solution, IImmutableSet<Document>? documents, CancellationToken cancellationToken = default)
    {
        if (symbol is null)
            throw new System.ArgumentNullException(nameof(symbol));
        if (solution is null)
            throw new System.ArgumentNullException(nameof(solution));

        symbol = symbol.OriginalDefinition;
        var foundSymbol = await FindSourceDefinitionAsync(symbol, solution, cancellationToken).ConfigureAwait(false);
        symbol = foundSymbol ?? symbol;

        var references = await FindCallReferencesAsync(solution, symbol, documents, cancellationToken).ConfigureAwait(false);

        var directReference = references.Where(
            r => SymbolEquivalenceComparer.Instance.Equals(symbol, r.Definition)).FirstOrDefault();

        var indirectReferences = references.WhereAsArray(r => r != directReference);

        var results = new List<SymbolCallerInfo>();

        if (directReference != null)
        {
            await AddReferencingSymbolsAsync(directReference, isDirect: true).ConfigureAwait(false);
        }

        foreach (var indirectReference in indirectReferences)
        {
            await AddReferencingSymbolsAsync(indirectReference, isDirect: false).ConfigureAwait(false);
        }

        return results;

        async Task AddReferencingSymbolsAsync(ReferencedSymbol reference, bool isDirect)
        {
            var result = await reference.Locations.FindReferencingSymbolsAsync(cancellationToken).ConfigureAwait(false);
            foreach (var (callingSymbol, locations) in result)
            {
                results.Add(new SymbolCallerInfo(callingSymbol, reference.Definition, locations, isDirect));
            }
        }
    }

    private static async Task<ImmutableArray<ReferencedSymbol>> FindCallReferencesAsync(
        Solution solution,
        ISymbol symbol,
        IImmutableSet<Document>? documents,
        CancellationToken cancellationToken = default)
    {
        if (symbol.Kind is SymbolKind.Event or
            SymbolKind.Method or
            SymbolKind.Property or
            SymbolKind.Field)
        {
            var collector = new StreamingProgressCollector();
            var options = FindReferencesSearchOptions.GetFeatureOptionsForStartingSymbol(symbol);
            await FindReferencesAsync(
                symbol, solution, collector, documents,
                options, cancellationToken).ConfigureAwait(false);
            return collector.GetReferencedSymbols();
        }

        return [];
    }
}