// 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.Composition;
using System.Diagnostics.CodeAnalysis;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.CodeAnalysis.CodeFixes.FullyQualify;
using Microsoft.CodeAnalysis.CSharp.Extensions;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Host.Mef;
 
namespace Microsoft.CodeAnalysis.CSharp.CodeFixes.FullyQualify;
 
using static CSharpSyntaxTokens;
 
[ExportLanguageService(typeof(IFullyQualifyService), LanguageNames.CSharp), Shared]
internal sealed class CSharpFullyQualifyService : AbstractFullyQualifyService<SimpleNameSyntax>
{
    [ImportingConstructor]
    [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
    public CSharpFullyQualifyService()
    {
    }
 
    protected override bool CanFullyQualify(SyntaxNode node, [NotNullWhen(true)] out SimpleNameSyntax? simpleName)
    {
        simpleName = node as SimpleNameSyntax;
        if (simpleName is null)
            return false;
 
        if (!simpleName.LooksLikeStandaloneTypeName())
            return false;
 
        if (!simpleName.CanBeReplacedWithAnyName())
            return false;
 
        return true;
    }
 
    protected override async Task<SyntaxNode> ReplaceNodeAsync(SimpleNameSyntax simpleName, string containerName, bool resultingSymbolIsType, CancellationToken cancellationToken)
    {
        var leadingTrivia = simpleName.GetLeadingTrivia();
        var newName = simpleName.WithLeadingTrivia(SyntaxTriviaList.Empty);
 
        var qualifiedName = SyntaxFactory.QualifiedName(SyntaxFactory.ParseName(containerName), newName)
            .WithLeadingTrivia(leadingTrivia);
 
        var syntaxTree = simpleName.SyntaxTree;
        var root = await syntaxTree.GetRootAsync(cancellationToken).ConfigureAwait(false);
 
        // If the name is a type that is part of a using directive, eg. "using Math" then we can go further and
        // instead of just changing to "using System.Math", we can make it "using static System.Math" and avoid the
        // CS0138 that would result from the former.  Don't do this for using aliases though as `static` and using
        // aliases cannot be combined.
        if (resultingSymbolIsType &&
            simpleName.Parent is UsingDirectiveSyntax { Alias: null, StaticKeyword.RawKind: 0 } usingDirective)
        {
            var newUsingDirective = usingDirective
                .WithStaticKeyword(StaticKeyword)
                .WithName(qualifiedName);
 
            return root.ReplaceNode(usingDirective, newUsingDirective);
        }
 
        return root.ReplaceNode(simpleName, qualifiedName);
    }
}