using DD.Persistence.API.Services;
using DD.Persistence.Database.Entity;
using DD.Persistence.Models;
using DD.Persistence.Models.Common;
using DD.Persistence.Models.Requests;
using DD.Persistence.Repositories;
using DD.Persistence.Services;
using Microsoft.Extensions.Caching.Memory;
using Newtonsoft.Json.Linq;
using NSubstitute;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using UuidExtensions;
using static NSubstitute.Arg;

namespace DD.Persistence.Test;
public class ChangeLogTest
{
    private readonly IChangeLogCommitRepository changeLogCommitRepository = Substitute.For<IChangeLogCommitRepository>();
    private readonly IChangeLogRepository changeLogRepository = Substitute.For<IChangeLogRepository>();
    private readonly IMemoryCache memoryCache = Substitute.For<IMemoryCache>();
    private ChangeLogService service;

    public ChangeLogTest()
    {
        service = new ChangeLogService(memoryCache, changeLogCommitRepository, changeLogRepository);
    }
    [Fact]
    public async Task AddRange()
    {
        var discriminatorId = Uuid7.Guid();
        var expectedCommitId = Uuid7.Guid();
        var comment = "Добавление нескольких значений";
        var commit = new ChangeLogCommitDto(expectedCommitId, comment);
        var dtos = GenerateChangeLogValuesDto(2);

        changeLogCommitRepository.Add(Arg.Any<ChangeLogCommitDto>(), Arg.Any<CancellationToken>()).Returns(Uuid7.Guid());
        changeLogRepository
            .AddRange(
                Arg.Any<Guid>(), 
                Arg.Any<ChangeLogCommitDto>(), 
                Arg.Any<IEnumerable<ChangeLogValuesDto>>(), 
                Arg.Any<CancellationToken>())
            .Returns(2);

        var addRangeResult = await service
            .AddRange(discriminatorId, commit, dtos, CancellationToken.None);

        await changeLogCommitRepository.Received(1).Add(commit, CancellationToken.None);
        await changeLogRepository.Received(1).AddRange(discriminatorId, commit, dtos, CancellationToken.None);
    }

    [Fact]
    public async Task UpdateRange()
    {
        var discriminatorId = Uuid7.Guid();
        var expectedCommitId = Uuid7.Guid();
        var comment = "Изменение нескольких значений";
        var commit = new ChangeLogCommitDto(expectedCommitId, comment);
        var dtos = GenerateChangeLogValuesDto(2);

        changeLogCommitRepository.Add(Arg.Any<ChangeLogCommitDto>(), Arg.Any<CancellationToken>()).Returns(Uuid7.Guid());
        changeLogRepository
            .UpdateRange(
                Arg.Any<ChangeLogCommitDto>(),
                Arg.Any<IEnumerable<ChangeLogValuesDto>>(),
                Arg.Any<CancellationToken>())
            .Returns(2);

        var updateRangeResult = await service
            .UpdateRange(commit, dtos, CancellationToken.None);

        await changeLogCommitRepository.Received(1).Add(commit, CancellationToken.None);
        await changeLogRepository.Received(1).UpdateRange(commit, dtos, CancellationToken.None);
    }

    [Fact]
    public async Task MarkAsDeleted()
    {
        var discriminatorId = Uuid7.Guid();
        var expectedCommitId = Uuid7.Guid();
        var comment = "Удаление нескольких значений";
        var commit = new ChangeLogCommitDto(expectedCommitId, comment);
        var dtos = GenerateChangeLogValuesDto(2);
        var dtoIds = dtos.Select(d => d.Id);

        changeLogCommitRepository.Add(Arg.Any<ChangeLogCommitDto>(), Arg.Any<CancellationToken>()).Returns(Uuid7.Guid());
        changeLogRepository
            .MarkAsDeleted(
                Arg.Any<Guid>(),
                Arg.Any<IEnumerable<Guid>>(),
                Arg.Any<DateTimeOffset>(),
                Arg.Any<CancellationToken>())
            .Returns(2);

        var markAsDeletedResult = await service
            .MarkAsDeleted(dtoIds, commit, CancellationToken.None);

        await changeLogCommitRepository.Received(1).Add(commit, CancellationToken.None);
        await changeLogRepository.Received(1).MarkAsDeleted(commit.Id, dtoIds, commit.Creation, CancellationToken.None);
    }

