// 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 System.Threading;
using System.Threading.Tasks;
using Microsoft.CodeAnalysis.Host;
using Microsoft.CodeAnalysis.Internal.Log;
using Microsoft.CodeAnalysis.Text;
using Roslyn.Utilities;
 
namespace Microsoft.CodeAnalysis;
 
public abstract partial class Workspace
{
    private readonly EventMap _eventMap = new();
 
    private const string WorkspaceChangeEventName = "WorkspaceChanged";
    private const string WorkspaceFailedEventName = "WorkspaceFailed";
    private const string DocumentOpenedEventName = "DocumentOpened";
    private const string DocumentClosedEventName = "DocumentClosed";
    private const string DocumentActiveContextChangedName = "DocumentActiveContextChanged";
    private const string TextDocumentOpenedEventName = "TextDocumentOpened";
    private const string TextDocumentClosedEventName = "TextDocumentClosed";
 
    /// <summary>
    /// An event raised whenever the current solution is changed.
    /// </summary>
    public event EventHandler<WorkspaceChangeEventArgs> WorkspaceChanged
    {
        add
        {
            _eventMap.AddEventHandler(WorkspaceChangeEventName, value);
        }
 
        remove
        {
            _eventMap.RemoveEventHandler(WorkspaceChangeEventName, value);
        }
    }
 
    protected Task RaiseWorkspaceChangedEventAsync(WorkspaceChangeKind kind, Solution oldSolution, Solution newSolution, ProjectId projectId = null, DocumentId documentId = null)
    {
        if (newSolution == null)
        {
            throw new ArgumentNullException(nameof(newSolution));
        }
 
        if (oldSolution == newSolution)
        {
            return Task.CompletedTask;
        }
 
        if (projectId == null && documentId != null)
        {
            projectId = documentId.ProjectId;
        }
 
        var ev = GetEventHandlers<WorkspaceChangeEventArgs>(WorkspaceChangeEventName);
        if (ev.HasHandlers)
        {
            return this.ScheduleTask(() =>
            {
                using (Logger.LogBlock(FunctionId.Workspace_Events, (s, p, d, k) => $"{s.Id} - {p} - {d} {kind.ToString()}", newSolution, projectId, documentId, kind, CancellationToken.None))
                {
                    var args = new WorkspaceChangeEventArgs(kind, oldSolution, newSolution, projectId, documentId);
                    ev.RaiseEvent(static (handler, arg) => handler(arg.self, arg.args), (self: this, args));
                }
            }, WorkspaceChangeEventName);
        }
        else
        {
            return Task.CompletedTask;
        }
    }
 
    /// <summary>
    /// An event raised whenever the workspace or part of its solution model
    /// fails to access a file or other external resource.
    /// </summary>
    public event EventHandler<WorkspaceDiagnosticEventArgs> WorkspaceFailed
    {
        add
        {
            _eventMap.AddEventHandler(WorkspaceFailedEventName, value);
        }
 
        remove
        {
            _eventMap.RemoveEventHandler(WorkspaceFailedEventName, value);
        }
    }
 
    protected internal virtual void OnWorkspaceFailed(WorkspaceDiagnostic diagnostic)
    {
        var ev = GetEventHandlers<WorkspaceDiagnosticEventArgs>(WorkspaceFailedEventName);
        if (ev.HasHandlers)
        {
            var args = new WorkspaceDiagnosticEventArgs(diagnostic);
            ev.RaiseEvent(static (handler, arg) => handler(arg.self, arg.args), (self: this, args));
        }
    }
 
    /// <summary>
    /// An event that is fired when a <see cref="Document"/> is opened in the editor.
    /// </summary>
    public event EventHandler<DocumentEventArgs> DocumentOpened
    {
        add
        {
            _eventMap.AddEventHandler(DocumentOpenedEventName, value);
        }
 
        remove
        {
            _eventMap.RemoveEventHandler(DocumentOpenedEventName, value);
        }
    }
 
    protected Task RaiseDocumentOpenedEventAsync(Document document)
        => RaiseTextDocumentOpenedOrClosedEventAsync(document, new DocumentEventArgs(document), DocumentOpenedEventName);
 
    /// <summary>
    /// An event that is fired when any <see cref="TextDocument"/> is opened in the editor.
    /// </summary>
    public event EventHandler<TextDocumentEventArgs> TextDocumentOpened
    {
        add
        {
            _eventMap.AddEventHandler(TextDocumentOpenedEventName, value);
        }
 
        remove
        {
            _eventMap.RemoveEventHandler(TextDocumentOpenedEventName, value);
        }
    }
 
