FruitBank/Tests/Mango.Sandbox/Mango.Sandbox.EndPoints/TestSignalREndpoint.cs

using AyCode.Services.SignalRs;
using FruitBank.Common.Dtos;
using FruitBank.Common.SignalRs;
using System.Globalization;
using System.Text.Json.Serialization;

namespace Mango.Sandbox.EndPoints;

/// <summary>
/// Egyszerû teszt SignalR endpoint a DevAdminSignalRHub teszteléséhez.
/// Ez az endpoint minimális függõséggel rendelkezik, hogy könnyebben diagnosztizálható legyen a SignalR Hub mûködése.
/// </summary>
public class TestSignalREndpoint : ITestSignalREndpointServer
{
    #region Primitív Paraméter Handlerek

    /// <summary>
    /// Egyszerû ping metódus - visszaadja a kapott üzenetet és egy timestampet.
    /// </summary>
    [SignalR(TestSignalRTags.PingTag)]
    public Task<TestPingResponse> Ping(string message)
    {
        return Task.FromResult(new TestPingResponse
        {
            Message = message,
            ReceivedAt = DateTime.UtcNow,
            ServerInfo = $"Sandbox Server - {Environment.MachineName}"
        });
    }

    /// <summary>
    /// Int paraméter teszt
    /// </summary>
    [SignalR(TestSignalRTags.SingleIntParam)]
    public Task<string> HandleSingleInt(int value)
    {
        return Task.FromResult($"Received: {value}");
    }

    /// <summary>
    /// Két int paraméter teszt
    /// </summary>
    [SignalR(TestSignalRTags.TwoIntParams)]
    public Task<int> HandleTwoInts(int a, int b)
    {
        return Task.FromResult(a + b);
    }

    /// <summary>
    /// Bool paraméter teszt
    /// </summary>
    [SignalR(TestSignalRTags.BoolParam)]
    public Task<bool> HandleBool(bool loadRelations)
    {
        return Task.FromResult(loadRelations);
    }

    /// <summary>
    /// String paraméter teszt
    /// </summary>
    [SignalR(TestSignalRTags.StringParam)]
    public Task<string> HandleString(string text)
    {
        return Task.FromResult($"Echo: {text}");
    }

    /// <summary>
    /// Guid paraméter teszt
    /// </summary>
    [SignalR(TestSignalRTags.GuidParam)]
    public Task<Guid> HandleGuid(Guid id)
    {
        return Task.FromResult(id);
    }

    /// <summary>
    /// Enum paraméter teszt
    /// </summary>
    [SignalR(TestSignalRTags.EnumParam)]
    public Task<TestStatus> HandleEnum(TestStatus status)
    {
        return Task.FromResult(status);
    }

    /// <summary>
    /// Paraméter nélküli metódus teszt
    /// </summary>
    [SignalR(TestSignalRTags.NoParams)]
    public Task<string> HandleNoParams()
    {
        return Task.FromResult("OK");
    }

    /// <summary>
    /// Több típusú paraméter teszt
    /// </summary>
    [SignalR(TestSignalRTags.MultipleTypesParams)]
    public Task<string> HandleMultipleTypes(bool flag, string text, int number)
    {
        return Task.FromResult($"{flag}-{text}-{number}");
    }

    /// <summary>
    /// Decimal paraméter teszt
    /// </summary>
    [SignalR(TestSignalRTags.DecimalParam)]
    public Task<decimal> HandleDecimal(decimal value)
    {
        return Task.FromResult(value * 2);
    }

    /// <summary>
    /// DateTime paraméter teszt
    /// </summary>
    [SignalR(TestSignalRTags.DateTimeParam)]
    public Task<DateTime> HandleDateTime(DateTime dateTime)
    {
        return Task.FromResult(dateTime);
    }

    /// <summary>
    /// Double paraméter teszt
    /// </summary>
    [SignalR(TestSignalRTags.DoubleParam)]
    public Task<double> HandleDouble(double value)
    {
        return Task.FromResult(value);
    }

    /// <summary>
    /// Long paraméter teszt
    /// </summary>
    [SignalR(TestSignalRTags.LongParam)]
    public Task<long> HandleLong(long value)
    {
        return Task.FromResult(value);
    }

    #endregion

    #region Komplex Objektum Handlerek