    [Fact]
    public async Task ClearAndAddRange()
    {
        var discriminatorId = Uuid7.Guid();
        var expectedCommitId = Uuid7.Guid();
        var comment = "Удаление и добавление нескольких значений";
        var commit = new ChangeLogCommitDto(expectedCommitId, comment);
        var dtos = GenerateChangeLogValuesDto(2);
        var dtoIds = dtos.Select(d => d.Id);

        changeLogCommitRepository.Add(Arg.Any<ChangeLogCommitDto>(), Arg.Any<CancellationToken>()).Returns(Uuid7.Guid());
        changeLogRepository
            .ClearAndAddRange(
                Arg.Any<Guid>(),
                Arg.Any<ChangeLogCommitDto>(),
                Arg.Any<IEnumerable<ChangeLogValuesDto>>(),
                Arg.Any<CancellationToken>())
            .Returns(2);

        var clearAndAddResult = await service
            .ClearAndAddRange(discriminatorId, commit, dtos, CancellationToken.None);

        await changeLogCommitRepository.Received(1).Add(commit, CancellationToken.None);
        await changeLogRepository.Received(1).ClearAndAddRange(discriminatorId, commit, dtos, CancellationToken.None);
    }

    [Fact]
    public async Task GetByDate()
    {
        var discriminatorId = Uuid7.Guid();
        var paginationRequest = new PaginationRequest()
        {
            Skip = 0,
            Take = 1000
        };
        var dtos = GenerateChangeLogValuesDto(5);
        var items = new PaginationContainer<ChangeLogValuesDto>()
        {
            Take = paginationRequest.Take,
            Skip = paginationRequest.Skip,
            Items = dtos,
            Count = 10
        };
        var momentDate = DateTime.UtcNow;

        changeLogRepository
           .GetByDate(
               Arg.Any<Guid>(),
               Arg.Any<DateTimeOffset>(),
               Arg.Any<PaginationRequest>(),
               Arg.Any<CancellationToken>())
           .Returns(items);

        var actualItems = await service
            .GetByDate(discriminatorId, momentDate, paginationRequest, CancellationToken.None);

        await changeLogRepository.Received(1).GetByDate(discriminatorId, momentDate, paginationRequest, CancellationToken.None);

    }

    [Fact]
    public async Task GetChangeLogForInterval()
    {
        var discriminatorId = Uuid7.Guid();
        var dtos = GenerateChangeLogDto(5);
;
        var dateBegin = DateTimeOffset.UtcNow.AddDays(-5);
        var dateEnd = DateTimeOffset.UtcNow;

        changeLogRepository
           .GetChangeLogForInterval(
               Arg.Any<Guid>(),
               Arg.Any<DateTimeOffset>(),
               Arg.Any<DateTimeOffset>(),
               Arg.Any<CancellationToken>())
           .Returns(dtos);

        var actualItems = await service
            .GetChangeLogForInterval(discriminatorId, dateBegin, dateEnd, CancellationToken.None);

        await changeLogRepository.Received(1).GetChangeLogForInterval(discriminatorId, dateBegin, dateEnd, CancellationToken.None);

    }

    [Fact]
    public async Task GetDatesChange()
    {
        var discriminatorId = Uuid7.Guid();

        var dateBegin = DateTimeOffset.UtcNow.AddDays(-5);
        var dateEnd = DateTimeOffset.UtcNow;

        var dateOnlyBegin = new DateOnly(dateBegin.Year, dateBegin.Month, dateBegin.Day);
        var dateOnlyEnd = new DateOnly(dateEnd.Year, dateEnd.Month, dateEnd.Day);

        var dtos = new List<DateOnly>() { dateOnlyBegin, dateOnlyEnd };  

        changeLogRepository
           .GetDatesChange(
               Arg.Any<Guid>(),
               Arg.Any<CancellationToken>())
           .Returns(dtos);

        var actualItems = await service
            .GetDatesChange(discriminatorId, CancellationToken.None);

        await changeLogRepository.Received(1).GetDatesChange(discriminatorId, CancellationToken.None);

    }


    private IEnumerable<ChangeLogValuesDto> GenerateChangeLogValuesDto(int count)
    {
        var items = new List<ChangeLogValuesDto>();
        for (int i = 0; i < count; i++)
        {
            items.Add(new ChangeLogValuesDto()
            {

                Id = Uuid7.Guid(),
                Value = new Dictionary<string, object>
                {
                    { "1", 1 },
                    { "2", 2 }
                }

            });
        }
        return items;
    }

    private IEnumerable<ChangeLogDto> GenerateChangeLogDto(int count)
    {
        var items = new List<ChangeLogDto>();
        for (int i = 0; i < count; i++)
        {
            items.Add(new ChangeLogDto()
            {
                Id = Uuid7.Guid(),              
            });
        }
        return items;
    }
}