using AyCode.Core.Tests.TestModels;
using AyCode.Services.SignalRs;

namespace AyCode.Services.Server.Tests.SignalRs;

/// <summary>
/// Test service with SignalR-attributed methods for testing ProcessOnReceiveMessage.
/// Uses shared DTOs from AyCode.Core.Tests.TestModels.
/// </summary>
public class TestSignalRService
{
    #region Captured Values for Assertions

    // Primitive captures
    public bool SingleIntMethodCalled { get; private set; }
    public int? ReceivedInt { get; private set; }
    
    public bool TwoIntMethodCalled { get; private set; }
    public (int A, int B)? ReceivedTwoInts { get; private set; }
    
    public bool BoolMethodCalled { get; private set; }
    public bool? ReceivedBool { get; private set; }
    
    public bool StringMethodCalled { get; private set; }
    public string? ReceivedString { get; private set; }
    
    public bool GuidMethodCalled { get; private set; }
    public Guid? ReceivedGuid { get; private set; }
    
    public bool EnumMethodCalled { get; private set; }
    public TestStatus? ReceivedEnum { get; private set; }
    
    public bool NoParamsMethodCalled { get; private set; }
    
    public bool MultipleTypesMethodCalled { get; private set; }
    public (bool, string, int)? ReceivedMultipleTypes { get; private set; }

    // Extended primitives
    public bool DecimalMethodCalled { get; private set; }
    public decimal? ReceivedDecimal { get; private set; }
    
    public bool DateTimeMethodCalled { get; private set; }
    public DateTime? ReceivedDateTime { get; private set; }
    
    public bool DoubleMethodCalled { get; private set; }
    public double? ReceivedDouble { get; private set; }
    
    public bool LongMethodCalled { get; private set; }
    public long? ReceivedLong { get; private set; }

    // Complex object captures (using shared DTOs)
    public bool TestOrderItemMethodCalled { get; private set; }
    public TestOrderItem? ReceivedTestOrderItem { get; private set; }
    
    public bool TestOrderMethodCalled { get; private set; }
    public TestOrder? ReceivedTestOrder { get; private set; }
    
    public bool SharedTagMethodCalled { get; private set; }
    public SharedTag? ReceivedSharedTag { get; private set; }

    // Collection captures
    public bool IntArrayMethodCalled { get; private set; }
    public int[]? ReceivedIntArray { get; private set; }
    
    public bool GuidArrayMethodCalled { get; private set; }
    public Guid[]? ReceivedGuidArray { get; private set; }
    
    public bool StringListMethodCalled { get; private set; }
    public List<string>? ReceivedStringList { get; private set; }
    
    public bool TestOrderItemListMethodCalled { get; private set; }
    public List<TestOrderItem>? ReceivedTestOrderItemList { get; private set; }
    
    public bool IntListMethodCalled { get; private set; }
    public List<int>? ReceivedIntList { get; private set; }
    
    public bool BoolArrayMethodCalled { get; private set; }
    public bool[]? ReceivedBoolArray { get; private set; }
    
    public bool MixedWithArrayMethodCalled { get; private set; }
    public (bool, int[], string)? ReceivedMixedWithArray { get; private set; }

    public bool NestedListMethodCalled { get; private set; }
    public List<List<int>>? ReceivedNestedList { get; private set; }

    // Extended array captures for comprehensive testing
    public bool LongArrayMethodCalled { get; private set; }
    public long[]? ReceivedLongArray { get; private set; }
    
    public bool DecimalArrayMethodCalled { get; private set; }
    public decimal[]? ReceivedDecimalArray { get; private set; }
    
    public bool DateTimeArrayMethodCalled { get; private set; }
    public DateTime[]? ReceivedDateTimeArray { get; private set; }
    
    public bool EnumArrayMethodCalled { get; private set; }
    public TestStatus[]? ReceivedEnumArray { get; private set; }
    
    public bool DoubleArrayMethodCalled { get; private set; }
    public double[]? ReceivedDoubleArray { get; private set; }
    
    public bool SharedTagArrayMethodCalled { get; private set; }
    public SharedTag[]? ReceivedSharedTagArray { get; private set; }
    
    public bool DictionaryMethodCalled { get; private set; }
    public Dictionary<string, int>? ReceivedDictionary { get; private set; }
    
    public bool ObjectArrayMethodCalled { get; private set; }
    public object[]? ReceivedObjectArray { get; private set; }

