// 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.Composition;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.CodeAnalysis.Host;
using Microsoft.CodeAnalysis.Host.Mef;
using Microsoft.CodeAnalysis.Options;
using Microsoft.CodeAnalysis.PooledObjects;
using Microsoft.CodeAnalysis.Shared.Extensions;
using Microsoft.CodeAnalysis.Structure;
using Microsoft.CodeAnalysis.Text;
using Roslyn.LanguageServer.Protocol;
using Roslyn.Utilities;
 
namespace Microsoft.CodeAnalysis.LanguageServer.Handler;
 
[ExportCSharpVisualBasicStatelessLspService(typeof(FoldingRangesHandler)), Shared]
[Method(Methods.TextDocumentFoldingRangeName)]
internal sealed class FoldingRangesHandler : ILspServiceDocumentRequestHandler<FoldingRangeParams, FoldingRange[]?>
{
    private readonly IGlobalOptionService _globalOptions;
 
    public bool MutatesSolutionState => false;
    public bool RequiresLSPSolution => true;
 
    [ImportingConstructor]
    [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
    public FoldingRangesHandler(IGlobalOptionService globalOptions)
    {
        _globalOptions = globalOptions;
    }
 
    public TextDocumentIdentifier GetTextDocumentIdentifier(FoldingRangeParams request) => request.TextDocument;
 
    public Task<FoldingRange[]?> HandleRequestAsync(FoldingRangeParams request, RequestContext context, CancellationToken cancellationToken)
    {
        var document = context.Document;
        if (document is null)
            return SpecializedTasks.Null<FoldingRange[]>();
 
        return SpecializedTasks.AsNullable(GetFoldingRangesAsync(_globalOptions, document, cancellationToken));
    }
 
    internal static Task<FoldingRange[]> GetFoldingRangesAsync(
        IGlobalOptionService globalOptions,
        Document document,
        CancellationToken cancellationToken)
    {
        var options = globalOptions.GetBlockStructureOptions(document.Project) with
        {
            // Need to set the block structure guide options to true since the concept does not exist in vscode
            // but we still want to categorize them as the correct BlockType.
            ShowBlockStructureGuidesForCommentsAndPreprocessorRegions = true,
            ShowBlockStructureGuidesForDeclarationLevelConstructs = true,
            ShowBlockStructureGuidesForCodeLevelConstructs = true
        };
 
        return GetFoldingRangesAsync(document, options, cancellationToken);
    }
 
    /// <summary>
    /// Used here and by lsif generator.
    /// </summary>
    public static async Task<FoldingRange[]> GetFoldingRangesAsync(
        Document document,
        BlockStructureOptions options,
        CancellationToken cancellationToken)
    {
        var blockStructureService = document.GetRequiredLanguageService<BlockStructureService>();
        var blockStructure = await blockStructureService.GetBlockStructureAsync(document, options, cancellationToken).ConfigureAwait(false);
        if (blockStructure == null)
            return [];
 
        var text = await document.GetValueTextAsync(cancellationToken).ConfigureAwait(false);
        return GetFoldingRanges(blockStructure, text);
    }
 
    private static FoldingRange[] GetFoldingRanges(BlockStructure blockStructure, SourceText text)
    {
        if (blockStructure.Spans.IsEmpty)
        {
            return [];
        }
 
        using var _ = ArrayBuilder<FoldingRange>.GetInstance(out var foldingRanges);
 
        foreach (var span in blockStructure.Spans)
        {
            if (!span.IsCollapsible)
            {
                continue;
            }
 
            var linePositionSpan = text.Lines.GetLinePositionSpan(span.TextSpan);
 
            // Filter out single line spans.
            if (linePositionSpan.Start.Line == linePositionSpan.End.Line)
            {
                continue;
            }
 
            // TODO - Figure out which blocks should be returned as a folding range (and what kind).
            // https://github.com/dotnet/roslyn/projects/45#card-20049168
            FoldingRangeKind? foldingRangeKind = span.Type switch
            {
                BlockTypes.Comment => FoldingRangeKind.Comment,
                BlockTypes.Imports => FoldingRangeKind.Imports,
                BlockTypes.PreprocessorRegion => FoldingRangeKind.Region,
                BlockTypes.Member => VSFoldingRangeKind.Implementation,
                _ => null,
            };
 
            foldingRanges.Add(new FoldingRange()
            {
                StartLine = linePositionSpan.Start.Line,
                StartCharacter = linePositionSpan.Start.Character,
                EndLine = linePositionSpan.End.Line,
                EndCharacter = linePositionSpan.End.Character,
                Kind = foldingRangeKind,
                CollapsedText = span.BannerText
            });
        }
 
        return foldingRanges.ToArray();
    }
}