    /// <summary>
    /// Egyszerû echo metódus - visszaadja a kapott objektumot változtatás nélkül.
    /// </summary>
    [SignalR(TestSignalRTags.EchoTag)]
    public Task<TestEchoResponse> Echo(TestEchoRequest request)
    {
        return Task.FromResult(new TestEchoResponse
        {
            Id = request?.Id ?? 0,
            Name = request?.Name ?? "Unknown",
            Timestamp = DateTime.UtcNow,
            EchoedSuccessfully = true
        });
    }

    /// <summary>
    /// TestOrderItem komplex objektum teszt
    /// </summary>
    [SignalR(TestSignalRTags.TestOrderItemParam)]
    public Task<TestOrderItem> HandleTestOrderItem(TestOrderItem item)
    {
        return Task.FromResult(new TestOrderItem
        {
            Id = item.Id,
            ProductName = $"Processed: {item.ProductName}",
            Quantity = item.Quantity * 2,
            UnitPrice = item.UnitPrice * 2,
        });
    }

    /// <summary>
    /// TestOrder komplex objektum teszt (beágyazott objektumokkal)
    /// </summary>
    [SignalR(TestSignalRTags.TestOrderParam)]
    public Task<TestOrder> HandleTestOrder(TestOrder order)
    {
        return Task.FromResult(order);
    }

    /// <summary>
    /// SharedTag komplex objektum teszt
    /// </summary>
    [SignalR(TestSignalRTags.SharedTagParam)]
    public Task<SharedTag> HandleSharedTag(SharedTag tag)
    {
        return Task.FromResult(tag);
    }

    #endregion

    #region Kollekció Handlerek

    /// <summary>
    /// Lista visszaadása teszthez.
    /// </summary>
    [SignalR(TestSignalRTags.GetTestItems)]
    public Task<List<TestItem>> GetTestItems()
    {
        var items = new List<TestItem>
        {
            new() { Id = 1, Name = "Item 1", Value = 100.5m },
            new() { Id = 2, Name = "Item 2", Value = 200.75m },
            new() { Id = 3, Name = "Item 3", Value = 300.25m }
        };
        return Task.FromResult(items);
    }

    /// <summary>
    /// Int tömb paraméter teszt
    /// </summary>
    [SignalR(TestSignalRTags.IntArrayParam)]
    public Task<int[]> HandleIntArray(int[] values)
    {
        return Task.FromResult(values.Select(x => x * 2).ToArray());
    }

    /// <summary>
    /// Guid tömb paraméter teszt
    /// </summary>
    [SignalR(TestSignalRTags.GuidArrayParam)]
    public Task<Guid[]> HandleGuidArray(Guid[] ids)
    {
        return Task.FromResult(ids);
    }

    /// <summary>
    /// String lista paraméter teszt
    /// </summary>
    [SignalR(TestSignalRTags.StringListParam)]
    public Task<List<string>> HandleStringList(List<string> items)
    {
        return Task.FromResult(items.Select(x => x.ToUpper()).ToList());
    }

    /// <summary>
    /// TestOrderItem lista paraméter teszt
    /// </summary>
    [SignalR(TestSignalRTags.TestOrderItemListParam)]
    public Task<List<TestOrderItem>> HandleTestOrderItemList(List<TestOrderItem> items)
    {
        return Task.FromResult(items);
    }

    /// <summary>
    /// Int lista paraméter teszt
    /// </summary>
    [SignalR(TestSignalRTags.IntListParam)]
    public Task<List<int>> HandleIntList(List<int> numbers)
    {
        return Task.FromResult(numbers.Select(x => x * 2).ToList());
    }

    /// <summary>
    /// Bool tömb paraméter teszt
    /// </summary>
    [SignalR(TestSignalRTags.BoolArrayParam)]
    public Task<bool[]> HandleBoolArray(bool[] flags)
    {
        return Task.FromResult(flags);
    }

    /// <summary>
    /// Vegyes paraméterek tömbbel teszt
    /// </summary>
    [SignalR(TestSignalRTags.MixedWithArrayParam)]
    public Task<string> HandleMixedWithArray(bool flag, int[] numbers, string text)
    {
        return Task.FromResult($"{flag}-[{string.Join(",", numbers)}]-{text}");
    }

    /// <summary>
    /// Beágyazott lista teszt
    /// </summary>
    [SignalR(TestSignalRTags.NestedListParam)]
    public Task<List<List<int>>> HandleNestedList(List<List<int>> nestedList)
    {
        return Task.FromResult(nestedList);
    }

