using Microsoft.Extensions.Logging;

using Moq;

using System;

using System.Collections.Generic;

using System.Linq;

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 //entry point

{

  public static async Task Main(string[] args)

  {

        // 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 = "SME", 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 MockEventNotificationService();

        var loggerMock = new Mock<ILogger>();

        var eventData = new EventData();

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

​

        await processor.SendSignalRMarketsInternalAsync(markets);

​

        Console.WriteLine("Markets processed.");

  }

​

    public class MockEventNotificationService : IEventNotificationService

    {

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

        {

            // Simulate sending data

            Console.WriteLine($"Sending {markets.Count()} markets for event {eventId}. Slim state: {enableMarketsSyncStateSlim}");

            foreach(var m in markets)

            {

              Console.WriteLine($"Market: Name = {m.Name}, ShortName = {m.ShortName}");

            }

            await Task.CompletedTask;

        }

    }

}

​

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);

    }

}