// 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 Microsoft.VisualStudio.Text;
 
namespace Microsoft.VisualStudio.LanguageServices.Implementation
{
    internal class ReiteratedVersionSnapshotTracker
    {
        /// <summary>
        /// tracking text buffer
        /// </summary>
        private ITextBuffer _trackingBuffer;
 
        /// <summary>
        /// hold onto latest ReiteratedVersionNumber snapshot of a textbuffer
        /// there is a bug where many of our features just assume that if they wait, they will end up get the latest snapshot in some ways. 
        /// but, unfortunately that is actually not true. they will, at the end, get latest reiterated version snapshot but 
        /// not the latest version snapshot since we might have skipped/swallowed the latest snapshot since its content didn't change.
        /// this is especially unfortunate for features that want to move back and forth between source text and ITextSnapshot since holding
        /// on the latest snapshot won't guarantee that. so, in VS, we hold onto right latest snapshot in VS workspace so that all feature under it
        /// doesn't need to worry about it.
        /// this could be moved down to workspace_editor if it actually move up to editor layer. 
        /// but for now, I am putting it here. we can think about moving it down to workspace_editor later.
        /// </summary>
        private ITextSnapshot _latestReiteratedVersionSnapshot;
 
        public ReiteratedVersionSnapshotTracker(ITextBuffer buffer)
        {
            if (buffer != null)
            {
                StartTracking(buffer);
            }
        }
 
        public void StartTracking(ITextBuffer buffer)
        {
            // buffer has changed. stop tracking old buffer
            if (_trackingBuffer != null && buffer != _trackingBuffer)
            {
                _trackingBuffer.ChangedHighPriority -= OnTextBufferChanged;
 
                _trackingBuffer = null;
                _latestReiteratedVersionSnapshot = null;
            }
 
            // start tracking new buffer
            if (buffer != null && _latestReiteratedVersionSnapshot == null)
            {
                _latestReiteratedVersionSnapshot = buffer.CurrentSnapshot;
                _trackingBuffer = buffer;
 
                buffer.ChangedHighPriority += OnTextBufferChanged;
            }
        }
 
        public void StopTracking(ITextBuffer buffer)
        {
            if (_trackingBuffer == buffer && buffer != null && _latestReiteratedVersionSnapshot != null)
            {
                buffer.ChangedHighPriority -= OnTextBufferChanged;
 
                _trackingBuffer = null;
                _latestReiteratedVersionSnapshot = null;
            }
        }
 
        private void OnTextBufferChanged(object sender, TextContentChangedEventArgs e)
        {
            if (sender is ITextBuffer)
            {
                var snapshot = _latestReiteratedVersionSnapshot;
                if (snapshot != null && snapshot.Version != null && e.AfterVersion != null &&
                    snapshot.Version.ReiteratedVersionNumber < e.AfterVersion.ReiteratedVersionNumber)
                {
                    _latestReiteratedVersionSnapshot = e.After;
                }
            }
        }
    }
}