    // Mixed parameter captures
    public bool IntAndDtoMethodCalled { get; private set; }
    public (int, TestOrderItem?)? ReceivedIntAndDto { get; private set; }
    
    public bool DtoAndListMethodCalled { get; private set; }
    public (TestOrderItem?, List<int>?)? ReceivedDtoAndList { get; private set; }
    
    public bool ThreeComplexParamsMethodCalled { get; private set; }
    public (TestOrderItem?, List<string>?, SharedTag?)? ReceivedThreeComplexParams { get; private set; }
    
    public bool FiveParamsMethodCalled { get; private set; }
    public (int, string?, bool, Guid, decimal)? ReceivedFiveParams { get; private set; }

    #endregion

    #region Primitive Parameter Handlers

    [SignalR(TestSignalRTags.SingleIntParam)]
    public string HandleSingleInt(int value)
    {
        SingleIntMethodCalled = true;
        ReceivedInt = value;
        return $"Received: {value}";
    }

    [SignalR(TestSignalRTags.TwoIntParams)]
    public int HandleTwoInts(int a, int b)
    {
        TwoIntMethodCalled = true;
        ReceivedTwoInts = (a, b);
        return a + b;
    }

    [SignalR(TestSignalRTags.BoolParam)]
    public bool HandleBool(bool loadRelations)
    {
        BoolMethodCalled = true;
        ReceivedBool = loadRelations;
        return loadRelations;
    }

    [SignalR(TestSignalRTags.StringParam)]
    public string HandleString(string text)
    {
        StringMethodCalled = true;
        ReceivedString = text;
        return $"Echo: {text}";
    }

    [SignalR(TestSignalRTags.GuidParam)]
    public Guid HandleGuid(Guid id)
    {
        GuidMethodCalled = true;
        ReceivedGuid = id;
        return id;
    }

    [SignalR(TestSignalRTags.EnumParam)]
    public TestStatus HandleEnum(TestStatus status)
    {
        EnumMethodCalled = true;
        ReceivedEnum = status;
        return status;
    }

    [SignalR(TestSignalRTags.NoParams)]
    public string HandleNoParams()
    {
        NoParamsMethodCalled = true;
        return "OK";
    }

    [SignalR(TestSignalRTags.MultipleTypesParams)]
    public string HandleMultipleTypes(bool flag, string text, int number)
    {
        MultipleTypesMethodCalled = true;
        ReceivedMultipleTypes = (flag, text, number);
        return $"{flag}-{text}-{number}";
    }

    [SignalR(TestSignalRTags.ThrowsException)]
    public void HandleThrowsException()
    {
        throw new InvalidOperationException("Test exception");
    }

    [SignalR(TestSignalRTags.DecimalParam)]
    public decimal HandleDecimal(decimal value)
    {
        DecimalMethodCalled = true;
        ReceivedDecimal = value;
        return value * 2;
    }

    [SignalR(TestSignalRTags.DateTimeParam)]
    public DateTime HandleDateTime(DateTime dateTime)
    {
        DateTimeMethodCalled = true;
        ReceivedDateTime = dateTime;
        return dateTime;
    }

    [SignalR(TestSignalRTags.DoubleParam)]
    public double HandleDouble(double value)
    {
        DoubleMethodCalled = true;
        ReceivedDouble = value;
        return value;
    }

    [SignalR(TestSignalRTags.LongParam)]
    public long HandleLong(long value)
    {
        LongMethodCalled = true;
        ReceivedLong = value;
        return value;
    }

    #endregion

    #region Complex Object Handlers (using shared DTOs)

    [SignalR(TestSignalRTags.TestOrderItemParam)]
    public TestOrderItem HandleTestOrderItem(TestOrderItem item)
    {
        TestOrderItemMethodCalled = true;
        ReceivedTestOrderItem = item;
        return new TestOrderItem 
        { 
            Id = item.Id, 
            ProductName = $"Processed: {item.ProductName}", 
            Quantity = item.Quantity * 2,
            UnitPrice = item.UnitPrice
        };
    }

    [SignalR(TestSignalRTags.TestOrderParam)]
    public TestOrder HandleTestOrder(TestOrder order)
    {
        TestOrderMethodCalled = true;
        ReceivedTestOrder = order;
        return order;
    }

