// 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.
 
#nullable disable
 
using System;
using System.ComponentModel.Composition;
using Microsoft.CodeAnalysis.Host.Mef;
using Microsoft.Internal.VisualStudio.Shell.ErrorList;
using Microsoft.VisualStudio.Shell.TableControl;
using Microsoft.VisualStudio.Shell.TableManager;
using Microsoft.VisualStudio.Text.Editor;
using Microsoft.VisualStudio.Utilities;
 
namespace Microsoft.VisualStudio.LanguageServices.Implementation.FindUsages;
 
internal static class RichNavOptions
{
    internal const string RichNavAvailableOptionName = "RichNavAvailable";
}
 
[Export(typeof(IScopeFilterFactory))]
[TableManagerIdentifier("FindAllReferences*")]
[TableManagerIdentifier("FindResults*")]
[Replaces(PredefinedScopeFilterNames.EntireSolutionScopeFilter)]
[Replaces(PredefinedScopeFilterNames.AllItemsScopeFilter)]
[DeferCreation(OptionName = RichNavOptions.RichNavAvailableOptionName)] // This factory will not be loaded unless this option is set to Boolean true
[DefaultScope]
[Name(PredefinedScopeFilterNames.LoadedSolutionScopeFilter)]
[Order(Before = PredefinedScopeFilterNames.AllItemsScopeFilter)]
internal class LoadedSolutionScopeFilterFactory : IReplacingScopeFilterFactory
{
    [ImportingConstructor]
    [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
    public LoadedSolutionScopeFilterFactory()
    {
    }
 
    public IErrorListFilterHandler CreateFilter(IWpfTableControl tableControl)
    {
        // We're only replacing an existing filter, and not creating a new one.
        return null;
    }
 
    public IErrorListFilterHandler ReplaceFilter(IWpfTableControl tableControl, string filterIdentifier)
    {
        if (filterIdentifier == PredefinedScopeFilterNames.AllItemsScopeFilter)
        {
            return new LoadedSolutionFilterHandler(ServicesVSResources.Loaded_items);
        }
        else if (filterIdentifier == PredefinedScopeFilterNames.EntireSolutionScopeFilter)
        {
            return new LoadedSolutionFilterHandler(ServicesVSResources.Loaded_solution);
        }
 
        return null; // Don't replace
    }
}
 
internal abstract class RoslynFilterHandler : FilterHandlerBase
{
    private readonly ItemOrigin _origin;
 
    protected RoslynFilterHandler(int id, string displayName, ItemOrigin origin)
    {
        FilterId = id;
        FilterDisplayName = displayName;
        _origin = origin;
    }
 
    public sealed override int FilterId { get; }
 
    public sealed override string FilterDisplayName { get; }
 
    public sealed override IEntryFilter GetFilter(out string displayText)
    {
        displayText = FilterDisplayName;
        return new ItemOriginFilter(_origin);
    }
}
 
internal class LoadedSolutionFilterHandler : RoslynFilterHandler
{
    private const int LoadedSolutionFilterHandlerFilterId = 20;
    public LoadedSolutionFilterHandler(string displayName)
        : base(LoadedSolutionFilterHandlerFilterId, displayName, ItemOrigin.ExactMetadata)
    {
    }
}
 
[Export(typeof(IScopeFilterFactory))]
[TableManagerIdentifier("FindAllReferences*")]
[TableManagerIdentifier("FindResults*")]
[DeferCreation(OptionName = RichNavOptions.RichNavAvailableOptionName)] // This factory will not be loaded unless this option is set to Boolean true
[Name(AllSourcesFilterHandlerFactory.AllSourcesScopeFilter)]
[Order(Before = PredefinedScopeFilterNames.EntireRepositoryScopeFilter)]
internal class AllSourcesFilterHandlerFactory : IScopeFilterFactory
{
    private const string AllSourcesScopeFilter = "All Sources";
 
    [ImportingConstructor]
    [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
    public AllSourcesFilterHandlerFactory()
    {
    }
 
    public IErrorListFilterHandler CreateFilter(IWpfTableControl tableControl)
        => new AllSourcesFilterHandler();
}
 
internal class AllSourcesFilterHandler : RoslynFilterHandler
{
    private const int AllSourcesFilterHandlerFilterId = 22;
 
    public AllSourcesFilterHandler()
        : base(AllSourcesFilterHandlerFilterId, ServicesVSResources.All_sources, ItemOrigin.IndexedInThirdParty)
    {
    }
}
 
[Export(typeof(IScopeFilterFactory))]
[TableManagerIdentifier("FindAllReferences*")]
[TableManagerIdentifier("FindResults*")]
[DeferCreation(OptionName = RichNavOptions.RichNavAvailableOptionName)] // This factory will not be loaded unless this option is set to Boolean true
[Name(PredefinedScopeFilterNames.EntireRepositoryScopeFilter)]
[Order(Before = PredefinedScopeFilterNames.LoadedSolutionScopeFilter)]
internal class EntireRepositoryFilterHandlerFactory : IScopeFilterFactory
{
    [ImportingConstructor]
    [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
    public EntireRepositoryFilterHandlerFactory()
    {
    }
 
    public IErrorListFilterHandler CreateFilter(IWpfTableControl tableControl)
        => new EntireRepositoryFilterHandler();
}
 
internal class EntireRepositoryFilterHandler : RoslynFilterHandler
{
    private const int EntireRepositoryFilterHandlerFilterId = 21;
 
    public EntireRepositoryFilterHandler()
        : base(EntireRepositoryFilterHandlerFilterId, ServicesVSResources.Entire_repository, ItemOrigin.IndexedInRepo)
    {
    }
}
 
internal class ItemOriginFilter : IEntryFilter
{
    private readonly ItemOrigin _targetOrigin;
 
    internal ItemOriginFilter(ItemOrigin targetOrigin)
        => _targetOrigin = targetOrigin;
 
    public bool Match(ITableEntryHandle entry)
    {
        Requires.NotNull(entry, nameof(entry));
 
        if (entry.TryGetValue(StandardTableKeyNames.ItemOrigin, out ItemOrigin entryOrigin))
            return entryOrigin <= _targetOrigin;
 
        // For backwards compatibility, consider items without ItemOrigin to be ItemOrigin.Exact (always matched)
        return true;
    }
}