    /// <summary>
    /// Long tömb paraméter teszt
    /// </summary>
    [SignalR(TestSignalRTags.LongArrayParam)]
    public Task<long[]> HandleLongArray(long[] values)
    {
        return Task.FromResult(values);
    }

    /// <summary>
    /// Decimal tömb paraméter teszt
    /// </summary>
    [SignalR(TestSignalRTags.DecimalArrayParam)]
    public Task<decimal[]> HandleDecimalArray(decimal[] values)
    {
        return Task.FromResult(values);
    }

    /// <summary>
    /// DateTime tömb paraméter teszt
    /// </summary>
    [SignalR(TestSignalRTags.DateTimeArrayParam)]
    public Task<DateTime[]> HandleDateTimeArray(DateTime[] values)
    {
        return Task.FromResult(values);
    }

    /// <summary>
    /// Enum tömb paraméter teszt
    /// </summary>
    [SignalR(TestSignalRTags.EnumArrayParam)]
    public Task<TestStatus[]> HandleEnumArray(TestStatus[] values)
    {
        return Task.FromResult(values);
    }

    /// <summary>
    /// Double tömb paraméter teszt
    /// </summary>
    [SignalR(TestSignalRTags.DoubleArrayParam)]
    public Task<double[]> HandleDoubleArray(double[] values)
    {
        return Task.FromResult(values);
    }

    /// <summary>
    /// SharedTag tömb paraméter teszt
    /// </summary>
    [SignalR(TestSignalRTags.SharedTagArrayParam)]
    public Task<SharedTag[]> HandleSharedTagArray(SharedTag[] tags)
    {
        return Task.FromResult(tags);
    }

    /// <summary>
    /// Dictionary paraméter teszt
    /// </summary>
    [SignalR(TestSignalRTags.DictionaryParam)]
    public Task<Dictionary<string, int>> HandleDictionary(Dictionary<string, int> dict)
    {
        return Task.FromResult(dict);
    }

    #endregion

    #region Vegyes Paraméter Handlerek

    /// <summary>
    /// Int és DTO vegyes paraméter teszt
    /// </summary>
    [SignalR(TestSignalRTags.IntAndDtoParam)]
    public Task<string> HandleIntAndDto(int id, TestOrderItem item)
    {
        return Task.FromResult($"{id}-{item?.ProductName}");
    }

    /// <summary>
    /// DTO és lista vegyes paraméter teszt
    /// </summary>
    [SignalR(TestSignalRTags.DtoAndListParam)]
    public Task<string> HandleDtoAndList(TestOrderItem item, List<int> numbers)
    {
        return Task.FromResult($"{item?.ProductName}-[{string.Join(",", numbers ?? [])}]");
    }

    /// <summary>
    /// Három komplex paraméter teszt
    /// </summary>
    [SignalR(TestSignalRTags.ThreeComplexParams)]
    public Task<string> HandleThreeComplexParams(TestOrderItem item, List<string> tags, SharedTag sharedTag)
    {
        return Task.FromResult($"{item?.ProductName}-{tags?.Count}-{sharedTag?.Name}");
    }

    /// <summary>
    /// Öt paraméter teszt
    /// </summary>
    [SignalR(TestSignalRTags.FiveParams)]
    public Task<string> HandleFiveParams(int a, string b, bool c, Guid d, decimal e)
    {
        return Task.FromResult($"{a}-{b}-{c}-{d}-{e.ToString(CultureInfo.InvariantCulture)}");
    }

    #endregion

    #region FruitBank Specifikus Metódusok

    /// <summary>
    /// OrderDto lista visszaadása ID-k alapján
    /// </summary>
    [SignalR(SignalRTags.GetAllOrderDtoByIds)]
    public Task<List<OrderDto>> GetOrderDtoByIds(int[] orderIds)
    {
        return Task.FromResult(new List<OrderDto>());
    }

    #endregion

    #region Binary Serialization Tesztek - CustomerDto reprodukálás

    /// <summary>
    /// CustomerDto lista visszaadása - reprodukálja a GetMeasuringUsers forgatókönyvet
    /// </summary>
    [SignalR(TestSignalRTags.GetCustomerDtoList)]
    public Task<List<TestCustomerDto>> GetCustomerDtoList()
    {
        var customers = new List<TestCustomerDto>
        {
            new()
            {
                Id = 1,
                Username = "user1",
                Email = "user1@test.com",
                FirstName = "First1",
                LastName = "Last1",
                RegisteredInStoreId = 1,
                Deleted = false
            },
            new()
            {
                Id = 2,
                Username = "user2",
                Email = "user2@test.com",
                FirstName = "First2",
                LastName = "Last2",
                RegisteredInStoreId = 1,
                Deleted = false
            },
            new()
            {
                Id = 3,
                Username = "user3",
                Email = "user3@test.com",
                FirstName = "First3",
                LastName = "Last3",
                RegisteredInStoreId = 2,
                Deleted = true
            }
        };
        return Task.FromResult(customers);
    }

