using Microsoft.Extensions.Logging;

using Moq;

using System;

using System.Collections.Generic;

using System.Linq;

using System.Reflection;

using System.Threading.Tasks;

using Xunit;

​

// Mock classes for testing

public class Market

{

    public string Name { get; set; }

    public string ShortName { get; set; }

    public MarketType MarketType { get; set; }

    public Dictionary<string, string> SpecifierValues { get; set; }

}

​

public class MarketType

{

    public string ShortNamePattern { get; set; }

    public string NamePattern { get; set; }

}

​

public class SignalRMessageSetting

{

    public bool EnableShortNameInMultiLive { get; set; }

    public bool EnableMarketsSyncStateSlim { get; set; }

}

​

public interface ISettingService

{

    Task<SignalRMessageSetting> GetSignalRMessageSettingAsync();

}

​

public interface IEventNotificationService

{

    Task SendMarketsAsync(IEnumerable<Market> markets, Guid eventId, bool enableMarketsSyncStateSlim);

}

​

public static class NameUtils

{

    public static string GenerateShortNameFromNamePattern(string pattern, List<string> teams, List<string> players, List<string> roster, Dictionary<string, string> specifierValues)

    {

        // Simplified implementation for demonstration purposes.

        if (string.IsNullOrWhiteSpace(pattern))

        {

            throw new ArgumentException("Pattern cannot be null or whitespace.", nameof(pattern));

        }

​

        // In a real-world scenario, this method would use the provided data to generate a short name

        // based on the given pattern. For simplicity, we just return a modified pattern here.

        return pattern + "_short";

    }

}

​

public class EventData

{

    public List<string> Teams { get; set; } = new List<string>();

    public List<string> Players { get; set; } = new List<string>();

    public List<string> Roster { get; set; } = new List<string>();

}

​

public class MarketDataProcessor

{

    private readonly ISettingService _settingService;

    private readonly IEventNotificationService _eventNotificationService;

    private readonly ILogger _logger;

    private readonly bool _isInMultiLive;

    private readonly Guid _eventId;

    private readonly EventData _event;

​

    public MarketDataProcessor(ISettingService settingService, IEventNotificationService eventNotificationService, ILogger logger, bool isInMultiLive, Guid eventId, EventData @event)

    {

        _settingService = settingService ?? throw new ArgumentNullException(nameof(settingService));

        _eventNotificationService = eventNotificationService ?? throw new ArgumentNullException(nameof(eventNotificationService));

        _logger = logger ?? throw new ArgumentNullException(nameof(logger));

        _isInMultiLive = isInMultiLive;

        _eventId = eventId;

        _event = @event ?? throw new ArgumentNullException(nameof(@event));

    }

​

    public async Task SendSignalRMarketsInternalAsync(IEnumerable<Market> markets)

    {

        if (markets == null)

        {

            throw new ArgumentNullException(nameof(markets));

        }

​

        var setting = await _settingService.GetSignalRMessageSettingAsync();

​

        if (_isInMultiLive && setting.EnableShortNameInMultiLive)

        {

            foreach (var market in markets)

            {

                if (string.IsNullOrWhiteSpace(market.ShortName))

                {

                    try

                    {

                        string pattern = string.IsNullOrWhiteSpace(market.MarketType?.ShortNamePattern) ? market.MarketType?.NamePattern : market.MarketType?.ShortNamePattern;

                        if (string.IsNullOrWhiteSpace(pattern))

                        {

                            throw new InvalidOperationException($"Both ShortNamePattern and NamePattern are null or whitespace for market type: {market.MarketType}");

                        }

                        market.ShortName = NameUtils.GenerateShortNameFromNamePattern(pattern, _event.Teams, _event.Players, _event.Roster, market.SpecifierValues);

                    }

                    catch (ArgumentException ex)

                    {

                        _logger.LogError(ex, "Error generating short name for market {MarketName}: {ErrorMessage}", market.Name, ex.Message);

                        market.ShortName = market.Name;

                    }

                    catch (InvalidOperationException ex)

                    {

                        _logger.LogError(ex, "Error generating short name for market {MarketName}: {ErrorMessage}", market.Name, ex.Message);

                        market.ShortName = market.Name;

                    }

                    catch (Exception ex)

                    {

                        _logger.LogError(ex, "Unexpected error generating short name for market {MarketName}: {ErrorMessage}", market.Name, ex.Message);

                        market.ShortName = market.Name;

                    }

                }

            }

        }

​

        await _eventNotificationService.SendMarketsAsync(markets, _eventId, setting.EnableMarketsSyncStateSlim);

    }

}

​

public class Program{

    public static async Task Main()