    [SignalR(TestSignalRTags.SharedTagParam)]
    public SharedTag HandleSharedTag(SharedTag tag)
    {
        SharedTagMethodCalled = true;
        ReceivedSharedTag = tag;
        return tag;
    }

    #endregion

    #region Collection Parameter Handlers

    [SignalR(TestSignalRTags.IntArrayParam)]
    public int[] HandleIntArray(int[] values)
    {
        IntArrayMethodCalled = true;
        ReceivedIntArray = values;
        return values.Select(x => x * 2).ToArray();
    }

    [SignalR(TestSignalRTags.GuidArrayParam)]
    public Guid[] HandleGuidArray(Guid[] ids)
    {
        GuidArrayMethodCalled = true;
        ReceivedGuidArray = ids;
        return ids;
    }

    [SignalR(TestSignalRTags.StringListParam)]
    public List<string> HandleStringList(List<string> items)
    {
        StringListMethodCalled = true;
        ReceivedStringList = items;
        return items.Select(x => x.ToUpper()).ToList();
    }

    [SignalR(TestSignalRTags.TestOrderItemListParam)]
    public List<TestOrderItem> HandleTestOrderItemList(List<TestOrderItem> items)
    {
        TestOrderItemListMethodCalled = true;
        ReceivedTestOrderItemList = items;
        return items;
    }

    [SignalR(TestSignalRTags.IntListParam)]
    public List<int> HandleIntList(List<int> numbers)
    {
        IntListMethodCalled = true;
        ReceivedIntList = numbers;
        return numbers.Select(x => x * 2).ToList();
    }

    [SignalR(TestSignalRTags.BoolArrayParam)]
    public bool[] HandleBoolArray(bool[] flags)
    {
        BoolArrayMethodCalled = true;
        ReceivedBoolArray = flags;
        return flags;
    }

    [SignalR(TestSignalRTags.MixedWithArrayParam)]
    public string HandleMixedWithArray(bool flag, int[] numbers, string text)
    {
        MixedWithArrayMethodCalled = true;
        ReceivedMixedWithArray = (flag, numbers, text);
        return $"{flag}-[{string.Join(",", numbers)}]-{text}";
    }

    [SignalR(TestSignalRTags.NestedListParam)]
    public List<List<int>> HandleNestedList(List<List<int>> nestedList)
    {
        NestedListMethodCalled = true;
        ReceivedNestedList = nestedList;
        return nestedList;
    }

    #endregion

    #region Extended Array Parameter Handlers

    [SignalR(TestSignalRTags.LongArrayParam)]
    public long[] HandleLongArray(long[] values)
    {
        LongArrayMethodCalled = true;
        ReceivedLongArray = values;
        return values;
    }

    [SignalR(TestSignalRTags.DecimalArrayParam)]
    public decimal[] HandleDecimalArray(decimal[] values)
    {
        DecimalArrayMethodCalled = true;
        ReceivedDecimalArray = values;
        return values;
    }

    [SignalR(TestSignalRTags.DateTimeArrayParam)]
    public DateTime[] HandleDateTimeArray(DateTime[] values)
    {
        DateTimeArrayMethodCalled = true;
        ReceivedDateTimeArray = values;
        return values;
    }

    [SignalR(TestSignalRTags.EnumArrayParam)]
    public TestStatus[] HandleEnumArray(TestStatus[] values)
    {
        EnumArrayMethodCalled = true;
        ReceivedEnumArray = values;
        return values;
    }

    [SignalR(TestSignalRTags.DoubleArrayParam)]
    public double[] HandleDoubleArray(double[] values)
    {
        DoubleArrayMethodCalled = true;
        ReceivedDoubleArray = values;
        return values;
    }

    [SignalR(TestSignalRTags.SharedTagArrayParam)]
    public SharedTag[] HandleSharedTagArray(SharedTag[] tags)
    {
        SharedTagArrayMethodCalled = true;
        ReceivedSharedTagArray = tags;
        return tags;
    }

    [SignalR(TestSignalRTags.DictionaryParam)]
    public Dictionary<string, int> HandleDictionary(Dictionary<string, int> dict)
    {
        DictionaryMethodCalled = true;
        ReceivedDictionary = dict;
        return dict;
    }

    [SignalR(TestSignalRTags.ObjectArrayParam)]
    public object[] HandleObjectArray(object[] values)
    {
        ObjectArrayMethodCalled = true;
        ReceivedObjectArray = values;
        return values;
    }

