using System.Collections.Immutable;
using Microsoft.CodeAnalysis;

namespace ExtractMethod.Tooling;

/// <summary>
/// Compact symbol display for the suggestion report. The defaults are wrong
/// for a report a human reads next to their own source:
/// - <c>ToDisplayString()</c> fully qualifies every namespace
///   (<c>System.Collections.Generic.List&lt;Widget&gt;</c>),
/// - <c>ToMinimalDisplayString()</c> keeps containing types AND prefixes
///   members with their own type (<c>int Demo._seed</c>).
/// The report wants the shortest form that stays readable in context:
/// types as bare names (<c>Widget</c>, <c>List&lt;Widget&gt;</c>), members as
/// <c>ContainingType.Member</c> with parameter types.
/// </summary>
internal static class Displays
{
    /// <summary>
    /// Type display for suggestion lines: shortest unambiguous-enough form
    /// (no namespaces, no containing types, keyword spellings for special
    /// types, nullable annotations kept). Built explicitly because
    /// MinimallyQualifiedFormat keeps containing types for nested types
    /// (<c>Demo.Widget</c>) and has no With-style override here.
    /// </summary>
    internal static readonly SymbolDisplayFormat TypeFormat = new(
        globalNamespaceStyle: SymbolDisplayGlobalNamespaceStyle.Omitted,
        typeQualificationStyle: SymbolDisplayTypeQualificationStyle.NameOnly,
        genericsOptions: SymbolDisplayGenericsOptions.IncludeTypeParameters
            | SymbolDisplayGenericsOptions.IncludeVariance,
        miscellaneousOptions: SymbolDisplayMiscellaneousOptions.UseSpecialTypes
            | SymbolDisplayMiscellaneousOptions.EscapeKeywordIdentifiers
            | SymbolDisplayMiscellaneousOptions.IncludeNullableReferenceTypeModifier);

    /// <summary>Compact member display for extract-first entries:
    /// <c>Demo._seed</c>, <c>Demo.Scale</c>, <c>Widget.Bigger(Widget)</c>,
    /// <c>List&lt;Widget&gt;.this[int]</c>.</summary>
    internal static string Member(ISymbol symbol) => symbol switch
    {
        IMethodSymbol method =>
            $"{Type(method.ContainingType)}.{method.Name}({Parameters(method.Parameters)})",
        IPropertySymbol { IsIndexer: true } indexer =>
            $"{Type(indexer.ContainingType)}.this[{Parameters(indexer.Parameters)}]",
        IFieldSymbol or IPropertySymbol or IEventSymbol =>
            $"{Type(symbol.ContainingType)}.{symbol.Name}",
        _ => symbol.ToDisplayString(TypeFormat),
    };

    private static string Parameters(ImmutableArray<IParameterSymbol> parameters)
        => string.Join(", ", parameters.Select(p => Type(p.Type)));

    private static string Type(ITypeSymbol? type) => type?.ToDisplayString(TypeFormat) ?? "?";
}