// 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.
 
using System;
using System.Collections.Immutable;
using System.Composition;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.CodeAnalysis.Host.Mef;
using Microsoft.CodeAnalysis.InlineHints;
using Microsoft.CodeAnalysis.Options;
using Microsoft.CodeAnalysis.PooledObjects;
using Microsoft.CodeAnalysis.Shared.Extensions;
using Roslyn.LanguageServer.Protocol;
using LSP = Roslyn.LanguageServer.Protocol;
 
namespace Microsoft.CodeAnalysis.LanguageServer.Handler.InlayHint
{
    [ExportCSharpVisualBasicStatelessLspService(typeof(InlayHintHandler)), Shared]
    [Method(Methods.TextDocumentInlayHintName)]
    internal sealed class InlayHintHandler : ILspServiceDocumentRequestHandler<InlayHintParams, LSP.InlayHint[]?>
    {
        private readonly IGlobalOptionService _optionsService;
 
        [ImportingConstructor]
        [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
        public InlayHintHandler(IGlobalOptionService optionsService)
        {
            _optionsService = optionsService;
        }
 
        public bool MutatesSolutionState => false;
 
        public bool RequiresLSPSolution => true;
 
        public TextDocumentIdentifier GetTextDocumentIdentifier(InlayHintParams request)
            => request.TextDocument;
 
        public Task<LSP.InlayHint[]?> HandleRequestAsync(InlayHintParams request, RequestContext context, CancellationToken cancellationToken)
        {
            var document = context.GetRequiredDocument();
            var inlayHintCache = context.GetRequiredLspService<InlayHintCache>();
            var options = _optionsService.GetInlineHintsOptions(document.Project.Language);
 
            return GetInlayHintsAsync(document, request.TextDocument, request.Range, options, displayAllOverride: false, inlayHintCache, cancellationToken);
        }
 
        internal static async Task<LSP.InlayHint[]?> GetInlayHintsAsync(Document document, TextDocumentIdentifier textDocumentIdentifier, LSP.Range range, InlineHintsOptions options, bool displayAllOverride, InlayHintCache inlayHintCache, CancellationToken cancellationToken)
        {
            var text = await document.GetValueTextAsync(cancellationToken).ConfigureAwait(false);
            var hints = await CalculateInlayHintsAsync(document, range, options, displayAllOverride, cancellationToken).ConfigureAwait(false);
            var syntaxVersion = await document.GetSyntaxVersionAsync(cancellationToken).ConfigureAwait(false);
 
            // Store the members in the resolve cache so that when we get a resolve request for a particular
            // member we can re-use the inline hint.
            var resultId = inlayHintCache.UpdateCache(new InlayHintCache.InlayHintCacheEntry(hints));
 
            var inlayHints = new LSP.InlayHint[hints.Length];
            for (var i = 0; i < hints.Length; i++)
            {
                var hint = hints[i];
                var (label, leftPadding, rightPadding) = Trim(hint.DisplayParts);
                var linePosition = text.Lines.GetLinePosition(hint.Span.Start);
                var kind = hint.Ranking == InlineHintsConstants.ParameterRanking
                    ? InlayHintKind.Parameter
                    : InlayHintKind.Type;
 
                // TextChange is calculated at the same time as the InlineHint,
                // so it should not need to be resolved.
                TextEdit[]? textEdits = null;
                if (hint.ReplacementTextChange.HasValue)
                {
                    var textEdit = ProtocolConversions.TextChangeToTextEdit(hint.ReplacementTextChange.Value, text);
                    textEdits = [textEdit];
                }
 
                var inlayHint = new LSP.InlayHint
                {
                    Position = ProtocolConversions.LinePositionToPosition(linePosition),
                    Label = label,
                    Kind = kind,
                    TextEdits = textEdits,
                    ToolTip = null,
                    PaddingLeft = leftPadding,
                    PaddingRight = rightPadding,
                    Data = new InlayHintResolveData(resultId, i, textDocumentIdentifier, syntaxVersion.ToString(), range, displayAllOverride)
                };
 
                inlayHints[i] = inlayHint;
            }
 
            return inlayHints;
        }
 
        internal static async Task<ImmutableArray<InlineHint>> CalculateInlayHintsAsync(Document document, LSP.Range range, InlineHintsOptions options, bool displayAllOverride, CancellationToken cancellationToken)
        {
            var text = await document.GetValueTextAsync(cancellationToken).ConfigureAwait(false);
            var textSpan = ProtocolConversions.RangeToTextSpan(range, text);
 
            var inlineHintService = document.GetRequiredLanguageService<IInlineHintsService>();
            var hints = await inlineHintService.GetInlineHintsAsync(document, textSpan, options, displayAllOverride, cancellationToken).ConfigureAwait(false);
            return hints;
        }
 
        /// <summary>
        /// Goes through the tagged text of the hint and trims off leading and trailing spaces. 
        /// If there is leading or trailing space, then we want to add padding to the left and right accordingly.
        /// </summary>
        private static (string label, bool leftPadding, bool rightPadding) Trim(ImmutableArray<TaggedText> taggedTexts)
        {
            using var _ = ArrayBuilder<TaggedText>.GetInstance(out var result);
            var leftPadding = false;
            var rightPadding = false;
 
            if (taggedTexts.Length == 1)
            {
                var first = taggedTexts.First();
 
                var trimStart = first.Text.TrimStart();
                var trimBoth = trimStart.TrimEnd();
                result.Add(new TaggedText(first.Tag, trimBoth));
                leftPadding = first.Text.Length - trimStart.Length != 0;
                rightPadding = trimStart.Length - trimBoth.Length != 0;
            }
            else if (taggedTexts.Length >= 2)
            {
                var first = taggedTexts.First();
                var trimStart = first.Text.TrimStart();
                result.Add(new TaggedText(first.Tag, trimStart));
                leftPadding = first.Text.Length - trimStart.Length != 0;
 
                for (var i = 1; i < taggedTexts.Length - 1; i++)
                    result.Add(taggedTexts[i]);
 
                var last = taggedTexts.Last();
                var trimEnd = last.Text.TrimEnd();
                result.Add(new TaggedText(last.Tag, trimEnd));
                rightPadding = last.Text.Length - trimEnd.Length != 0;
            }
 
            return (result.ToImmutable().JoinText(), leftPadding, rightPadding);
        }
    }
}