// 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.Composition;
using System.Diagnostics.CodeAnalysis;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.CodeAnalysis.CodeRefactorings;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Editing;
using Microsoft.CodeAnalysis.Shared.Extensions;
using Roslyn.Utilities;
 
namespace Microsoft.CodeAnalysis.CSharp.ImplementInterface
{
    [ExportCodeRefactoringProvider(LanguageNames.CSharp, Name = PredefinedCodeRefactoringProviderNames.ImplementInterfaceImplicitly), Shared]
    internal class CSharpImplementImplicitlyCodeRefactoringProvider :
        AbstractChangeImplementationCodeRefactoringProvider
    {
        [ImportingConstructor]
        [SuppressMessage("RoslynDiagnosticsReliability", "RS0033:Importing constructor should be [Obsolete]", Justification = "Used in test code: https://github.com/dotnet/roslyn/issues/42814")]
        public CSharpImplementImplicitlyCodeRefactoringProvider()
        {
        }
 
        protected override string Implement_0 => FeaturesResources.Implement_0_implicitly;
        protected override string Implement_all_interfaces => FeaturesResources.Implement_all_interfaces_implicitly;
        protected override string Implement => FeaturesResources.Implement_implicitly;
 
        // We need to be an explicit impl in order to convert to implicit.
        protected override bool CheckExplicitNameAllowsConversion(ExplicitInterfaceSpecifierSyntax? explicitName)
            => explicitName != null;
 
        // If we don't implement any interface members explicitly we can't convert this to be
        // implicit.
        protected override bool CheckMemberCanBeConverted(ISymbol member)
        {
            var memberInterfaceImplementations = member.ExplicitInterfaceImplementations();
            if (memberInterfaceImplementations.Length == 0)
                return false;
            var containingTypeInterfaces = member.ContainingType.AllInterfaces;
            if (containingTypeInterfaces.Length == 0)
                return false;
            return memberInterfaceImplementations.Any(static (impl, containingTypeInterfaces) => containingTypeInterfaces.Contains(impl.ContainingType), containingTypeInterfaces);
        }
 
        // When converting to implicit, we don't need to update any references.
        protected override Task UpdateReferencesAsync(Project project, SolutionEditor solutionEditor, ISymbol implMember, INamedTypeSymbol containingType, CancellationToken cancellationToken)
            => Task.CompletedTask;
 
        protected override SyntaxNode ChangeImplementation(SyntaxGenerator generator, SyntaxNode decl, ISymbol _1, ISymbol _2)
            => generator.WithAccessibility(WithoutExplicitImpl(decl), Accessibility.Public);
 
        private static SyntaxNode WithoutExplicitImpl(SyntaxNode decl)
            => decl switch
            {
                MethodDeclarationSyntax member => member.WithExplicitInterfaceSpecifier(null),
                PropertyDeclarationSyntax member => member.WithExplicitInterfaceSpecifier(null),
                EventDeclarationSyntax member => member.WithExplicitInterfaceSpecifier(null),
                _ => throw ExceptionUtilities.UnexpectedValue(decl),
            };
    }
}