// 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.Collections.Immutable;
using Microsoft.CodeAnalysis.Tags;
 
namespace Microsoft.CodeAnalysis;
 
internal static class GlyphExtensions
{
    public static ImmutableArray<Glyph> GetGlyphs(this ImmutableArray<string> tags)
    {
        var builder = ImmutableArray.CreateBuilder<Glyph>(initialCapacity: tags.Length);
 
        foreach (var tag in tags)
        {
            var glyph = GetGlyph(tag, tags);
            if (glyph != Glyph.None)
            {
                builder.Add(glyph);
            }
        }
 
        return builder.ToImmutable();
    }
 
    public static Glyph GetFirstGlyph(this ImmutableArray<string> tags)
    {
        var glyphs = GetGlyphs(tags);
 
        return !glyphs.IsEmpty
            ? glyphs[0]
            : Glyph.None;
    }
 
    private static Glyph GetGlyph(string tag, ImmutableArray<string> allTags)
    {
        switch (tag)
        {
            case WellKnownTags.Assembly:
                return Glyph.Assembly;
 
            case WellKnownTags.File:
                return allTags.Contains(LanguageNames.VisualBasic) ? Glyph.BasicFile : Glyph.CSharpFile;
 
            case WellKnownTags.Project:
                return allTags.Contains(LanguageNames.VisualBasic) ? Glyph.BasicProject : Glyph.CSharpProject;
 
            case WellKnownTags.Class:
                return (GetAccessibility(allTags)) switch
                {
                    Accessibility.Protected => Glyph.ClassProtected,
                    Accessibility.Private => Glyph.ClassPrivate,
                    Accessibility.Internal => Glyph.ClassInternal,
                    _ => Glyph.ClassPublic,
                };
            case WellKnownTags.Constant:
                return (GetAccessibility(allTags)) switch
                {
                    Accessibility.Protected => Glyph.ConstantProtected,
                    Accessibility.Private => Glyph.ConstantPrivate,
                    Accessibility.Internal => Glyph.ConstantInternal,
                    _ => Glyph.ConstantPublic,
                };
            case WellKnownTags.Delegate:
                return (GetAccessibility(allTags)) switch
                {
                    Accessibility.Protected => Glyph.DelegateProtected,
                    Accessibility.Private => Glyph.DelegatePrivate,
                    Accessibility.Internal => Glyph.DelegateInternal,
                    _ => Glyph.DelegatePublic,
                };
            case WellKnownTags.Enum:
                return (GetAccessibility(allTags)) switch
                {
                    Accessibility.Protected => Glyph.EnumProtected,
                    Accessibility.Private => Glyph.EnumPrivate,
                    Accessibility.Internal => Glyph.EnumInternal,
                    _ => Glyph.EnumPublic,
                };
            case WellKnownTags.EnumMember:
                return (GetAccessibility(allTags)) switch
                {
                    Accessibility.Protected => Glyph.EnumMemberProtected,
                    Accessibility.Private => Glyph.EnumMemberPrivate,
                    Accessibility.Internal => Glyph.EnumMemberInternal,
                    _ => Glyph.EnumMemberPublic,
                };
            case WellKnownTags.Error:
                return Glyph.Error;
 
            case WellKnownTags.Event:
                return (GetAccessibility(allTags)) switch
                {
                    Accessibility.Protected => Glyph.EventProtected,
                    Accessibility.Private => Glyph.EventPrivate,
                    Accessibility.Internal => Glyph.EventInternal,
                    _ => Glyph.EventPublic,
                };
            case WellKnownTags.ExtensionMethod:
                return (GetAccessibility(allTags)) switch
                {
                    Accessibility.Protected => Glyph.ExtensionMethodProtected,
                    Accessibility.Private => Glyph.ExtensionMethodPrivate,
                    Accessibility.Internal => Glyph.ExtensionMethodInternal,
                    _ => Glyph.ExtensionMethodPublic,
                };
            case WellKnownTags.Field:
                return (GetAccessibility(allTags)) switch
                {
                    Accessibility.Protected => Glyph.FieldProtected,
                    Accessibility.Private => Glyph.FieldPrivate,
                    Accessibility.Internal => Glyph.FieldInternal,
                    _ => Glyph.FieldPublic,
                };
            case WellKnownTags.Interface:
                return (GetAccessibility(allTags)) switch
                {
                    Accessibility.Protected => Glyph.InterfaceProtected,
                    Accessibility.Private => Glyph.InterfacePrivate,
                    Accessibility.Internal => Glyph.InterfaceInternal,
                    _ => Glyph.InterfacePublic,
                };
            case WellKnownTags.TargetTypeMatch:
                return Glyph.TargetTypeMatch;
 
            case WellKnownTags.Intrinsic:
                return Glyph.Intrinsic;
 
            case WellKnownTags.Keyword:
                return Glyph.Keyword;
 
            case WellKnownTags.Label:
                return Glyph.Label;
 
            case WellKnownTags.Local:
                return Glyph.Local;
 
            case WellKnownTags.Namespace:
                return Glyph.Namespace;
 
            case WellKnownTags.Method:
                return (GetAccessibility(allTags)) switch
                {
                    Accessibility.Protected => Glyph.MethodProtected,
                    Accessibility.Private => Glyph.MethodPrivate,
                    Accessibility.Internal => Glyph.MethodInternal,
                    _ => Glyph.MethodPublic,
                };
            case WellKnownTags.Module:
                return (GetAccessibility(allTags)) switch
                {
                    Accessibility.Protected => Glyph.ModulePublic,
                    Accessibility.Private => Glyph.ModulePrivate,
                    Accessibility.Internal => Glyph.ModuleInternal,
                    _ => Glyph.ModulePublic,
                };
            case WellKnownTags.Folder:
                return Glyph.OpenFolder;
 
            case WellKnownTags.Operator:
                return Glyph.Operator;
 
            case WellKnownTags.Parameter:
                return Glyph.Parameter;
 
            case WellKnownTags.Property:
                return (GetAccessibility(allTags)) switch
                {
                    Accessibility.Protected => Glyph.PropertyProtected,
                    Accessibility.Private => Glyph.PropertyPrivate,
                    Accessibility.Internal => Glyph.PropertyInternal,
                    _ => Glyph.PropertyPublic,
                };
            case WellKnownTags.RangeVariable:
                return Glyph.RangeVariable;
 
            case WellKnownTags.Reference:
                return Glyph.Reference;
 
            case WellKnownTags.NuGet:
                return Glyph.NuGet;
 
            case WellKnownTags.Structure:
                return (GetAccessibility(allTags)) switch
                {
                    Accessibility.Protected => Glyph.StructureProtected,
                    Accessibility.Private => Glyph.StructurePrivate,
                    Accessibility.Internal => Glyph.StructureInternal,
                    _ => Glyph.StructurePublic,
                };
            case WellKnownTags.TypeParameter:
                return Glyph.TypeParameter;
 
            case WellKnownTags.Snippet:
                return Glyph.Snippet;
 
            case WellKnownTags.Warning:
                return Glyph.CompletionWarning;
 
            case WellKnownTags.StatusInformation:
                return Glyph.StatusInformation;
        }
 
        return Glyph.None;
    }
 
    public static Accessibility GetAccessibility(ImmutableArray<string> tags)
    {
        foreach (var tag in tags)
        {
            switch (tag)
            {
                case WellKnownTags.Public:
                    return Accessibility.Public;
                case WellKnownTags.Protected:
                    return Accessibility.Protected;
                case WellKnownTags.Internal:
                    return Accessibility.Internal;
                case WellKnownTags.Private:
                    return Accessibility.Private;
            }
        }
 
        return Accessibility.NotApplicable;
    }
}