using System;

using System.Text.Json;

using System.Collections.Concurrent;

using System.Collections.Generic;

using System.Linq;

​

public class Program

{

    public static void Main()

    {

        var dict = new ConcurrentDictionary<string, object>();

        dict.TryAdd("researchReason", "NotPreviouslyResearched");

        var json = JsonSerializer.Serialize(dict);

        Console.WriteLine("Serialized JSON:");

        Console.WriteLine(json);

​

        var deserialized = JsonSerializer.Deserialize<ConcurrentDictionary<string, object>>(json);

        var debugDump = new Dictionary<string, object>();

        foreach (var kvp in deserialized)

        {

            if (kvp.Value is JsonElement je)

            {

                debugDump[kvp.Key] = new

                {

                    ValueKind = (int)je.ValueKind

                };

            }

            else

            {

                debugDump[kvp.Key] = kvp.Value;

            }

        }

​

        var debugJson = JsonSerializer.Serialize(debugDump, new JsonSerializerOptions { WriteIndented = true });

        Console.WriteLine("Debug Output:");

        Console.WriteLine(debugJson);

        var newDict = dict.FilterAndCombine(new Dictionary<string,object>());

        var fixedd = JsonSerializer.Serialize(newDict, new JsonSerializerOptions { WriteIndented = true });

        Console.Write("Fixed: ");

        Console.WriteLine(fixedd);

    }

}

​

    public static class EventBusCore_ConcurrentDictionaryExtensions

    {

​

        /// <summary>

        /// Filters the metadata dictionary to exclude keys ending with "-Status" and combines it with the payload dictionary.

        /// </summary>

        /// <param name="metadata">The metadata dictionary to filter and combine.</param>

        /// <param name="payload">The payload dictionary to combine with the filtered metadata.</param>

        /// <returns>A new dictionary containing the combined entries from the payload and filtered metadata.</returns>

        /// <remarks>

        /// RWM: This method helps filter out certain Metadata from the <see cref="SustainmentEventBase.Metadata" />, and combine

        /// it with other metadata from an event being processed, so an EventLoop payload can be constructed.

        /// </remarks>

        public static Dictionary<string, object> FilterAndCombine(this ConcurrentDictionary<string, object> metadata, Dictionary<string, object> payload)

        {

            // RWM: Create a copy for now because we don't want to create the expectation that what we're passing in will be modified.

            var result = payload.ToDictionary(x => x.Key, x => x.Value);

            foreach (var item in metadata.Where(kvp => !kvp.Key.EndsWith("-Status")))

            {

                result[item.Key] = item.Value is JsonElement element

                    ? element.ValueKind switch

                    {

                        JsonValueKind.String => element.GetString(),

                        JsonValueKind.Number => element.TryGetInt64(out long l) ? l : element.GetDouble(),

                        JsonValueKind.True => true,

                        JsonValueKind.False => false,

                        JsonValueKind.Null => null,

                        _ => element.GetRawText()

                    }

                    : item.Value;

            }

            return result;

        }

    }