// 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.Collections.Immutable;
using System.Globalization;
using System.Runtime.CompilerServices;
using System.Threading;
using Microsoft.CodeAnalysis.Editing;
using Microsoft.CodeAnalysis.Shared.Extensions;
 
namespace Microsoft.CodeAnalysis.CodeGeneration;
 
internal abstract class CodeGenerationSymbol : ISymbol
{
    protected static ConditionalWeakTable<CodeGenerationSymbol, SyntaxAnnotation[]> annotationsTable = new();
 
    private readonly ImmutableArray<AttributeData> _attributes;
    protected readonly string _documentationCommentXml;
 
    public Accessibility DeclaredAccessibility { get; }
    protected internal DeclarationModifiers Modifiers { get; }
    public string Name { get; }
    public INamedTypeSymbol ContainingType { get; protected set; }
 
    protected CodeGenerationSymbol(
        IAssemblySymbol containingAssembly,
        INamedTypeSymbol containingType,
        ImmutableArray<AttributeData> attributes,
        Accessibility declaredAccessibility,
        DeclarationModifiers modifiers,
        string name,
        string documentationCommentXml = null)
    {
        this.ContainingAssembly = containingAssembly;
        this.ContainingType = containingType;
        _attributes = attributes.NullToEmpty();
        this.DeclaredAccessibility = declaredAccessibility;
        this.Modifiers = modifiers;
        this.Name = name;
        _documentationCommentXml = documentationCommentXml;
    }
 
    protected abstract CodeGenerationSymbol Clone();
 
    internal SyntaxAnnotation[] GetAnnotations()
    {
        annotationsTable.TryGetValue(this, out var annotations);
        return annotations ?? [];
    }
 
    internal CodeGenerationSymbol WithAdditionalAnnotations(params SyntaxAnnotation[] annotations)
    {
        return annotations.IsNullOrEmpty()
            ? this
            : AddAnnotationsTo(this, this.Clone(), annotations);
    }
 
    private static CodeGenerationSymbol AddAnnotationsTo(
        CodeGenerationSymbol originalDefinition, CodeGenerationSymbol newDefinition, SyntaxAnnotation[] annotations)
    {
        annotationsTable.TryGetValue(originalDefinition, out var originalAnnotations);
 
        annotations = SyntaxAnnotationExtensions.CombineAnnotations(originalAnnotations, annotations);
        annotationsTable.Add(newDefinition, annotations);
 
        return newDefinition;
    }
 
    public abstract SymbolKind Kind { get; }
 
    public string Language => "Code Generation Agnostic Language";
 
    public virtual ISymbol ContainingSymbol => null;
 
    public IAssemblySymbol ContainingAssembly { get; }
 
    public static IMethodSymbol ContainingMethod => null;
 
    public IModuleSymbol ContainingModule => null;
 
    public INamespaceSymbol ContainingNamespace => null;
 
    public bool IsDefinition => true;
 
    public bool IsStatic
    {
        get
        {
            return this.Modifiers.IsStatic;
        }
    }
 
    public bool IsVirtual
    {
        get
        {
            return this.Modifiers.IsVirtual;
        }
    }
 
    public bool IsOverride
    {
        get
        {
            return this.Modifiers.IsOverride;
        }
    }
 
    public bool IsAbstract
    {
        get
        {
            return this.Modifiers.IsAbstract;
        }
    }
 
    public bool IsSealed
    {
        get
        {
            return this.Modifiers.IsSealed;
        }
    }
 
    public bool IsExtern => false;
 
    public bool IsImplicitlyDeclared => false;
 
    public bool CanBeReferencedByName => true;
 
    public ImmutableArray<Location> Locations
    {
        get
        {
            return [];
        }
    }
 
    public static ImmutableArray<SyntaxNode> DeclaringSyntaxNodes
    {
        get
        {
            return [];
        }
    }
 
    public ImmutableArray<SyntaxReference> DeclaringSyntaxReferences
    {
        get
        {
            return [];
        }
    }
 
    public ImmutableArray<AttributeData> GetAttributes()
        => _attributes;
 
    public ImmutableArray<AttributeData> GetAttributes(INamedTypeSymbol attributeType)
        => GetAttributes().WhereAsArray(a => a.AttributeClass.Equals(attributeType));
 
    public ImmutableArray<AttributeData> GetAttributes(IMethodSymbol attributeConstructor)
        => GetAttributes().WhereAsArray(a => a.AttributeConstructor.Equals(attributeConstructor));
 
    public ISymbol OriginalDefinition
    {
        get
        {
            return this;
        }
    }
 
    public abstract void Accept(SymbolVisitor visitor);
 
    public abstract TResult Accept<TResult>(SymbolVisitor<TResult> visitor);
 
    public abstract TResult Accept<TArgument, TResult>(SymbolVisitor<TArgument, TResult> visitor, TArgument argument);
 
    public string GetDocumentationCommentId()
        => null;
 
    public string GetDocumentationCommentXml(
        CultureInfo preferredCulture,
        bool expandIncludes,
        CancellationToken cancellationToken)
    {
        return _documentationCommentXml ?? "";
    }
 
    public string ToDisplayString(SymbolDisplayFormat format = null)
        => throw new NotImplementedException();
 
    public ImmutableArray<SymbolDisplayPart> ToDisplayParts(SymbolDisplayFormat format = null)
        => throw new NotImplementedException();
 
    public string ToMinimalDisplayString(SemanticModel semanticModel, int position, SymbolDisplayFormat format = null)
        => throw new NotImplementedException();
 
    public ImmutableArray<SymbolDisplayPart> ToMinimalDisplayParts(SemanticModel semanticModel, int position, SymbolDisplayFormat format = null)
        => throw new NotImplementedException();
 
    public virtual string MetadataName
    {
        get
        {
            return this.Name;
        }
    }
 
    public int MetadataToken => 0;
 
    public bool HasUnsupportedMetadata => false;
 
    public bool Equals(ISymbol other)
        => this.Equals((object)other);
 
    public bool Equals(ISymbol other, SymbolEqualityComparer equalityComparer)
        => this.Equals(other);
}