// 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 Microsoft.CodeAnalysis.CodeStyle;
using Microsoft.CodeAnalysis.Diagnostics;
using Microsoft.CodeAnalysis.Operations;
 
namespace Microsoft.CodeAnalysis.ConvertTypeOfToNameOf;
 
internal abstract class AbstractConvertTypeOfToNameOfDiagnosticAnalyzer(LocalizableString title)
    : AbstractBuiltInCodeStyleDiagnosticAnalyzer(
        IDEDiagnosticIds.ConvertTypeOfToNameOfDiagnosticId,
        EnforceOnBuildValues.ConvertTypeOfToNameOf,
        option: null,
        title: title)
{
    public override DiagnosticAnalyzerCategory GetAnalyzerCategory()
        => DiagnosticAnalyzerCategory.SemanticSpanAnalysis;
 
    protected abstract bool IsValidTypeofAction(OperationAnalysisContext context);
 
    protected override void InitializeWorker(AnalysisContext context)
        => context.RegisterOperationAction(AnalyzeAction, OperationKind.TypeOf);
 
    protected void AnalyzeAction(OperationAnalysisContext context)
    {
        if (ShouldSkipAnalysis(context, notification: null))
            return;
 
        if (!IsValidTypeofAction(context) || !IsValidOperation(context.Operation))
            return;
 
        var node = context.Operation.Syntax;
        var parent = node.Parent;
 
        // If the parent node is null then it cannot be a member access, so do not report a diagnostic
        if (parent is null)
            return;
 
        var location = parent.GetLocation();
        context.ReportDiagnostic(Diagnostic.Create(Descriptor, location));
 
    }
 
    private static bool IsValidOperation(IOperation operation)
    {
        // Cast to a typeof operation & check parent is a property reference and member access
        var typeofOperation = (ITypeOfOperation)operation;
        if (operation.Parent is not IPropertyReferenceOperation)
            return false;
 
        // Check Parent is a .Name access
        var operationParent = (IPropertyReferenceOperation)operation.Parent;
        var parentProperty = operationParent.Property.Name;
        if (parentProperty is not nameof(System.Type.Name))
            return false;
 
        // If it's a generic type, do not offer the fix because nameof(T) and typeof(T).Name are not 
        // semantically equivalent, the resulting string is formatted differently, where typeof(T).Name
        // return "T`1" and nameof just returns "T"
        if (typeofOperation.TypeOperand is IErrorTypeSymbol)
            return false;
 
        if (typeofOperation.TypeOperand is not INamedTypeSymbol namedType)
            return false;
 
        // Note: generic names like `typeof(List<int>)` are not convertible (since the name will be List`1). However,
        // it's fine if an outer part of the name is generic (like `typeof(List<int>.Enumerator)`). as that will be
        // convertible to `nameof(List<>.Enumerator)`.  So we only need to check the type arguments directly on the type
        // here, not on any containing types.
        return namedType.TypeArguments.Length == 0;
    }
}