// 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.Diagnostics;
using System.Diagnostics.Tracing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace Microsoft.CodeAnalysis.Internal.Log
{
    /// <summary>
    /// This EventSource exposes our events to ETW.
    /// RoslynEventSource GUID is {bf965e67-c7fb-5c5b-d98f-cdf68f8154c2}.
    /// 
    /// When updating this class, use the following to also update Main\Source\Test\Performance\Log\RoslynEventSourceParser.cs:
    /// Main\Tools\Source\TraceParserGen\bin\Debug\TraceParserGen.exe Microsoft.CodeAnalysis.Workspaces.dll -eventsource:RoslynEventSource
    /// 
    /// Use this command to register the ETW manifest on any machine where you need to decode events in xperf/etlstackbrowse:
    /// "\\clrmain\tools\managed\etw\eventRegister\bin\Debug\eventRegister.exe" Microsoft.CodeAnalysis.Workspaces.dll
    /// </summary>
    [EventSource(Name = "RoslynEventSource")]
    internal sealed partial class RoslynEventSource : EventSource
    {
        // might not "enabled" but we always have this singleton alive
        public static readonly RoslynEventSource Instance = new();
 
        private readonly bool _initialized;
        private RoslynEventSource()
            => _initialized = true;
 
        // Do not change the parameter order for this method: it must match the parameter order
        // for WriteEvent() that's being invoked inside it. This is necessary because the ETW schema
        // generation process will reflect over WriteRoslynEvent() to determine how to pack event
        // data. If the orders are different, the generated schema will be wrong, and any perf
        // tools will deserialize event data fields in the wrong order.
        //
        // The WriteEvent overloads are optimized for either:
        //     Up to 3 integer parameters
        //     1 string and up to 2 integer parameters
        // There's also a params object[] overload that is much slower and should be avoided
        [Event(1)]
        public void Log(string message, FunctionId functionId)
            => WriteEvent(1, message ?? string.Empty, (int)functionId);
 
        [Event(2)]
        public void BlockStart(string message, FunctionId functionId, int blockId)
            => WriteEvent(2, message ?? string.Empty, (int)functionId, blockId);
 
        [Event(3)]
        public void BlockStop(FunctionId functionId, int tick, int blockId)
            => WriteEvent(3, (int)functionId, tick, blockId);
 
        [Event(4)]
        public void SendFunctionDefinitions(string definitions)
            => WriteEvent(4, definitions);
 
        [Event(5)]
        public void BlockCanceled(FunctionId functionId, int tick, int blockId)
            => WriteEvent(5, (int)functionId, tick, blockId);
 
        [NonEvent]
        protected override void OnEventCommand(EventCommandEventArgs command)
        {
            base.OnEventCommand(command);
 
            if (command.Command == EventCommand.SendManifest ||
                command.Command != EventCommand.Disable ||
                FunctionDefinitionRequested(command))
            {
                if (!_initialized)
                {
                    // We're still in the constructor, need to defer sending until we've finished initializing
                    Task.Yield().GetAwaiter().OnCompleted(FireAndForgetSendFunctionDefinitions);
                    return;
                }
 
                SendFunctionDefinitions();
            }
 
            // Cannot inline this local function as a lambda because we need NonEventAttribute applied.
            [NonEvent]
            void FireAndForgetSendFunctionDefinitions()
            {
                _ = Task.Run(SendFunctionDefinitions);
            }
        }
 
        [NonEvent]
        private static bool FunctionDefinitionRequested(EventCommandEventArgs command)
        {
            return command.Arguments != null &&
                   command.Arguments.Keys.FirstOrDefault() == "SendFunctionDefinitions";
        }
 
        [NonEvent]
        private void SendFunctionDefinitions()
            => SendFunctionDefinitions(GenerateFunctionDefinitions());
 
        [NonEvent]
        public static string GenerateFunctionDefinitions()
        {
            var output = new StringBuilder();
 
            var functions = from f in typeof(FunctionId).GetFields()
                            where !f.IsSpecialName
                            select f;
 
            var assembly = typeof(RoslynEventSource).Assembly;
            var fvi = FileVersionInfo.GetVersionInfo(assembly.Location);
            output.AppendLine(fvi.ProductVersion);
 
            foreach (var function in functions)
            {
                var value = (int)function.GetRawConstantValue();
#if DEBUG
                var name = "Debug_" + function.Name;
#else
                var name = function.Name;
#endif
                var goal = (from attr in function.GetCustomAttributes(false)
                            where attr is PerfGoalAttribute
                            select ((PerfGoalAttribute)attr).InteractionClass).DefaultIfEmpty(InteractionClass.Undefined).First();
 
                output.Append(value);
                output.Append(" ");
                output.Append(name);
                output.Append(" ");
                output.AppendLine(goal.ToString());
            }
 
            // Note that changing the format of this output string will break any ETW listeners
            // that don't have a direct reference to Microsoft.CodeAnalysis.Workspaces.dll
            return output.ToString();
        }
    }
}