    /// <summary>
    /// Nagyobb CustomerDto lista - több interned string a szerializációban
    /// </summary>
    [SignalR(TestSignalRTags.GetLargeCustomerDtoList)]
    public Task<List<TestCustomerDto>> GetLargeCustomerDtoList()
    {
        var customers = new List<TestCustomerDto>();
        for (int i = 1; i <= 30; i++)
        {
            customers.Add(new TestCustomerDto
            {
                Id = i,
                Username = $"user{i}",
                Email = $"user{i}@test.com",
                FirstName = $"FirstName{i}",
                LastName = $"LastName{i}",
                RegisteredInStoreId = (i % 3) + 1,
                Deleted = i % 5 == 0
            });
        }
        return Task.FromResult(customers);
    }

    #endregion
}

/// <summary>
/// Teszt SignalR Tags - egyszerû értékek a teszteléshez
/// </summary>
public static class TestSignalRTags
{
    // Eredeti tagok
    public const int PingTag = SignalRTags.PingTag;
    public const int EchoTag = SignalRTags.EchoTag;
    public const int GetTestItems = 9003;

    // Primitív paraméterek
    public const int SingleIntParam = 9010;
    public const int TwoIntParams = 9011;
    public const int BoolParam = 9012;
    public const int StringParam = 9013;
    public const int GuidParam = 9014;
    public const int EnumParam = 9015;
    public const int NoParams = 9016;
    public const int MultipleTypesParams = 9017;
    public const int DecimalParam = 9018;
    public const int DateTimeParam = 9019;
    public const int DoubleParam = 9020;
    public const int LongParam = 9021;

    // Komplex objektumok
    public const int TestOrderItemParam = 9030;
    public const int TestOrderParam = 9031;
    public const int SharedTagParam = 9032;

    // Kollekciók
    public const int IntArrayParam = 9040;
    public const int GuidArrayParam = 9041;
    public const int StringListParam = 9042;
    public const int TestOrderItemListParam = 9043;
    public const int IntListParam = 9044;
    public const int BoolArrayParam = 9045;
    public const int MixedWithArrayParam = 9046;
    public const int NestedListParam = 9047;
    public const int LongArrayParam = 9048;
    public const int DecimalArrayParam = 9049;
    public const int DateTimeArrayParam = 9050;
    public const int EnumArrayParam = 9051;
    public const int DoubleArrayParam = 9052;
    public const int SharedTagArrayParam = 9053;
    public const int DictionaryParam = 9054;

    // Vegyes paraméterek
    public const int IntAndDtoParam = 9060;
    public const int DtoAndListParam = 9061;
    public const int ThreeComplexParams = 9062;
    public const int FiveParams = 9063;

    // Binary serialization tesztek - CustomerDto reprodukálás
    public const int GetCustomerDtoList = 9070;
    public const int GetLargeCustomerDtoList = 9071;
}

/// <summary>
/// Interface a TestSignalREndpoint-hoz
/// </summary>
public interface ITestSignalREndpointServer
{
    // Primitívek
    Task<TestPingResponse> Ping(string message);
    Task<string> HandleSingleInt(int value);
    Task<int> HandleTwoInts(int a, int b);
    Task<bool> HandleBool(bool loadRelations);
    Task<string> HandleString(string text);
    Task<Guid> HandleGuid(Guid id);
    Task<TestStatus> HandleEnum(TestStatus status);
    Task<string> HandleNoParams();
    Task<string> HandleMultipleTypes(bool flag, string text, int number);
    Task<decimal> HandleDecimal(decimal value);
    Task<DateTime> HandleDateTime(DateTime dateTime);
    Task<double> HandleDouble(double value);
    Task<long> HandleLong(long value);

    // Komplex objektumok
    Task<TestEchoResponse> Echo(TestEchoRequest request);
    Task<TestOrderItem> HandleTestOrderItem(TestOrderItem item);
    Task<TestOrder> HandleTestOrder(TestOrder order);
    Task<SharedTag> HandleSharedTag(SharedTag tag);

