// 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.
 
namespace Roslyn.LanguageServer.Protocol;
 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text.Json.Serialization;
using Roslyn.Utilities;
 
/// <summary>
/// Class representing information about programming constructs like variables, classes, interfaces, etc.
/// <para>
/// See the <see href="https://microsoft.github.io/language-server-protocol/specifications/specification-current/#symbolInformation">Language Server Protocol specification</see> for additional information.
/// </para>
/// </summary>
internal class SymbolInformation : IEquatable<SymbolInformation>
{
 
    // Code has to reference SymbolInformation in a SumType even if it's not using the class itself.
    // This means that if we deprecate the type itself, referencing code would have to suppress
    // deprecation  warnings even if they are only using non-deprecated types. We work around
    // by deprecating the members instead of the type itself.
    const string DeprecationMessage = "The SymbolInformation class is deprecated. Use DocumentSymbol or WorkspaceSymbol instead.";
 
    /// <summary>
    /// Gets or sets the name of this symbol.
    /// </summary>
    [JsonPropertyName("name")]
    [Obsolete(DeprecationMessage)]
    public string Name
    {
        get;
        set;
    }
 
    /// <summary>
    /// Gets or sets the <see cref="SymbolKind"/> of this symbol.
    /// </summary>
    [JsonPropertyName("kind")]
    [Obsolete(DeprecationMessage)]
    public SymbolKind Kind
    {
        get;
        set;
    }
 
    /// <summary>
    /// Tags for this document symbol.
    /// </summary>
    /// <remarks>Since 3.16</remarks>
    [JsonPropertyName("tags")]
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [Obsolete(DeprecationMessage)]
    public SymbolTag[]? Tags { get; init; }
 
    /// <summary>
    /// Indicates whether this symbol is deprecated.
    /// </summary>
    [JsonPropertyName("deprecated")]
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingDefault)]
    [Obsolete("Use the Tags property instead")]
    public bool Deprecated { get; init; }
 
    /// <summary>
    /// The location of this symbol, used by a tool to reveal the location in the editor.
    /// <para>
    /// If the symbol is selected in the tool the range's start information is used to
    /// position the cursor. So the range usually spans more then the actual symbol's
    /// name and does normally include things like visibility modifiers.
    /// </para>
    /// <para>
    /// The range doesn't have to denote a node range in the sense of an abstract
    /// syntax tree. It can therefore not be used to re-construct a hierarchy of
    /// the symbols.
    /// </para>
    /// </summary>
    [JsonPropertyName("location")]
    [Obsolete(DeprecationMessage)]
    public Location Location
    {
        get;
        set;
    }
 
    /// <summary>
    /// <para>
    /// The name of the symbol containing this symbol.
    /// </para>
    /// This information is for user interface purposes (e.g. to render a qualifier in
    /// the user interface if necessary). It can't be used to re-infer a hierarchy for
    /// the document symbols.
    /// </summary>
    [JsonPropertyName("containerName")]
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    [Obsolete(DeprecationMessage)]
    public string? ContainerName
    {
        get;
        set;
    }
 
    /// <inheritdoc/>
    public override bool Equals(object obj)
    {
        return this.Equals(obj as SymbolInformation);
    }
 
    /// <inheritdoc/>
    public bool Equals(SymbolInformation? other)
    {
#pragma warning disable CS0618 // Type or member is obsolete
        return other != null
            && this.Name == other.Name
            && this.Kind == other.Kind
            && (this.Tags == null
                    ? other.Tags == null
                    : (this.Tags.Equals(other.Tags) || this.Tags.SequenceEqual(other.Tags)))
            && this.Deprecated == other.Deprecated
            && EqualityComparer<Location>.Default.Equals(this.Location, other.Location)
            && this.ContainerName == other.ContainerName;
#pragma warning restore CS0618
    }
 
    /// <inheritdoc/>
    public override int GetHashCode() =>
#pragma warning disable CS0618 // Type or member is obsolete
#if NET
        HashCode.Combine(Name, Kind, Hash.CombineValues(Tags), Deprecated, Location, ContainerName);
#else
        Hash.Combine(Name,
        Hash.Combine((int)Kind,
        Hash.Combine(Hash.CombineValues(Tags),
        Hash.Combine(Deprecated,
        Hash.Combine(ContainerName, Location?.GetHashCode() ?? 0)))));
#endif
#pragma warning restore CS0618
}