// 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.Collections.Immutable;
using System.Globalization;
using System.Threading;
 
namespace Microsoft.CodeAnalysis.CSharp.Symbols.PublicModel
{
    internal sealed class PreprocessingSymbol : IPreprocessingSymbol
    {
        private readonly string _name;
 
        internal PreprocessingSymbol(string name)
        {
            _name = name;
        }
 
        ISymbol ISymbol.OriginalDefinition => this;
 
        ISymbol? ISymbol.ContainingSymbol => null;
 
        INamedTypeSymbol? ISymbol.ContainingType => null;
 
        public sealed override int GetHashCode()
        {
            return this._name.GetHashCode();
        }
 
        public override bool Equals(object? obj)
        {
            if (ReferenceEquals(this, obj))
            {
                return true;
            }
 
            if (ReferenceEquals(obj, null))
            {
                return false;
            }
 
            PreprocessingSymbol? other = obj as PreprocessingSymbol;
 
            return (object?)other != null &&
                this._name.Equals(other._name);
        }
 
        bool IEquatable<ISymbol?>.Equals(ISymbol? other)
        {
            return this.Equals(other);
        }
 
        bool ISymbol.Equals(ISymbol? other, CodeAnalysis.SymbolEqualityComparer equalityComparer)
        {
            return this.Equals(other);
        }
 
        ImmutableArray<Location> ISymbol.Locations => ImmutableArray<Location>.Empty;
 
        ImmutableArray<SyntaxReference> ISymbol.DeclaringSyntaxReferences => ImmutableArray<SyntaxReference>.Empty;
 
        ImmutableArray<AttributeData> ISymbol.GetAttributes() => ImmutableArray<AttributeData>.Empty;
 
        Accessibility ISymbol.DeclaredAccessibility => Accessibility.NotApplicable;
 
        void ISymbol.Accept(SymbolVisitor visitor) => visitor.VisitPreprocessing(this);
 
        TResult ISymbol.Accept<TResult>(SymbolVisitor<TResult> visitor) => visitor.VisitPreprocessing(this)!;
 
        TResult ISymbol.Accept<TArgument, TResult>(SymbolVisitor<TArgument, TResult> visitor, TArgument argument) => visitor.VisitPreprocessing(this, argument);
 
        string? ISymbol.GetDocumentationCommentId() => null;
 
        string? ISymbol.GetDocumentationCommentXml(CultureInfo? preferredCulture, bool expandIncludes, CancellationToken cancellationToken) => null;
 
        string ISymbol.ToDisplayString(SymbolDisplayFormat? format)
        {
            return SymbolDisplay.ToDisplayString(this, format);
        }
 
        ImmutableArray<SymbolDisplayPart> ISymbol.ToDisplayParts(SymbolDisplayFormat? format)
        {
            return SymbolDisplay.ToDisplayParts(this, format);
        }
 
        string ISymbol.ToMinimalDisplayString(SemanticModel semanticModel, int position, SymbolDisplayFormat? format)
        {
            return SymbolDisplay.ToMinimalDisplayString(this, Symbol.GetCSharpSemanticModel(semanticModel), position, format);
        }
 
        ImmutableArray<SymbolDisplayPart> ISymbol.ToMinimalDisplayParts(SemanticModel semanticModel, int position, SymbolDisplayFormat? format)
        {
            return SymbolDisplay.ToMinimalDisplayParts(this, Symbol.GetCSharpSemanticModel(semanticModel), position, format);
        }
 
        SymbolKind ISymbol.Kind => SymbolKind.Preprocessing;
 
        string ISymbol.Language => LanguageNames.CSharp;
 
        string ISymbol.Name => _name;
 
        string ISymbol.MetadataName => _name;
 
        int ISymbol.MetadataToken => 0;
 
        IAssemblySymbol? ISymbol.ContainingAssembly => null;
 
        IModuleSymbol? ISymbol.ContainingModule => null;
 
        INamespaceSymbol? ISymbol.ContainingNamespace => null;
 
        bool ISymbol.IsDefinition => true;
 
        bool ISymbol.IsStatic => false;
 
        bool ISymbol.IsVirtual => false;
 
        bool ISymbol.IsOverride => false;
 
        bool ISymbol.IsAbstract => false;
 
        bool ISymbol.IsSealed => false;
 
        bool ISymbol.IsExtern => false;
 
        bool ISymbol.IsImplicitlyDeclared => false;
 
        bool ISymbol.CanBeReferencedByName => SyntaxFacts.IsValidIdentifier(_name) && !SyntaxFacts.ContainsDroppedIdentifierCharacters(_name);
 
        bool ISymbol.HasUnsupportedMetadata => false;
 
        public sealed override string ToString()
        {
            return SymbolDisplay.ToDisplayString(this);
        }
    }
}