// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
 
using System;
using System.Collections.Generic;
using System.IO;
#if NETFRAMEWORK
using Microsoft.Build.Shared;
#endif
 
namespace Microsoft.Build.Framework.Telemetry;
 
internal sealed class WorkerNodeTelemetryEventArgs(IWorkerNodeTelemetryData workerNodeTelemetryData) : BuildEventArgs
{
    public WorkerNodeTelemetryEventArgs()
        : this(new WorkerNodeTelemetryData())
    { }
 
    public IWorkerNodeTelemetryData WorkerNodeTelemetryData { get; private set; } = workerNodeTelemetryData;
 
    internal override void WriteToStream(BinaryWriter writer)
    {
        writer.Write7BitEncodedInt(WorkerNodeTelemetryData.TasksExecutionData.Count);
        foreach (KeyValuePair<TaskOrTargetTelemetryKey, TaskExecutionStats> entry in WorkerNodeTelemetryData.TasksExecutionData)
        {
            WriteToStream(writer, entry.Key);
            writer.Write(entry.Value.CumulativeExecutionTime.Ticks);
            writer.Write(entry.Value.ExecutionsCount);
            writer.Write(entry.Value.TotalMemoryBytes);
            writer.Write(entry.Value.TaskFactoryName ?? string.Empty);
            writer.Write(entry.Value.TaskHostRuntime ?? string.Empty);
        }
 
        writer.Write7BitEncodedInt(WorkerNodeTelemetryData.TargetsExecutionData.Count);
        foreach (KeyValuePair<TaskOrTargetTelemetryKey, TargetExecutionStats> entry in WorkerNodeTelemetryData.TargetsExecutionData)
        {
            WriteToStream(writer, entry.Key);
            writer.Write(entry.Value.WasExecuted);
            writer.Write((int)entry.Value.SkipReason);
        }
    }
 
    internal override void CreateFromStream(BinaryReader reader, int version)
    {
        int count = reader.Read7BitEncodedInt();
        Dictionary<TaskOrTargetTelemetryKey, TaskExecutionStats> tasksExecutionData = new();
        for (int i = 0; i < count; i++)
        {
            var key = ReadFromStream(reader);
            var cumulativeExecutionTime = TimeSpan.FromTicks(reader.ReadInt64());
            var executionsCount = reader.ReadInt32();
            var totalMemoryBytes = reader.ReadInt64();
            var taskFactoryName = reader.ReadString();
            var taskHostRuntime = reader.ReadString();
 
            tasksExecutionData.Add(
                key,
                new TaskExecutionStats(
                    cumulativeExecutionTime,
                    executionsCount,
                    totalMemoryBytes,
                    string.IsNullOrEmpty(taskFactoryName) ? null : taskFactoryName,
                    string.IsNullOrEmpty(taskHostRuntime) ? null : taskHostRuntime));
        }
 
        count = reader.Read7BitEncodedInt();
        Dictionary<TaskOrTargetTelemetryKey, TargetExecutionStats> targetsExecutionData = new();
        for (int i = 0; i < count; i++)
        {
            var key = ReadFromStream(reader);
            var wasExecuted = reader.ReadBoolean();
            var skipReason = (TargetSkipReason)reader.ReadInt32();
            targetsExecutionData.Add(key, new TargetExecutionStats(wasExecuted, skipReason));
        }
 
        WorkerNodeTelemetryData = new WorkerNodeTelemetryData(tasksExecutionData, targetsExecutionData);
    }
 
    private static void WriteToStream(BinaryWriter writer, TaskOrTargetTelemetryKey key)
    {
        writer.Write(key.Name);
        writer.Write(key.IsCustom);
        writer.Write(key.IsNuget);
        writer.Write(key.IsMetaProj);
    }
 
    private static TaskOrTargetTelemetryKey ReadFromStream(BinaryReader reader)
    {
        return new TaskOrTargetTelemetryKey(
            reader.ReadString(),
            reader.ReadBoolean(),
            reader.ReadBoolean(),
            reader.ReadBoolean());
    }
}