    // Kollekciók
    Task<List<TestItem>> GetTestItems();
    Task<int[]> HandleIntArray(int[] values);
    Task<Guid[]> HandleGuidArray(Guid[] ids);
    Task<List<string>> HandleStringList(List<string> items);
    Task<List<TestOrderItem>> HandleTestOrderItemList(List<TestOrderItem> items);
    Task<List<int>> HandleIntList(List<int> numbers);
    Task<bool[]> HandleBoolArray(bool[] flags);
    Task<string> HandleMixedWithArray(bool flag, int[] numbers, string text);
    Task<List<List<int>>> HandleNestedList(List<List<int>> nestedList);
    Task<long[]> HandleLongArray(long[] values);
    Task<decimal[]> HandleDecimalArray(decimal[] values);
    Task<DateTime[]> HandleDateTimeArray(DateTime[] values);
    Task<TestStatus[]> HandleEnumArray(TestStatus[] values);
    Task<double[]> HandleDoubleArray(double[] values);
    Task<SharedTag[]> HandleSharedTagArray(SharedTag[] tags);
    Task<Dictionary<string, int>> HandleDictionary(Dictionary<string, int> dict);

    // Vegyes paraméterek
    Task<string> HandleIntAndDto(int id, TestOrderItem item);
    Task<string> HandleDtoAndList(TestOrderItem item, List<int> numbers);
    Task<string> HandleThreeComplexParams(TestOrderItem item, List<string> tags, SharedTag sharedTag);
    Task<string> HandleFiveParams(int a, string b, bool c, Guid d, decimal e);

    // Binary serialization tesztek - CustomerDto reprodukálás
    Task<List<TestCustomerDto>> GetCustomerDtoList();
    Task<List<TestCustomerDto>> GetLargeCustomerDtoList();
}

#region DTOs

public class TestPingResponse
{
    public string Message { get; set; } = string.Empty;
    public DateTime ReceivedAt { get; set; }
    public string ServerInfo { get; set; } = string.Empty;
}

public class TestEchoRequest
{
    public int Id { get; set; }
    public string Name { get; set; } = string.Empty;
}

public class TestEchoResponse
{
    public int Id { get; set; }
    public string Name { get; set; } = string.Empty;
    public DateTime Timestamp { get; set; }
    public bool EchoedSuccessfully { get; set; }
}

public class TestItem
{
    public int Id { get; set; }
    public string Name { get; set; } = string.Empty;
    public decimal Value { get; set; }
}

/// <summary>
/// Teszt enum a különbözõ állapotok teszteléséhez
/// </summary>
public enum TestStatus
{
    Pending = 0,
    Active = 1,
    Completed = 2,
    Cancelled = 3
}

/// <summary>
/// Teszt rendelési tétel komplex objektum teszteléshez
/// </summary>
public class TestOrderItem
{
    public int Id { get; set; }
    
    public string ProductName { get; set; } = string.Empty;
    
    public int Quantity { get; set; }
    
    public decimal UnitPrice { get; set; }
    
    public decimal TotalPrice => Quantity * UnitPrice;
}

/// <summary>
/// Teszt rendelés beágyazott objektumokkal
/// </summary>
public class TestOrder
{
    public int Id { get; set; }
    public string CustomerName { get; set; } = string.Empty;
    public DateTime OrderDate { get; set; }
    public TestStatus Status { get; set; }
    public List<TestOrderItem> Items { get; set; } = [];
    public decimal TotalAmount => Items.Sum(x => x.TotalPrice);
}

/// <summary>
/// Megosztott tag objektum teszteléshez
/// </summary>
public class SharedTag
{
    public int Id { get; set; }
    public string Name { get; set; } = string.Empty;
    public string? Description { get; set; }
    public DateTime CreatedAt { get; set; }
    public bool IsActive { get; set; }
}

/// <summary>
/// Teszt CustomerDto a felhasználók teszteléséhez
/// </summary>
public class TestCustomerDto
{
    public int Id { get; set; }
    public string Username { get; set; } = string.Empty;
    public string Email { get; set; } = string.Empty;
    public string FirstName { get; set; } = string.Empty;
    public string LastName { get; set; } = string.Empty;
    public string FullName => $"{LastName} {FirstName}";
    public int RegisteredInStoreId { get; set; }
    public bool Deleted { get; set; }
}

#endregion