using DD.Persistence.Client.Clients.Interfaces;
using DD.Persistence.Client.Clients.Mapping;
using DD.Persistence.Client.Clients.Mapping.Clients;
using DD.Persistence.Models;
using DD.Persistence.Models.Configurations;
using Microsoft.Extensions.Logging;
using NSubstitute;
using System.Text.Json;

namespace DD.Persistence.Test;

public record FirstTestDto(Guid DiscriminatorId, DateTimeOffset Timestamp, int Id, string? Value);

public record SecondTestDto(Guid DiscriminatorId, DateTimeOffset Timestamp, int Id, double Capacity);

public class MappingClientsTest
{
    private readonly ITimestampedValuesClient timestampedValuesClient = Substitute.For<ITimestampedValuesClient>();
    private readonly ILogger<TimestampedSetMapper> logger = Substitute.For<ILogger<TimestampedSetMapper>>(); 
    private readonly TimestampedMappingClient timestampedMappingClient;

    private readonly MappingConfig mappingConfigs;


    public MappingClientsTest()
    {
        mappingConfigs = GetConfig();
        var storage = new MapperStorage(mappingConfigs, logger);

        timestampedMappingClient = new TimestampedMappingClient(timestampedValuesClient, storage);
    }

    

    [Fact]
    public async Task GetMultiMapped()
    {
        // Arrange
        var discriminatorIds = mappingConfigs.Keys;
        var firstDiscriminatorId = discriminatorIds.First();
        var secondDiscriminatorId = discriminatorIds.Last();
        var getResult = new[]
        {
            new TimestampedValuesDto()
            {
                DiscriminatorId = firstDiscriminatorId,
                Timestamp = DateTime.UtcNow,
                Values = new Dictionary<string, object>
                {
                    { nameof(FirstTestDto.Id), JsonDocument.Parse(JsonSerializer.Serialize(1)).RootElement },
                    { nameof(FirstTestDto.Value), JsonDocument.Parse(JsonSerializer.Serialize("string1")).RootElement}
                }
            },
            new TimestampedValuesDto()
            {
                DiscriminatorId = secondDiscriminatorId,
                Timestamp = DateTime.UtcNow,
                Values = new Dictionary<string, object>
                {
                    { nameof(SecondTestDto.Id), JsonDocument.Parse(JsonSerializer.Serialize(1)).RootElement },
                    { nameof(SecondTestDto.Capacity), JsonDocument.Parse(JsonSerializer.Serialize(0.1)).RootElement}
                }
            }
        };
        timestampedValuesClient
            .Get(discriminatorIds, null, null, null, 0, 1, CancellationToken.None)
            .ReturnsForAnyArgs(getResult);

        // Act
        var result = await timestampedMappingClient.GetMultiMapped(discriminatorIds, null, null, null, 0, 1, CancellationToken.None);

        // Assert
        Assert.NotNull(result);
        Assert.NotEmpty(result);
        Assert.Equal(getResult.Count(), result.Count());

        var firstActualDto = (FirstTestDto) result[firstDiscriminatorId].First();
        Assert.NotNull(firstActualDto);

        var actualId = firstActualDto.Id.ToString();
        var expectedId = getResult[0].Values[nameof(FirstTestDto.Id)].ToString();
        Assert.Equal(expectedId, actualId);

        var secondActualDto = (SecondTestDto) result[secondDiscriminatorId].First();
        Assert.NotNull(secondActualDto);

        actualId = secondActualDto.Id.ToString();
        expectedId = getResult[1].Values[nameof(SecondTestDto.Id)].ToString();
        Assert.Equal(expectedId, actualId);
    }
    private MappingConfig GetConfig()
    {
        var config = new MappingConfig();
        config[Guid.NewGuid()] = typeof(FirstTestDto);
        config[Guid.NewGuid()] = typeof(SecondTestDto);

        return config;
    }
}