// 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.Composition;
using Microsoft.CodeAnalysis.CodeLens;
using Microsoft.CodeAnalysis.CSharp.Extensions;
using Microsoft.CodeAnalysis.CSharp.LanguageService;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Host.Mef;
 
namespace Microsoft.CodeAnalysis.CSharp.CodeLens
{
    [ExportLanguageService(typeof(ICodeLensDisplayInfoService), LanguageNames.CSharp), Shared]
    internal sealed class CSharpCodeLensDisplayInfoService : ICodeLensDisplayInfoService
    {
        private static readonly SymbolDisplayFormat Format =
            SymbolDisplayFormat.CSharpErrorMessageFormat.RemoveMemberOptions(
                SymbolDisplayMemberOptions.IncludeExplicitInterface);
 
        [ImportingConstructor]
        [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
        public CSharpCodeLensDisplayInfoService()
        {
        }
 
        /// <summary>
        /// Returns the node that should be displayed
        /// </summary>
        public SyntaxNode GetDisplayNode(SyntaxNode node)
        {
            while (true)
            {
                switch (node.Kind())
                {
                    // LocalDeclarations do not have symbols themselves, you need a variable declarator
                    case SyntaxKind.LocalDeclarationStatement:
                        var localDeclarationNode = (LocalDeclarationStatementSyntax)node;
                        node = localDeclarationNode.Declaration.Variables.FirstOrDefault();
                        continue;
 
                    // Field and event declarations do not have symbols themselves, you need a variable declarator
                    case SyntaxKind.FieldDeclaration:
                    case SyntaxKind.EventFieldDeclaration:
                        var fieldNode = (BaseFieldDeclarationSyntax)node;
                        node = fieldNode.Declaration.Variables.FirstOrDefault();
                        continue;
 
                    // Variable is a field without access modifier. Parent is FieldDeclaration
                    case SyntaxKind.VariableDeclaration:
                        node = node.Parent;
                        continue;
 
                    // Built in types   
                    case SyntaxKind.PredefinedType:
                        node = node.Parent;
                        continue;
 
                    case SyntaxKind.MultiLineDocumentationCommentTrivia:
                    case SyntaxKind.SingleLineDocumentationCommentTrivia:
                        // For DocumentationCommentTrivia node, node.Parent is null. Obtain parent through ParentTrivia.Token
                        if (node.IsStructuredTrivia)
                        {
                            var structuredTriviaSyntax = (StructuredTriviaSyntax)node;
                            node = structuredTriviaSyntax.ParentTrivia.Token.Parent;
                            continue;
                        }
 
                        return null;
 
                    default:
                        return node;
                }
            }
        }
 
        /// <summary>
        /// Gets the DisplayName for the given node.
        /// </summary>
        public string GetDisplayName(SemanticModel semanticModel, SyntaxNode node)
        {
            if (node == null)
            {
                return FeaturesResources.paren_Unknown_paren;
            }
 
            if (CSharpSyntaxFacts.Instance.IsGlobalAssemblyAttribute(node))
            {
                return "assembly: " + node.ConvertToSingleLine();
            }
 
            // Don't discriminate between getters and setters for indexers
            if (node.Parent.IsKind(SyntaxKind.AccessorList) &&
                node.Parent.Parent.IsKind(SyntaxKind.IndexerDeclaration))
            {
                return GetDisplayName(semanticModel, node.Parent.Parent);
            }
 
            switch (node.Kind())
            {
                case SyntaxKind.ConstructorDeclaration:
                    {
                        // The constructor's name will be the name of the class, not ctor like we want
                        var symbol = semanticModel.GetDeclaredSymbol(node);
                        var displayName = symbol.ToDisplayString(Format);
                        var openParenIndex = displayName.IndexOf('(');
                        var lastDotBeforeOpenParenIndex = displayName.LastIndexOf('.', openParenIndex, openParenIndex);
 
                        var constructorName = symbol.IsStatic ? "cctor" : "ctor";
 
                        return displayName[..(lastDotBeforeOpenParenIndex + 1)] +
                               constructorName +
                               displayName[openParenIndex..];
                    }
 
                case SyntaxKind.IndexerDeclaration:
                    {
                        // The name will be "namespace.class.this[type] - we want "namespace.class[type] Indexer"
                        var symbol = semanticModel.GetDeclaredSymbol(node);
                        var displayName = symbol.ToDisplayString(Format);
                        var openBracketIndex = displayName.IndexOf('[');
                        var lastDotBeforeOpenBracketIndex = displayName.LastIndexOf('.', openBracketIndex, openBracketIndex);
 
                        return displayName[..lastDotBeforeOpenBracketIndex] +
                               displayName[openBracketIndex..] +
                               " Indexer";
                    }
 
                case SyntaxKind.OperatorDeclaration:
                    {
                        // The name will be "namespace.class.operator +(type)" - we want namespace.class.+(type) Operator
                        var symbol = semanticModel.GetDeclaredSymbol(node);
                        var displayName = symbol.ToDisplayString(Format);
                        var spaceIndex = displayName.IndexOf(' ');
                        var lastDotBeforeSpaceIndex = displayName.LastIndexOf('.', spaceIndex, spaceIndex);
 
                        return displayName[..(lastDotBeforeSpaceIndex + 1)] +
                               displayName[(spaceIndex + 1)..] +
                               " Operator";
                    }
 
                case SyntaxKind.ConversionOperatorDeclaration:
                    {
                        // The name will be "namespace.class.operator +(type)" - we want namespace.class.+(type) Operator
                        var symbol = semanticModel.GetDeclaredSymbol(node);
                        var displayName = symbol.ToDisplayString(Format);
                        var firstSpaceIndex = displayName.IndexOf(' ');
                        var secondSpaceIndex = displayName.IndexOf(' ', firstSpaceIndex + 1);
                        var lastDotBeforeSpaceIndex = displayName.LastIndexOf('.', firstSpaceIndex, firstSpaceIndex);
 
                        return displayName[..(lastDotBeforeSpaceIndex + 1)] +
                               displayName[(secondSpaceIndex + 1)..] +
                               " Operator";
                    }
 
                case SyntaxKind.UsingDirective:
                    {
                        // We want to see usings formatted as simply "Using", prefaced by the namespace they are in
                        var enclosingScopeString = GetEnclosingScopeString(node, semanticModel, Format);
                        return string.IsNullOrEmpty(enclosingScopeString) ? "Using" : enclosingScopeString + " Using";
                    }
 
                case SyntaxKind.ExternAliasDirective:
                    {
                        // We want to see aliases formatted as "Alias", prefaced by their enclosing scope, if any
                        var enclosingScopeString = GetEnclosingScopeString(node, semanticModel, Format);
                        return string.IsNullOrEmpty(enclosingScopeString) ? "Alias" : enclosingScopeString + " Alias";
                    }
 
                default:
                    {
                        var symbol = semanticModel.GetDeclaredSymbol(node);
                        return symbol != null ? symbol.ToDisplayString(Format) : FeaturesResources.paren_Unknown_paren;
                    }
            }
        }
 
        private static string GetEnclosingScopeString(SyntaxNode node, SemanticModel semanticModel, SymbolDisplayFormat symbolDisplayFormat)
        {
            var scopeNode = node;
            while (scopeNode != null && !SyntaxFacts.IsNamespaceMemberDeclaration(scopeNode.Kind()))
            {
                scopeNode = scopeNode.Parent;
            }
 
            if (scopeNode == null)
            {
                return null;
            }
 
            var scopeSymbol = semanticModel.GetDeclaredSymbol(scopeNode);
            return scopeSymbol.ToDisplayString(symbolDisplayFormat);
        }
    }
}