// 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.Immutable;
using System.Composition;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.CodeAnalysis.Host.Mef;
using Microsoft.CodeAnalysis.NavigateTo;
using Microsoft.CodeAnalysis.Shared.TestHooks;
using Roslyn.LanguageServer.Protocol;
using Roslyn.Utilities;
 
namespace Microsoft.CodeAnalysis.LanguageServer.Handler
{
    /// <summary>
    /// TODO - This must be moved to the MS.CA.LanguageServer.Protocol project once
    /// we no longer reference VS icon types.
    /// </summary>
    [ExportCSharpVisualBasicStatelessLspService(typeof(WorkspaceSymbolsHandler)), Shared]
    [Method(Methods.WorkspaceSymbolName)]
    [method: ImportingConstructor]
    [method: Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
    internal sealed class WorkspaceSymbolsHandler(IAsynchronousOperationListenerProvider listenerProvider)
        : ILspServiceRequestHandler<WorkspaceSymbolParams, SumType<SymbolInformation[], WorkspaceSymbol[]>?>
    {
        private static readonly IImmutableSet<string> s_supportedKinds = [
            NavigateToItemKind.Class,
            NavigateToItemKind.Constant,
            NavigateToItemKind.Delegate,
            NavigateToItemKind.Enum,
            NavigateToItemKind.EnumItem,
            NavigateToItemKind.Event,
            NavigateToItemKind.Field,
            NavigateToItemKind.Interface,
            NavigateToItemKind.Method,
            NavigateToItemKind.Module,
            NavigateToItemKind.Property,
            NavigateToItemKind.Structure
        ];
 
        private readonly IAsynchronousOperationListener _asyncListener = listenerProvider.GetListener(FeatureAttribute.NavigateTo);
 
        public bool MutatesSolutionState => false;
        public bool RequiresLSPSolution => true;
 
        public async Task<SumType<SymbolInformation[], WorkspaceSymbol[]>?> HandleRequestAsync(WorkspaceSymbolParams request, RequestContext context, CancellationToken cancellationToken)
        {
            Contract.ThrowIfNull(context.Solution);
 
            var solution = context.Solution;
 
            using var progress = BufferedProgress.Create(
                request.PartialResultToken,
                (SymbolInformation[] t) => new SumType<SymbolInformation[], WorkspaceSymbol[]>(t));
 
            var searcher = NavigateToSearcher.Create(
                solution,
                _asyncListener,
                new LSPNavigateToCallback(context, progress),
                request.Query,
                s_supportedKinds,
                cancellationToken);
 
            await searcher.SearchAsync(NavigateToSearchScope.Solution, cancellationToken).ConfigureAwait(false);
            return progress.GetValues()?.Flatten().ToArray();
        }
 
        private sealed class LSPNavigateToCallback(
            RequestContext context,
            BufferedProgress<SymbolInformation[]> progress)
            : INavigateToSearchCallback
        {
            public async Task AddResultsAsync(ImmutableArray<INavigateToSearchResult> results, CancellationToken cancellationToken)
            {
                Contract.ThrowIfNull(context.Solution);
                var solution = context.Solution;
 
                var clientCapabilities = context.GetRequiredClientCapabilities();
                var supportsVSExtensions = clientCapabilities.HasVisualStudioLspCapability();
 
                foreach (var result in results)
                {
                    var document = await result.NavigableItem.Document.GetRequiredDocumentAsync(solution, cancellationToken).ConfigureAwait(false);
 
                    var location = await ProtocolConversions.TextSpanToLocationAsync(
                        document, result.NavigableItem.SourceSpan, result.NavigableItem.IsStale, context, cancellationToken).ConfigureAwait(false);
                    if (location == null)
                        return;
 
                    var symbolInfo = SymbolInformationFactory.Create(
                        result.Name,
                        result.AdditionalInformation,
                        ProtocolConversions.NavigateToKindToSymbolKind(result.Kind),
                        location,
                        result.NavigableItem.Glyph,
                        supportsVSExtensions);
 
                    progress.Report(symbolInfo);
                }
            }
 
            public void Done(bool isFullyLoaded)
            {
                // do nothing, we already await the SearchAsync method which calls this in a finally right before returning.
                // used by non-LSP editor API.
            }
 
            public void ReportProgress(int current, int maximum)
            {
                // do nothing, LSP doesn't support reporting progress towards completion.
                // used by non-LSP editor API.
            }
 
            public void ReportIncomplete()
            {
            }
        }
    }
}