// 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 System;
using Microsoft.CodeAnalysis.Editor.Shared.Utilities;
using Microsoft.CodeAnalysis.Shared.TestHooks;
using Microsoft.CodeAnalysis.Options;
using Microsoft.VisualStudio.Text;
using Microsoft.VisualStudio.Text.Editor;
using Roslyn.Utilities;
using Microsoft.CodeAnalysis.Editor.Shared.Extensions;
 
namespace Microsoft.CodeAnalysis.Editor.Implementation.IntelliSense
{
    internal abstract class AbstractController<TSession, TModel, TPresenterSession, TEditorSession> : IController<TModel>
        where TSession : class, ISession<TModel>
        where TPresenterSession : IIntelliSensePresenterSession
    {
        protected readonly IThreadingContext ThreadingContext;
        protected readonly IGlobalOptionService GlobalOptions;
        protected readonly ITextView TextView;
        protected readonly ITextBuffer SubjectBuffer;
        protected readonly IIntelliSensePresenter<TPresenterSession, TEditorSession> Presenter;
        protected readonly IDocumentProvider DocumentProvider;
 
        private readonly IAsynchronousOperationListener _asyncListener;
        private readonly string _asyncOperationId;
 
        // Null when we absolutely know we don't have any sort of item computation going on. Non
        // null the moment we think we start computing state. Null again once we decide we can
        // stop.
        protected TSession sessionOpt;
 
        protected bool IsSessionActive => sessionOpt != null;
 
        protected AbstractController(
            IGlobalOptionService globalOptions,
            IThreadingContext threadingContext,
            ITextView textView,
            ITextBuffer subjectBuffer,
            IIntelliSensePresenter<TPresenterSession, TEditorSession> presenter,
            IAsynchronousOperationListener asyncListener,
            IDocumentProvider documentProvider,
            string asyncOperationId)
        {
            this.GlobalOptions = globalOptions;
            ThreadingContext = threadingContext;
            this.TextView = textView;
            this.SubjectBuffer = subjectBuffer;
            this.Presenter = presenter;
            _asyncListener = asyncListener;
            this.DocumentProvider = documentProvider;
            _asyncOperationId = asyncOperationId;
 
            this.TextView.Closed += OnTextViewClosed;
 
            // Caret position changed only fires if the caret is explicitly moved.  It doesn't fire
            // when the caret is moved because of text change events.
            this.TextView.Caret.PositionChanged += this.OnCaretPositionChanged;
            this.TextView.TextBuffer.PostChanged += this.OnTextViewBufferPostChanged;
        }
 
        internal abstract void OnModelUpdated(TModel result, bool updateController);
        internal abstract void OnTextViewBufferPostChanged(object sender, EventArgs e);
        internal abstract void OnCaretPositionChanged(object sender, EventArgs e);
 
        private void OnTextViewClosed(object sender, EventArgs e)
        {
            this.ThreadingContext.ThrowIfNotOnUIThread();
            DismissSessionIfActive();
 
            this.TextView.Closed -= OnTextViewClosed;
            this.TextView.Caret.PositionChanged -= this.OnCaretPositionChanged;
            this.TextView.TextBuffer.PostChanged -= this.OnTextViewBufferPostChanged;
        }
 
        public TModel WaitForController()
        {
            this.ThreadingContext.ThrowIfNotOnUIThread();
            VerifySessionIsActive();
            return sessionOpt.WaitForController();
        }
 
        void IController<TModel>.OnModelUpdated(TModel result, bool updateController)
        {
            // This is only called from the model computation if it was not cancelled.  And if it was 
            // not cancelled then we must have a pointer to it (as well as the presenter session).
            this.ThreadingContext.ThrowIfNotOnUIThread();
            VerifySessionIsActive();
 
            this.OnModelUpdated(result, updateController);
        }
 
        IAsyncToken IController<TModel>.BeginAsyncOperation(string name, object tag, string filePath, int lineNumber)
        {
            this.ThreadingContext.ThrowIfNotOnUIThread();
            VerifySessionIsActive();
            name = String.IsNullOrEmpty(name)
                ? _asyncOperationId
                : $"{_asyncOperationId} - {name}";
            return _asyncListener.BeginAsyncOperation(name, tag, filePath: filePath, lineNumber: lineNumber);
        }
 
        protected void VerifySessionIsActive()
        {
            this.ThreadingContext.ThrowIfNotOnUIThread();
            Contract.ThrowIfFalse(IsSessionActive);
        }
 
        protected void VerifySessionIsInactive()
        {
            this.ThreadingContext.ThrowIfNotOnUIThread();
            Contract.ThrowIfTrue(IsSessionActive);
        }
 
        protected void DismissSessionIfActive()
        {
            this.ThreadingContext.ThrowIfNotOnUIThread();
            if (IsSessionActive)
            {
                this.StopModelComputation();
            }
        }
 
        public void StopModelComputation()
        {
            this.ThreadingContext.ThrowIfNotOnUIThread();
            VerifySessionIsActive();
 
            // Make a local copy so that we won't do anything that causes us to recurse and try to
            // dismiss this again.
            var localSession = sessionOpt;
            sessionOpt = null;
            localSession.Stop();
        }
 
        public bool TryHandleEscapeKey()
        {
            this.ThreadingContext.ThrowIfNotOnUIThread();
 
            // Escape simply dismissed a session if it's up. Otherwise let the next thing in the
            // chain handle us.
            if (!IsSessionActive)
            {
                return false;
            }
 
            // If we haven't even computed a model yet, then also send this command to anyone
            // listening.  It's unlikely that the command was intended for us (as we wouldn't
            // have even shown ui yet.
            var handledCommand = sessionOpt.InitialUnfilteredModel != null;
 
            // In the presence of an escape, we always stop what we're doing.
            this.StopModelComputation();
 
            return handledCommand;
        }
    }
}