    {

        Console.WriteLine("🔍 Discovering and Running Tests...\n");

​

        int totalPassed = 0, totalFailed = 0;

​

        // Get all test classes (those containing [Fact] or [Theory] methods)

        var testClasses = Assembly.GetExecutingAssembly()

            .GetTypes()

            .Where(t => t.GetMethods(BindingFlags.Instance | BindingFlags.Public)

                .Any(m => m.GetCustomAttribute<FactAttribute>() != null ||

                          m.GetCustomAttribute<TheoryAttribute>() != null))

            .ToList();

​

        foreach (var testClass in testClasses)

        {

            Console.WriteLine($"📌 Running tests in: {testClass.Name}");

            (int passed, int failed) = await RunTests(testClass);

            totalPassed += passed;

            totalFailed += failed;

            Console.WriteLine();

        }

​

        Console.WriteLine("\n📊 FINAL SUMMARY:");

        Console.WriteLine($"✅ Total Passed: {totalPassed}");

        Console.WriteLine($"❌ Total Failed: {totalFailed}");

        Console.WriteLine($"📌 Total Tests: {totalPassed + totalFailed}");

        Console.WriteLine("\n✅ Test execution completed.");

    }

​

    private static async Task<(int passed, int failed)> RunTests(Type testClassType)

    {

        object testInstance = Activator.CreateInstance(testClassType);

        var testMethods = testClassType.GetMethods(BindingFlags.Instance | BindingFlags.Public)

            .Where(m => m.GetCustomAttribute<FactAttribute>() != null ||

                        m.GetCustomAttribute<TheoryAttribute>() != null)

            .ToArray();

​

        int passed = 0, failed = 0;

​

        foreach (var method in testMethods)

        {

            try

            {

                var result = method.Invoke(testInstance, method.GetParameters().Length == 0 ? null : new object[method.GetParameters().Length]);

                if (result is Task task) await task; // Await async test methods

                Console.WriteLine($"  ✅ {method.Name} PASSED");

                passed++;

            }

            catch (TargetInvocationException ex)

            {

                Console.WriteLine($"  ❌ {method.Name} FAILED: {ex.InnerException?.Message ?? ex.Message}");

                failed++;

            }

            catch (Exception ex)

            {

                Console.WriteLine($"  ⚠️ {method.Name} ERROR: {ex.Message}");

                failed++;

            }

        }

​

        return (passed, failed);

    }

}

​

public class MarketDataProcessorTests

{

    [Fact]

    public async Task SendSignalRMarketsInternalAsync_NullMarkets_ThrowsArgumentNullException()

    {

        // Arrange

        var settingServiceMock = new Mock<ISettingService>();

        var eventNotificationServiceMock = new Mock<IEventNotificationService>();

        var loggerMock = new Mock<ILogger>();

        var processor = new MarketDataProcessor(settingServiceMock.Object, eventNotificationServiceMock.Object, loggerMock.Object, false, Guid.NewGuid(), new EventData());

​

        // Act & Assert

        await Assert.ThrowsAsync<ArgumentNullException>(() => processor.SendSignalRMarketsInternalAsync(null));

    }

​

    [Fact]

    public async Task SendSignalRMarketsInternalAsync_NotInMultiLive_DoesNotGenerateShortNames()

    {

        // Arrange

        var markets = new List<Market> { new Market { Name = "Market 1" } };

        var setting = new SignalRMessageSetting { EnableShortNameInMultiLive = false, EnableMarketsSyncStateSlim = true };

        var settingServiceMock = new Mock<ISettingService>();

        settingServiceMock.Setup(s => s.GetSignalRMessageSettingAsync()).ReturnsAsync(setting);

        var eventNotificationServiceMock = new Mock<IEventNotificationService>();

        var loggerMock = new Mock<ILogger>();

        var processor = new MarketDataProcessor(settingServiceMock.Object, eventNotificationServiceMock.Object, loggerMock.Object, false, Guid.NewGuid(), new EventData());

​

        // Act

        await processor.SendSignalRMarketsInternalAsync(markets);

​

        // Assert

        Assert.Equal("Market 1", markets[0].Name);

        Assert.Null(markets[0].ShortName); // ShortName should not be generated.

        eventNotificationServiceMock.Verify(e => e.SendMarketsAsync(markets, It.IsAny<Guid>(), true), Times.Once);

    }

​

    [Fact]

    public async Task SendSignalRMarketsInternalAsync_ShortNamesDisabled_DoesNotGenerateShortNames()

    {

        // Arrange

        var markets = new List<Market> { new Market { Name = "Market 1" } };

        var setting = new SignalRMessageSetting { EnableShortNameInMultiLive = false, EnableMarketsSyncStateSlim = true };

        var settingServiceMock = new Mock<ISettingService>();

        settingServiceMock.Setup(s => s.GetSignalRMessageSettingAsync()).ReturnsAsync(setting);

        var eventNotificationServiceMock = new Mock<IEventNotificationService>();

        var loggerMock = new Mock<ILogger>();

        var processor = new MarketDataProcessor(settingServiceMock.Object, eventNotificationServiceMock.Object, loggerMock.Object, true, Guid.NewGuid(), new EventData());

​

        // Act

        await processor.SendSignalRMarketsInternalAsync(markets);

​

        // Assert

        Assert.Equal("Market 1", markets[0].Name);

        Assert.Null(markets[0].ShortName);  // ShortName should not be generated.

        eventNotificationServiceMock.Verify(e => e.SendMarketsAsync(markets, It.IsAny<Guid>(), true), Times.Once);

    }

​

