// 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.Immutable;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.CodeAnalysis.AddImport;
using Microsoft.CodeAnalysis.Packaging;
using Microsoft.CodeAnalysis.Shared.Extensions;
using Microsoft.CodeAnalysis.SymbolSearch;
using Microsoft.CodeAnalysis.Text;
 
namespace Microsoft.CodeAnalysis.Remote
{
    internal sealed class RemoteMissingImportDiscoveryService : BrokeredServiceBase, IRemoteMissingImportDiscoveryService
    {
        internal sealed class Factory : FactoryBase<IRemoteMissingImportDiscoveryService, IRemoteMissingImportDiscoveryService.ICallback>
        {
            protected override IRemoteMissingImportDiscoveryService CreateService(in ServiceConstructionArguments arguments, RemoteCallback<IRemoteMissingImportDiscoveryService.ICallback> callback)
                => new RemoteMissingImportDiscoveryService(arguments, callback);
        }
 
        private readonly RemoteCallback<IRemoteMissingImportDiscoveryService.ICallback> _callback;
 
        public RemoteMissingImportDiscoveryService(in ServiceConstructionArguments arguments, RemoteCallback<IRemoteMissingImportDiscoveryService.ICallback> callback)
            : base(arguments)
        {
            _callback = callback;
        }
 
        public ValueTask<ImmutableArray<AddImportFixData>> GetFixesAsync(
            Checksum solutionChecksum,
            RemoteServiceCallbackId callbackId,
            DocumentId documentId,
            TextSpan span,
            string diagnosticId,
            int maxResults,
            AddImportOptions options,
            ImmutableArray<PackageSource> packageSources,
            CancellationToken cancellationToken)
        {
            return RunServiceAsync(solutionChecksum, async solution =>
            {
                var document = solution.GetRequiredDocument(documentId);
 
                var service = document.GetRequiredLanguageService<IAddImportFeatureService>();
 
                var symbolSearchService = new SymbolSearchService(_callback, callbackId);
 
                var result = await service.GetFixesAsync(
                    document, span, diagnosticId, maxResults,
                    symbolSearchService, options,
                    packageSources, cancellationToken).ConfigureAwait(false);
 
                return result;
            }, cancellationToken);
        }
 
        public ValueTask<ImmutableArray<AddImportFixData>> GetUniqueFixesAsync(
            Checksum solutionChecksum,
            RemoteServiceCallbackId callbackId,
            DocumentId documentId,
            TextSpan span,
            ImmutableArray<string> diagnosticIds,
            AddImportOptions options,
            ImmutableArray<PackageSource> packageSources,
            CancellationToken cancellationToken)
        {
            return RunServiceAsync(solutionChecksum, async solution =>
            {
                var document = solution.GetRequiredDocument(documentId);
 
                var service = document.GetRequiredLanguageService<IAddImportFeatureService>();
 
                var symbolSearchService = new SymbolSearchService(_callback, callbackId);
 
                var result = await service.GetUniqueFixesAsync(
                    document, span, diagnosticIds,
                    symbolSearchService, options,
                    packageSources, cancellationToken).ConfigureAwait(false);
 
                return result;
            }, cancellationToken);
        }
 
        /// <summary>
        /// Provides an implementation of the <see cref="ISymbolSearchService"/> on the remote side so that
        /// Add-Import can find results in nuget packages/reference assemblies.  This works
        /// by remoting *from* the OOP server back to the host, which can then forward this 
        /// appropriately to wherever the real <see cref="ISymbolSearchService"/> is running.  This is necessary
        /// because it's not guaranteed that the real <see cref="ISymbolSearchService"/> will be running in 
        /// the same process that is supplying the <see cref="RemoteMissingImportDiscoveryService"/>.
        /// 
        /// Ideally we would not need to bounce back to the host for this.
        /// </summary>
        private sealed class SymbolSearchService : ISymbolSearchService
        {
            private readonly RemoteCallback<IRemoteMissingImportDiscoveryService.ICallback> _callback;
            private readonly RemoteServiceCallbackId _callbackId;
 
            public SymbolSearchService(RemoteCallback<IRemoteMissingImportDiscoveryService.ICallback> callback, RemoteServiceCallbackId callbackId)
            {
                _callback = callback;
                _callbackId = callbackId;
            }
 
            public ValueTask<ImmutableArray<PackageWithTypeResult>> FindPackagesWithTypeAsync(string source, string name, int arity, CancellationToken cancellationToken)
                => _callback.InvokeAsync((callback, cancellationToken) => callback.FindPackagesWithTypeAsync(_callbackId, source, name, arity, cancellationToken), cancellationToken);
 
            public ValueTask<ImmutableArray<PackageWithAssemblyResult>> FindPackagesWithAssemblyAsync(string source, string assemblyName, CancellationToken cancellationToken)
                => _callback.InvokeAsync((callback, cancellationToken) => callback.FindPackagesWithAssemblyAsync(_callbackId, source, assemblyName, cancellationToken), cancellationToken);
 
            public ValueTask<ImmutableArray<ReferenceAssemblyWithTypeResult>> FindReferenceAssembliesWithTypeAsync(string name, int arity, CancellationToken cancellationToken)
                => _callback.InvokeAsync((callback, cancellationToken) => callback.FindReferenceAssembliesWithTypeAsync(_callbackId, name, arity, cancellationToken), cancellationToken);
        }
    }
}