// 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.Collections.Immutable;
using System.Composition;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using Microsoft.CodeAnalysis.Host;
using Microsoft.CodeAnalysis.Host.Mef;
using Microsoft.CodeAnalysis.Internal.Log;
using Microsoft.CodeAnalysis.LegacySolutionEvents;
using Microsoft.CodeAnalysis.Shared.TestHooks;
using Roslyn.Utilities;
 
namespace Microsoft.CodeAnalysis.ExternalAccess.UnitTesting.SolutionCrawler;
 
[ExportWorkspaceService(typeof(IUnitTestingSolutionCrawlerRegistrationService), ServiceLayer.Host), Shared]
internal sealed partial class UnitTestingSolutionCrawlerRegistrationService : IUnitTestingSolutionCrawlerRegistrationService
{
    private const string Default = "*";
 
    private readonly object _gate = new();
    private readonly UnitTestingSolutionCrawlerProgressReporter _progressReporter = new();
 
    private readonly IAsynchronousOperationListener _listener;
    private readonly Dictionary<(string workspaceKind, SolutionServices services), UnitTestingWorkCoordinator> _documentWorkCoordinatorMap = [];
 
    private ImmutableDictionary<string, ImmutableArray<Lazy<IUnitTestingIncrementalAnalyzerProvider, UnitTestingIncrementalAnalyzerProviderMetadata>>> _analyzerProviders;
 
    /// <summary>
    /// The last solution we've heard about from the <see cref="ILegacySolutionEventsListener"/>.  This is used by
    /// our <see cref="UnitTestingWorkCoordinator"/> to represent the equivalent entity that <see
    /// cref="Workspace.CurrentSolution"/> normally represents.
    /// </summary>
    private Solution _lastReportedSolution = null!;
 