    [Fact]

    public async Task SendSignalRMarketsInternalAsync_GeneratesShortNames_WhenEnabledAndInMultiLive()

    {

        // Arrange

        var markets = new List<Market>

        {

            new Market { Name = "Market 1", MarketType = new MarketType { ShortNamePattern = "Pattern1" }, SpecifierValues = new Dictionary<string, string>() },

            new Market { Name = "Market 2", ShortName = "ExistingShortName", MarketType = new MarketType { ShortNamePattern = "Pattern2" } , SpecifierValues = new Dictionary<string, string>()}

        };

        var setting = new SignalRMessageSetting { EnableShortNameInMultiLive = true, EnableMarketsSyncStateSlim = false };

        var settingServiceMock = new Mock<ISettingService>();

        settingServiceMock.Setup(s => s.GetSignalRMessageSettingAsync()).ReturnsAsync(setting);

        var eventNotificationServiceMock = new Mock<IEventNotificationService>();

        var loggerMock = new Mock<ILogger>();

        var eventData = new EventData();

        var processor = new MarketDataProcessor(settingServiceMock.Object, eventNotificationServiceMock.Object, loggerMock.Object, true, Guid.NewGuid(), eventData);

​

        // Act

        await processor.SendSignalRMarketsInternalAsync(markets);

​

        // Assert

        Assert.Equal("Pattern1_short", markets[0].ShortName); // ShortName should be generated.

        Assert.Equal("ExistingShortName", markets[1].ShortName); // Existing ShortName should be preserved.

        eventNotificationServiceMock.Verify(e => e.SendMarketsAsync(markets, It.IsAny<Guid>(), false), Times.Once);

    }

​

​

    [Fact]

    public async Task SendSignalRMarketsInternalAsync_UsesNamePattern_WhenShortNamePatternIsNull()

    {

        // Arrange

        var markets = new List<Market>

        {

            new Market { Name = "Market 1", MarketType = new MarketType { ShortNamePattern = null, NamePattern = "NamePattern1" }, SpecifierValues = new Dictionary<string, string>() },

        };

        var setting = new SignalRMessageSetting { EnableShortNameInMultiLive = true, EnableMarketsSyncStateSlim = false };

        var settingServiceMock = new Mock<ISettingService>();

        settingServiceMock.Setup(s => s.GetSignalRMessageSettingAsync()).ReturnsAsync(setting);

        var eventNotificationServiceMock = new Mock<IEventNotificationService>();

        var loggerMock = new Mock<ILogger>();

        var eventData = new EventData();

        var processor = new MarketDataProcessor(settingServiceMock.Object, eventNotificationServiceMock.Object, loggerMock.Object, true, Guid.NewGuid(), eventData);

​

        // Act

        await processor.SendSignalRMarketsInternalAsync(markets);

​

        // Assert

        Assert.Equal("NamePattern1_short", markets[0].ShortName);

        eventNotificationServiceMock.Verify(e => e.SendMarketsAsync(markets, It.IsAny<Guid>(), false), Times.Once);

​

    }

​

    [Fact]

    public async Task SendSignalRMarketsInternalAsync_LogsErrorAndUsesFullName_WhenExceptionOccurs()

    {

        // Arrange

        var markets = new List<Market>

        {

            new Market { Name = "Market 1", MarketType = new MarketType { ShortNamePattern = "" }, SpecifierValues = new Dictionary<string, string>() },

        };

        var setting = new SignalRMessageSetting { EnableShortNameInMultiLive = true, EnableMarketsSyncStateSlim = true };

        var settingServiceMock = new Mock<ISettingService>();

        settingServiceMock.Setup(s => s.GetSignalRMessageSettingAsync()).ReturnsAsync(setting);

        var eventNotificationServiceMock = new Mock<IEventNotificationService>();

        var loggerMock = new Mock<ILogger>();

        var eventData = new EventData();

        var processor = new MarketDataProcessor(settingServiceMock.Object, eventNotificationServiceMock.Object, loggerMock.Object, true, Guid.NewGuid(), eventData);

​

        // Act

        await processor.SendSignalRMarketsInternalAsync(markets);

​

        // Assert

        Assert.Equal("Market 1", markets[0].ShortName); // Should use full name on error.

        loggerMock.Verify(l => l.Log(

                LogLevel.Error,

                It.IsAny<EventId>(),

                It.Is<It.IsAnyType>((v, t) => v.ToString().Contains("Error generating short name for market Market 1")),

                It.IsAny<Exception>(),

                It.IsAny<Func<It.IsAnyType, Exception, string>>()),

            Times.Once);

        eventNotificationServiceMock.Verify(e => e.SendMarketsAsync(markets, It.IsAny<Guid>(), true), Times.Once);

    }

}