    protected Task RaiseTextDocumentOpenedEventAsync(TextDocument document)
        => RaiseTextDocumentOpenedOrClosedEventAsync(document, new TextDocumentEventArgs(document), TextDocumentOpenedEventName);
 
    private Task RaiseTextDocumentOpenedOrClosedEventAsync<TDocument, TDocumentEventArgs>(
        TDocument document,
        TDocumentEventArgs args,
        string eventName)
        where TDocument : TextDocument
        where TDocumentEventArgs : EventArgs
    {
        var ev = GetEventHandlers<TDocumentEventArgs>(eventName);
        if (ev.HasHandlers && document != null)
        {
            return this.ScheduleTask(() =>
            {
                ev.RaiseEvent(static (handler, arg) => handler(arg.self, arg.args), (self: this, args));
            }, eventName);
        }
        else
        {
            return Task.CompletedTask;
        }
    }
 
    /// <summary>
    /// An event that is fired when a <see cref="Document"/> is closed in the editor.
    /// </summary>
    public event EventHandler<DocumentEventArgs> DocumentClosed
    {
        add
        {
            _eventMap.AddEventHandler(DocumentClosedEventName, value);
        }
 
        remove
        {
            _eventMap.RemoveEventHandler(DocumentClosedEventName, value);
        }
    }
 
    protected Task RaiseDocumentClosedEventAsync(Document document)
        => RaiseTextDocumentOpenedOrClosedEventAsync(document, new DocumentEventArgs(document), DocumentClosedEventName);
 
    /// <summary>
    /// An event that is fired when any <see cref="TextDocument"/> is closed in the editor.
    /// </summary>
    public event EventHandler<TextDocumentEventArgs> TextDocumentClosed
    {
        add
        {
            _eventMap.AddEventHandler(TextDocumentClosedEventName, value);
        }
 
        remove
        {
            _eventMap.RemoveEventHandler(TextDocumentClosedEventName, value);
        }
    }
 
    protected Task RaiseTextDocumentClosedEventAsync(TextDocument document)
        => RaiseTextDocumentOpenedOrClosedEventAsync(document, new TextDocumentEventArgs(document), TextDocumentClosedEventName);
 
    /// <summary>
    /// An event that is fired when the active context document associated with a buffer 
    /// changes.
    /// </summary>
    public event EventHandler<DocumentActiveContextChangedEventArgs> DocumentActiveContextChanged
    {
        add
        {
            _eventMap.AddEventHandler(DocumentActiveContextChangedName, value);
        }
 
        remove
        {
            _eventMap.RemoveEventHandler(DocumentActiveContextChangedName, value);
        }
    }
 
    [Obsolete("This member is obsolete. Use the RaiseDocumentActiveContextChangedEventAsync(SourceTextContainer, DocumentId, DocumentId) overload instead.", error: true)]
    protected Task RaiseDocumentActiveContextChangedEventAsync(Document document)
        => throw new NotImplementedException();
 
    protected Task RaiseDocumentActiveContextChangedEventAsync(SourceTextContainer sourceTextContainer, DocumentId oldActiveContextDocumentId, DocumentId newActiveContextDocumentId)
    {
        var ev = GetEventHandlers<DocumentActiveContextChangedEventArgs>(DocumentActiveContextChangedName);
        if (ev.HasHandlers && sourceTextContainer != null && oldActiveContextDocumentId != null && newActiveContextDocumentId != null)
        {
            // Capture the current solution snapshot (inside the _serializationLock of OnDocumentContextUpdated)
            var currentSolution = this.CurrentSolution;
 
            return this.ScheduleTask(() =>
            {
                var args = new DocumentActiveContextChangedEventArgs(currentSolution, sourceTextContainer, oldActiveContextDocumentId, newActiveContextDocumentId);
                ev.RaiseEvent(static (handler, arg) => handler(arg.self, arg.args), (self: this, args));
            }, "Workspace.WorkspaceChanged");
        }
        else
        {
            return Task.CompletedTask;
        }
    }
 
    private EventMap.EventHandlerSet<EventHandler<T>> GetEventHandlers<T>(string eventName) where T : EventArgs
    {
        // this will register features that want to listen to workspace events
        // lazily first time workspace event is actually fired
        EnsureEventListeners();
        return _eventMap.GetEventHandlers<EventHandler<T>>(eventName);
    }
 
    private void EnsureEventListeners()
    {
        this.Services.GetService<IWorkspaceEventListenerService>()?.EnsureListeners();
    }
}