// 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.Collections.Immutable;
using System.Windows.Documents;
using System.Windows.Media;
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.Classification;
using Microsoft.CodeAnalysis.Editor.Shared.Extensions;
using Microsoft.CodeAnalysis.Editor.Shared.Utilities;
using Microsoft.CodeAnalysis.Shared.Extensions;
using Microsoft.CodeAnalysis.Text;
using Microsoft.VisualStudio.Language.Intellisense;
using Microsoft.VisualStudio.LanguageServices.Implementation.Utilities;
 
namespace Microsoft.VisualStudio.LanguageServices.ValueTracking;
 
internal abstract class TreeItemViewModel : TreeViewItemBase
{
    private readonly SourceText _sourceText;
    private readonly Glyph _glyph;
    private readonly IGlyphService _glyphService;
 
    protected ValueTrackingTreeViewModel TreeViewModel { get; }
    protected TextSpan TextSpan { get; }
    protected LineSpan LineSpan { get; }
    protected IThreadingContext ThreadingContext { get; }
    protected DocumentId DocumentId { get; }
    protected Workspace Workspace { get; }
 
    public int LineNumber => LineSpan.Start + 1; // LineSpan is 0 indexed, editors are not
 
    public string FileName { get; }
 
    public ImageSource GlyphImage => _glyph.GetImageSource(_glyphService);
    public bool ShowGlyph => !IsLoading;
 
    public ImmutableArray<ClassifiedSpan> ClassifiedSpans { get; }
 
    public ImmutableArray<Inline> Inlines => CalculateInlines();
    public override string AutomationName => _sourceText.ToString(TextSpan);
 
    protected TreeItemViewModel(
        TextSpan textSpan,
        SourceText sourceText,
        DocumentId documentId,
        string fileName,
        Glyph glyph,
        ImmutableArray<ClassifiedSpan> classifiedSpans,
        ValueTrackingTreeViewModel treeViewModel,
        IGlyphService glyphService,
        IThreadingContext threadingContext,
        Workspace workspace,
        ImmutableArray<TreeItemViewModel> children)
    {
        FileName = fileName;
        TextSpan = textSpan;
        _sourceText = sourceText;
        ClassifiedSpans = classifiedSpans;
        TreeViewModel = treeViewModel;
        ThreadingContext = threadingContext;
 
        _glyph = glyph;
        _glyphService = glyphService;
        Workspace = workspace;
        DocumentId = documentId;
 
        if (!children.IsDefaultOrEmpty)
        {
            foreach (var child in children)
            {
                ChildItems.Add(child);
            }
        }
 
        sourceText.GetLineAndOffset(textSpan.Start, out var lineStart, out var _);
        sourceText.GetLineAndOffset(textSpan.End, out var lineEnd, out var _);
        LineSpan = LineSpan.FromBounds(lineStart, lineEnd);
 
        PropertyChanged += (s, e) =>
        {
            if (e.PropertyName == nameof(IsLoading))
            {
                NotifyPropertyChanged(nameof(ShowGlyph));
            }
        };
 
        TreeViewModel.PropertyChanged += (s, e) =>
        {
            if (e.PropertyName == nameof(TreeViewModel.HighlightBrush))
            {
                // If the highlight changes we need to recalculate the inlines so the 
                // highlighting is correct
                NotifyPropertyChanged(nameof(Inlines));
            }
        };
    }
 
    public abstract void NavigateTo();
 
    private ImmutableArray<Inline> CalculateInlines()
    {
        if (ClassifiedSpans.IsDefaultOrEmpty)
        {
            return ImmutableArray<Inline>.Empty;
        }
 
        var classifiedTexts = ClassifiedSpans.SelectAsArray(
           cs =>
           {
               return new ClassifiedText(cs.ClassificationType, _sourceText.ToString(cs.TextSpan));
           });
 
        var spanStartPosition = TextSpan.Start - ClassifiedSpans[0].TextSpan.Start;
        var highlightSpan = new TextSpan(spanStartPosition, TextSpan.Length);
 
        return classifiedTexts.ToInlines(
            TreeViewModel.ClassificationFormatMap,
            TreeViewModel.ClassificationTypeMap,
            (run, classifiedText, position) =>
            {
                if (TreeViewModel.HighlightBrush is not null)
                {
                    // Check the span start first because we always want to highlight a run that 
                    // is at the start, even if the TextSpan length is 0. If it's not the start,
                    // highlighting should still happen if the run position is contained within
                    // the span.
                    if (position == highlightSpan.Start || highlightSpan.Contains(position))
                    {
                        run.SetValue(
                            TextElement.BackgroundProperty,
                            TreeViewModel.HighlightBrush);
                    }
                }
            }).ToImmutableArray();
    }
}