AyCode.Core/AyCode.Services.Tests/SignalRs/PostJsonDataMessageTests.cs

using AyCode.Core.Extensions;
using AyCode.Services.SignalRs;
using MessagePack.Resolvers;

namespace AyCode.Services.Tests.SignalRs;

[TestClass]
public class PostJsonDataMessageTests
{
    [TestMethod]
    public void Debug_CreatePostMessage_ForInt()
    {
        // Test what CreatePostMessage produces for an int
        var message = CreatePostMessageTest(42);

        Console.WriteLine($"Message type: {message.GetType().Name}");

        if (message is SignalPostJsonDataMessage<IdMessage> idMsg)
        {
            Console.WriteLine($"PostDataJson: {idMsg.PostDataJson}");
            Console.WriteLine($"PostData.Ids.Count: {idMsg.PostData.Ids.Count}");
            Console.WriteLine($"PostData.Ids[0]: {idMsg.PostData.Ids[0]}");
        }

        // Serialize to MessagePack
        var bytes = message.ToMessagePack(ContractlessStandardResolver.Options);
        Console.WriteLine($"MessagePack bytes: {bytes.Length}");

        // Deserialize as server would
        var deserialized = bytes.MessagePackTo<SignalPostJsonDataMessage<IdMessage>>(ContractlessStandardResolver.Options);
        Console.WriteLine($"Deserialized PostDataJson: {deserialized.PostDataJson}");
        Console.WriteLine($"Deserialized PostData type: {deserialized.PostData?.GetType().Name}");
        Console.WriteLine($"Deserialized PostData.Ids.Count: {deserialized.PostData?.Ids.Count}");

        Assert.IsNotNull(deserialized.PostData);
        Assert.AreEqual(1, deserialized.PostData.Ids.Count);
    }

    [TestMethod]
    [DataRow(42)]
    [DataRow("45")]
    [DataRow(true)]
    public void IdMessage_FullRoundTrip_AnyParameter(object testValue)
    {
        dynamic GetValueByType(object value)
        {
            if (value is int valueInt) return valueInt;
            if (value is bool valueBool) return valueBool;
            if (value is string valueString) return valueString;

            Assert.Fail($"Type of testValue not implemented");
            return null;
        }

        // Step 1: Client creates message for int parameter (like PostDataAsync<int, string>)
        Console.WriteLine("=== Step 1: Client creates message ===");

        var idMessage = new IdMessage(GetValueByType(testValue));
        Console.WriteLine($"IdMessage.Ids[0]: '{idMessage.Ids[0]}'");

        var clientMessage = new SignalPostJsonDataMessage<IdMessage>(idMessage);
        Console.WriteLine($"Client PostDataJson: '{clientMessage.PostDataJson}'");

        // Step 2: Serialize to MessagePack (client sends)
        Console.WriteLine("\n=== Step 2: MessagePack serialization ===");
        var bytes = clientMessage.ToMessagePack(ContractlessStandardResolver.Options);
        Console.WriteLine($"MessagePack bytes: {bytes.Length}");

        // Step 3: Server deserializes
        Console.WriteLine("\n=== Step 3: Server deserializes ===");
        var serverMessage = bytes.MessagePackTo<SignalPostJsonDataMessage<IdMessage>>(ContractlessStandardResolver.Options);
        Console.WriteLine($"Server PostDataJson: '{serverMessage.PostDataJson}'");
        Console.WriteLine($"Server PostData.Ids.Count: {serverMessage.PostData?.Ids.Count}");
        Console.WriteLine($"Server PostData.Ids[0]: '{serverMessage.PostData?.Ids[0]}'");

        // Step 4: Server deserializes parameter
        Console.WriteLine("\n=== Step 4: Server deserializes parameter ===");
        var paramJson = serverMessage.PostData.Ids[0];
        Console.WriteLine($"Parameter JSON: '{paramJson}'");
        var paramValue = AcJsonDeserializer.Deserialize(paramJson, testValue.GetType());
        Console.WriteLine($"Deserialized int value: {paramValue}");

        // Step 5: Service method returns string
        Console.WriteLine("\n=== Step 5: Service method returns ===");
        var serviceResult = $"{paramValue}"; // Like HandleSingleInt does
        Console.WriteLine($"Service result: '{serviceResult}'");

        // Step 6: Server creates response
        Console.WriteLine("\n=== Step 6: Server creates response ===");
        var response = new SignalResponseJsonMessage(100, SignalResponseStatus.Success, serviceResult);
        Console.WriteLine($"Response.ResponseData: '{response.ResponseData}'");

        // Step 7: Serialize response to MessagePack
        Console.WriteLine("\n=== Step 7: Response MessagePack ===");
        var responseBytes = response.ToMessagePack(ContractlessStandardResolver.Options);
        Console.WriteLine($"Response MessagePack bytes: {responseBytes.Length}");

        // Step 8: Client deserializes response
        Console.WriteLine("\n=== Step 8: Client deserializes response ===");
        var clientResponse = responseBytes.MessagePackTo<SignalResponseJsonMessage>(ContractlessStandardResolver.Options);
        Console.WriteLine($"Client ResponseData: '{clientResponse.ResponseData}'");

        // Step 9: Client deserializes to target type (string)
        Console.WriteLine("\n=== Step 9: Client deserializes to string ===");
        try
        {
            var finalResult = clientResponse.ResponseData.JsonTo<string>();

            Console.WriteLine($"Final result: '{finalResult}'");
            Assert.AreEqual(GetValueByType(testValue).ToString(), finalResult);
        }
        catch (Exception ex)
        {
            Console.WriteLine($"ERROR: {ex.Message}");
            throw;
        }
    }

    private static ISignalRMessage CreatePostMessageTest<TPostData>(TPostData postData)
    {
        var type = typeof(TPostData);

        if (type == typeof(string) || type.IsEnum || type.IsValueType || type == typeof(DateTime))
        {
            return new SignalPostJsonDataMessage<IdMessage>(new IdMessage(postData!));
        }

        return new SignalPostJsonDataMessage<TPostData>(postData);
    }    
}