    [ImportingConstructor]
    [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
    public UnitTestingSolutionCrawlerRegistrationService(
        [ImportMany] IEnumerable<Lazy<IUnitTestingIncrementalAnalyzerProvider, UnitTestingIncrementalAnalyzerProviderMetadata>> analyzerProviders,
        IAsynchronousOperationListenerProvider listenerProvider)
    {
        _analyzerProviders = analyzerProviders.GroupBy(kv => kv.Metadata.Name).ToImmutableDictionary(g => g.Key, g => g.ToImmutableArray());
        AssertAnalyzerProviders(_analyzerProviders);
 
        _listener = listenerProvider.GetListener(FeatureAttribute.SolutionCrawlerUnitTesting);
    }
 
    /// <summary>
    /// make sure solution cralwer is registered for the given workspace.
    /// </summary>
    public IUnitTestingWorkCoordinator Register(Solution solution)
    {
        var workspaceKind = solution.WorkspaceKind;
        var solutionServices = solution.Services;
        Contract.ThrowIfNull(workspaceKind);
 
        var correlationId = CorrelationIdFactory.GetNextId();
 
        UnitTestingWorkCoordinator? coordinator;
        lock (_gate)
        {
            _lastReportedSolution = solution;
            if (!_documentWorkCoordinatorMap.TryGetValue((workspaceKind, solutionServices), out coordinator))
            {
                coordinator = new UnitTestingWorkCoordinator(
                    _listener,
                    GetAnalyzerProviders(workspaceKind),
                    new UnitTestingRegistration(this, correlationId, workspaceKind, solutionServices, _progressReporter));
 
                _documentWorkCoordinatorMap.Add((workspaceKind, solutionServices), coordinator);
            }
        }
 
        UnitTestingSolutionCrawlerLogger.LogRegistration(correlationId, workspaceKind);
        return coordinator;
    }
 
    public bool HasRegisteredAnalyzerProviders
    {
        get
        {
            lock (_gate)
            {
                return _analyzerProviders.Count > 0;
            }
        }
    }
 
    public void AddAnalyzerProvider(IUnitTestingIncrementalAnalyzerProvider provider, UnitTestingIncrementalAnalyzerProviderMetadata metadata)
    {
        // now update all existing work coordinator
        lock (_gate)
        {
            var lazyProvider = new Lazy<IUnitTestingIncrementalAnalyzerProvider, UnitTestingIncrementalAnalyzerProviderMetadata>(() => provider, metadata);
 
            // update existing map for future solution crawler registration - no need for interlock but this makes add or update easier
            ImmutableInterlocked.AddOrUpdate(ref _analyzerProviders, metadata.Name, n => [lazyProvider], (n, v) => v.Add(lazyProvider));
 
            // assert map integrity
            AssertAnalyzerProviders(_analyzerProviders);
 
            // find existing coordinator to update
            var lazyProviders = _analyzerProviders[metadata.Name];
            foreach (var ((workspaceKind, solutionServices), coordinator) in _documentWorkCoordinatorMap)
            {
                Contract.ThrowIfNull(workspaceKind);
 
                if (!TryGetProvider(workspaceKind, lazyProviders, out var picked) || picked != lazyProvider)
                {
                    // check whether new provider belong to current workspace
                    continue;
                }
 
                var analyzer = lazyProvider.Value.CreateIncrementalAnalyzer();
                if (analyzer != null)
                {
                    coordinator.AddAnalyzer(analyzer);
                }
            }
        }
    }
 
    public void Reanalyze(string? workspaceKind, SolutionServices services, IUnitTestingIncrementalAnalyzer analyzer, IEnumerable<ProjectId>? projectIds, IEnumerable<DocumentId>? documentIds)
    {
        Contract.ThrowIfNull(workspaceKind);
 
        lock (_gate)
        {
            if (!_documentWorkCoordinatorMap.TryGetValue((workspaceKind, services), out var coordinator))
            {
                // this can happen if solution crawler is already unregistered from workspace.
                // one of those example will be VS shutting down so roslyn package is disposed but there is a pending
                // async operation.
                return;
            }
 
            // no specific projects or documents provided
            if (projectIds == null && documentIds == null)
            {
                var solution = coordinator.Registration.GetSolutionToAnalyze();
                coordinator.Reanalyze(analyzer, new UnitTestingReanalyzeScope(solution.Id));
                return;
            }
 
            coordinator.Reanalyze(analyzer, new UnitTestingReanalyzeScope(projectIds, documentIds));
        }
    }
 
    private IEnumerable<Lazy<IUnitTestingIncrementalAnalyzerProvider, UnitTestingIncrementalAnalyzerProviderMetadata>> GetAnalyzerProviders(string workspaceKind)
    {
        foreach (var (_, lazyProviders) in _analyzerProviders)
        {
            // try get provider for the specific workspace kind
            if (TryGetProvider(workspaceKind, lazyProviders, out var lazyProvider))
            {
                yield return lazyProvider;
                continue;
            }
 
            // try get default provider
            if (TryGetProvider(Default, lazyProviders, out lazyProvider))
            {
                yield return lazyProvider;
            }
        }
    }
 
    private static bool TryGetProvider(
        string kind,
        ImmutableArray<Lazy<IUnitTestingIncrementalAnalyzerProvider, UnitTestingIncrementalAnalyzerProviderMetadata>> lazyProviders,
        [NotNullWhen(true)] out Lazy<IUnitTestingIncrementalAnalyzerProvider, UnitTestingIncrementalAnalyzerProviderMetadata>? lazyProvider)
    {
        // set out param
        lazyProvider = null;
 
        // try find provider for specific workspace kind
        if (kind != Default)
        {
            foreach (var provider in lazyProviders)
            {
                if (provider.Metadata.WorkspaceKinds.Any(wk => wk == kind))
                {
                    lazyProvider = provider;
                    return true;
                }
            }
 
            return false;
        }
 
        // try find default provider
        foreach (var provider in lazyProviders)
        {
            if (IsDefaultProvider(provider.Metadata))
            {
                lazyProvider = provider;
                return true;
            }
 
            return false;
        }
 
        return false;
    }
 
    [Conditional("DEBUG")]
    private static void AssertAnalyzerProviders(
        ImmutableDictionary<string, ImmutableArray<Lazy<IUnitTestingIncrementalAnalyzerProvider, UnitTestingIncrementalAnalyzerProviderMetadata>>> analyzerProviders)
    {
#if DEBUG
        // make sure there is duplicated provider defined for same workspace.
        var set = new HashSet<string>();
        foreach (var kv in analyzerProviders)
        {
            foreach (var lazyProvider in kv.Value)
            {
                if (IsDefaultProvider(lazyProvider.Metadata))
                {
                    Debug.Assert(set.Add(Default));
                    continue;
                }
 
                foreach (var kind in lazyProvider.Metadata.WorkspaceKinds)
                {
                    Debug.Assert(set.Add(kind));
                }
            }
 
            set.Clear();
        }
#endif
    }
 
    private static bool IsDefaultProvider(UnitTestingIncrementalAnalyzerProviderMetadata providerMetadata)
        => providerMetadata.WorkspaceKinds is [];
 
    internal TestAccessor GetTestAccessor()
    {
        return new TestAccessor(this);
    }
 
    internal readonly struct TestAccessor
    {
        private readonly UnitTestingSolutionCrawlerRegistrationService _solutionCrawlerRegistrationService;
 
        internal TestAccessor(UnitTestingSolutionCrawlerRegistrationService solutionCrawlerRegistrationService)
        {
            _solutionCrawlerRegistrationService = solutionCrawlerRegistrationService;
        }
 
        internal ref ImmutableDictionary<string, ImmutableArray<Lazy<IUnitTestingIncrementalAnalyzerProvider, UnitTestingIncrementalAnalyzerProviderMetadata>>> AnalyzerProviders
            => ref _solutionCrawlerRegistrationService._analyzerProviders;
    }
 
    internal sealed class UnitTestingRegistration(
        UnitTestingSolutionCrawlerRegistrationService owner,
        int correlationId,
        string workspaceKind,
        SolutionServices solutionServices,
        UnitTestingSolutionCrawlerProgressReporter progressReporter)
    {
        private readonly UnitTestingSolutionCrawlerRegistrationService _owner = owner;
 
        public readonly int CorrelationId = correlationId;
        public readonly string WorkspaceKind = workspaceKind;
        public readonly SolutionServices Services = solutionServices;
        public readonly UnitTestingSolutionCrawlerProgressReporter ProgressReporter = progressReporter;
 
        public Solution GetSolutionToAnalyze()
        {
            lock (_owner._gate)
                return _owner._lastReportedSolution;
        }
    }
}