// 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.Text;
using Microsoft.CodeAnalysis;
using Microsoft.VisualStudio.LanguageServices.Implementation.ProjectSystem;
using Microsoft.VisualStudio.LanguageServices.Implementation.Venus;
using Microsoft.VisualStudio.Shell;
using Microsoft.VisualStudio.Shell.Interop;
 
namespace Microsoft.VisualStudio.LanguageServices.Implementation.Library.ObjectBrowser;
 
internal static class Extensions
{
    private static readonly SymbolDisplayFormat s_typeDisplayFormat = new(
        typeQualificationStyle: SymbolDisplayTypeQualificationStyle.NameAndContainingTypes,
        genericsOptions: SymbolDisplayGenericsOptions.IncludeTypeParameters | SymbolDisplayGenericsOptions.IncludeVariance);
 
    private static readonly SymbolDisplayFormat s_memberDisplayFormat = new(
        typeQualificationStyle: SymbolDisplayTypeQualificationStyle.NameAndContainingTypesAndNamespaces,
        genericsOptions: SymbolDisplayGenericsOptions.IncludeTypeParameters | SymbolDisplayGenericsOptions.IncludeVariance,
        memberOptions: SymbolDisplayMemberOptions.IncludeExplicitInterface | SymbolDisplayMemberOptions.IncludeParameters,
        parameterOptions: SymbolDisplayParameterOptions.IncludeType,
        miscellaneousOptions: SymbolDisplayMiscellaneousOptions.UseSpecialTypes);
 
    public static string GetMemberNavInfoNameOrEmpty(this ISymbol memberSymbol)
    {
        return memberSymbol != null
            ? memberSymbol.ToDisplayString(s_memberDisplayFormat)
            : string.Empty;
    }
 
    public static string GetNamespaceNavInfoNameOrEmpty(this INamespaceSymbol namespaceSymbol)
    {
        if (namespaceSymbol == null)
        {
            return string.Empty;
        }
 
        return !namespaceSymbol.IsGlobalNamespace
            ? namespaceSymbol.ToDisplayString()
            : string.Empty;
    }
 
    public static string GetTypeNavInfoNameOrEmpty(this ITypeSymbol typeSymbol)
    {
        return typeSymbol != null
            ? typeSymbol.ToDisplayString(s_typeDisplayFormat)
            : string.Empty;
    }
 
    public static string GetProjectDisplayName(this Project project)
    {
        // If the project name is unambiguous within the solution, use that name. Otherwise, use the unique name
        // provided by IVsSolution3.GetUniqueUINameOfProject. This covers all cases except for a single solution
        // with two or more multi-targeted projects with the same name and same targets.
        //
        // https://github.com/dotnet/roslyn/pull/43800
        // http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/949113
 
        if (IsUnambiguousProjectNameInSolution(project))
        {
            return project.Name;
        }
        else if (project.Solution.Workspace is VisualStudioWorkspace workspace
            && workspace.GetHierarchy(project.Id) is { } hierarchy
            && (IVsSolution3)ServiceProvider.GlobalProvider.GetService(typeof(SVsSolution)) is { } solution)
        {
            if (ErrorHandler.Succeeded(solution.GetUniqueUINameOfProject(hierarchy, out var name)) && name != null)
            {
                return name;
            }
        }
 
        return project.Name;
 
        // Local functions
        static bool IsUnambiguousProjectNameInSolution(Project project)
        {
            foreach (var other in project.Solution.Projects)
            {
                if (other.Id == project.Id)
                    continue;
 
                if (other.Name == project.Name)
                {
                    // Another project with the same name was found in the solution. This project name is _not_
                    // unambiguous.
                    return false;
                }
            }
 
            return true;
        }
    }
 
    public static bool IsVenus(this Project project)
    {
        if (project.Solution.Workspace is not VisualStudioWorkspaceImpl)
        {
            return false;
        }
 
        foreach (var documentId in project.DocumentIds)
        {
            if (ContainedDocument.TryGetContainedDocument(documentId) != null)
            {
                return true;
            }
        }
 
        return false;
    }
 
    /// <summary>
    /// Returns a display name for the given project, walking its parent IVsHierarchy chain and
    /// pre-pending the names of parenting hierarchies (except the solution).
    /// </summary>
    public static string GetProjectNavInfoName(this Project project)
    {
        var result = project.Name;
 
        if (project.Solution.Workspace is not VisualStudioWorkspace workspace)
        {
            return result;
        }
 
        var hierarchy = workspace.GetHierarchy(project.Id);
        if (hierarchy == null)
        {
            return result;
        }
 
        if (!hierarchy.TryGetName(out result))
        {
            return result;
        }
 
        if (hierarchy.TryGetParentHierarchy(out var parentHierarchy) && !(parentHierarchy is IVsSolution))
        {
            var builder = new StringBuilder(result);
 
            while (parentHierarchy is not null and not IVsSolution)
            {
                if (parentHierarchy.TryGetName(out var parentName))
                {
                    builder.Insert(0, parentName + "\\");
                }
 
                if (!parentHierarchy.TryGetParentHierarchy(out parentHierarchy))
                {
                    break;
                }
            }
 
            result = builder.ToString();
        }
 
        return result;
    }
}