    #endregion

    #region Mixed Parameter Handlers

    [SignalR(TestSignalRTags.IntAndDtoParam)]
    public string HandleIntAndDto(int id, TestOrderItem item)
    {
        IntAndDtoMethodCalled = true;
        ReceivedIntAndDto = (id, item);
        return $"{id}-{item?.ProductName}";
    }

    [SignalR(TestSignalRTags.DtoAndListParam)]
    public string HandleDtoAndList(TestOrderItem item, List<int> numbers)
    {
        DtoAndListMethodCalled = true;
        ReceivedDtoAndList = (item, numbers);
        return $"{item?.ProductName}-[{string.Join(",", numbers ?? [])}]";
    }

    [SignalR(TestSignalRTags.ThreeComplexParams)]
    public string HandleThreeComplexParams(TestOrderItem item, List<string> tags, SharedTag sharedTag)
    {
        ThreeComplexParamsMethodCalled = true;
        ReceivedThreeComplexParams = (item, tags, sharedTag);
        return $"{item?.ProductName}-{tags?.Count}-{sharedTag?.Name}";
    }

    [SignalR(TestSignalRTags.FiveParams)]
    public string HandleFiveParams(int a, string b, bool c, Guid d, decimal e)
    {
        FiveParamsMethodCalled = true;
        ReceivedFiveParams = (a, b, c, d, e);
        return $"{a}-{b}-{c}-{d}-{e}";
    }

    #endregion

    public void Reset()
    {
        // Primitive captures
        SingleIntMethodCalled = false;
        ReceivedInt = null;
        TwoIntMethodCalled = false;
        ReceivedTwoInts = null;
        BoolMethodCalled = false;
        ReceivedBool = null;
        StringMethodCalled = false;
        ReceivedString = null;
        GuidMethodCalled = false;
        ReceivedGuid = null;
        EnumMethodCalled = false;
        ReceivedEnum = null;
        NoParamsMethodCalled = false;
        MultipleTypesMethodCalled = false;
        ReceivedMultipleTypes = null;
        DecimalMethodCalled = false;
        ReceivedDecimal = null;
        DateTimeMethodCalled = false;
        ReceivedDateTime = null;
        DoubleMethodCalled = false;
        ReceivedDouble = null;
        LongMethodCalled = false;
        ReceivedLong = null;
        
        // Complex object captures
        TestOrderItemMethodCalled = false;
        ReceivedTestOrderItem = null;
        TestOrderMethodCalled = false;
        ReceivedTestOrder = null;
        SharedTagMethodCalled = false;
        ReceivedSharedTag = null;
        
        // Collection captures
        IntArrayMethodCalled = false;
        ReceivedIntArray = null;
        GuidArrayMethodCalled = false;
        ReceivedGuidArray = null;
        StringListMethodCalled = false;
        ReceivedStringList = null;
        TestOrderItemListMethodCalled = false;
        ReceivedTestOrderItemList = null;
        IntListMethodCalled = false;
        ReceivedIntList = null;
        BoolArrayMethodCalled = false;
        ReceivedBoolArray = null;
        MixedWithArrayMethodCalled = false;
        ReceivedMixedWithArray = null;
        NestedListMethodCalled = false;
        ReceivedNestedList = null;
        
        // Extended array captures
        LongArrayMethodCalled = false;
        ReceivedLongArray = null;
        DecimalArrayMethodCalled = false;
        ReceivedDecimalArray = null;
        DateTimeArrayMethodCalled = false;
        ReceivedDateTimeArray = null;
        EnumArrayMethodCalled = false;
        ReceivedEnumArray = null;
        DoubleArrayMethodCalled = false;
        ReceivedDoubleArray = null;
        SharedTagArrayMethodCalled = false;
        ReceivedSharedTagArray = null;
        DictionaryMethodCalled = false;
        ReceivedDictionary = null;
        ObjectArrayMethodCalled = false;
        ReceivedObjectArray = null;
        
        // Mixed parameter captures
        IntAndDtoMethodCalled = false;
        ReceivedIntAndDto = null;
        DtoAndListMethodCalled = false;
        ReceivedDtoAndList = null;
        ThreeComplexParamsMethodCalled = false;
        ReceivedThreeComplexParams = null;
        FiveParamsMethodCalled = false;
        ReceivedFiveParams = null;
    }
}