PlanTempusApp/Tests/ConfigurationTests/KeyValueJsonHandlingTests.cs

using Microsoft.VisualStudio.TestTools.UnitTesting;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json.Linq;
using System.Collections.Generic;
using System.Linq;
namespace Tests.ConfigurationTests
{
	[TestClass]
	public class KeyValueJsonHandlingTests : TestFixture
	{

		[TestMethod]
		public void FunMixedTypesTest()
		{
			var pairs = new List<KeyValuePair<string, object>>
				{
				   new("developer:coffeeLevel", 9001.5),
				   new("developer:bugsFixed", 42),
				   new("developer:awake", false),
				   new("compiler:errors:semicolon:0", "Missing ;"),
				   new("compiler:errors:semicolon:1", "Found ; but why?"),
				   new("computer:ram:status", "Out of memory"),
				   new("computer:cpu:temperature", 99.9),
				   new("friday:beer:count", 6),
				   new("friday:code:working", true),
				   new("friday:bugs:count", int.MaxValue),
				   new("real:object", JObject.Parse(@"{
					   ""beer"": {
						   ""count"": 6
					   },
					   ""code"": {
						   ""working"": true
					   },
					   ""bugs"": {
						   ""count"": 2147483647
					   }
				   }"))
				};

		 

			var result = KeyValueToJson.Convert(pairs);

			var expected = JObject.Parse(@"{
            'developer': {
                'coffeeLevel': 9001.5,
                'bugsFixed': 42,
                'awake': false
            },
            'compiler': {
                'errors': { 'semicolon': ['Missing ;', 'Found ; but why?'] }
            },
            'computer': {
                'ram': { 'status': 'Out of memory' },
                'cpu': { 'temperature': 99.9 }
            },
            'friday': {
                'beer': { 'count': 6 },
                'code': { 'working': true },
                'bugs': { 'count': 2147483647 }
            }
        }");

			Assert.IsTrue(JToken.DeepEquals(expected, result));
		}
	}

	  
public static class KeyValueToJson
	{
		public static JObject Convert(List<KeyValuePair<string, object>> pairs)
		{
			var root = new JObject();

			foreach (var pair in pairs)
			{
				var keys = pair.Key.Split(':');
				var current = root;

				// Gennemgå hierarkiet og opret underobjekter, hvis de ikke eksisterer
				for (int i = 0; i < keys.Length - 1; i++)
				{
					var key = keys[i];

					if (current[key] == null)
					{
						current[key] = new JObject();
					}

					current = (JObject)current[key];
				}

				// Håndter den sidste nøgle og tilføj værdien
				var lastKey = keys[keys.Length - 1];
				var value = ConvertValue(pair.Value);

				// Hvis den sidste nøgle allerede eksisterer, tilføj til en liste
				if (current[lastKey] != null)
				{
					// Hvis den allerede er en liste, tilføj til listen
					if (current[lastKey].Type == JTokenType.Array)
					{
						((JArray)current[lastKey]).Add(value);
					}
					// Hvis den ikke er en liste, konverter til en liste
					else
					{
						var existingValue = current[lastKey];
						current[lastKey] = new JArray { existingValue, value };
					}
				}
				// Ellers tilføj som en enkelt værdi
				else
				{
					current[lastKey] = value;
				}
			}

			return root;
		}

		private static JToken ConvertValue(object value)
		{
			// Konverter værdien til det korrekte JToken-format
			return value switch
			{
				int i => new JValue(i),
				double d => new JValue(d),
				bool b => new JValue(b),
				string s => new JValue(s),
				_ => new JValue(value.ToString()) // Fallback for andre typer
			};
		}
	}
}