using Microsoft.Extensions.DependencyInjection;
using Persistence.Client.Clients;
using Persistence.Client;
using Persistence.Models;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Xunit;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using System.Net;
using Mapster;
using Persistence.Database.Model;
using Persistence.Models.Requests;

namespace Persistence.IntegrationTests.Controllers;
public class ChangeLogControllerTest : BaseIntegrationTest
{
    private readonly IChangeLogClient client;
    private static Random generatorRandomDigits = new Random();

    public ChangeLogControllerTest(WebAppFactoryFixture factory) : base(factory)
    {
        var persistenceClientFactory = scope.ServiceProvider
            .GetRequiredService<PersistenceClientFactory>();

        client = persistenceClientFactory.GetClient<IChangeLogClient>();
    }

    [Fact]
    public async Task ClearAndInsertRange()
    {
        // arrange
        var idDiscriminator = Guid.NewGuid();
        var dtos = Generate(2, DateTimeOffset.UtcNow);

        // act
        var result = await client.ClearAndInsertRange(idDiscriminator, dtos);

        // assert
        Assert.Equal(HttpStatusCode.OK, result.StatusCode);
        Assert.Equal(2, result.Content);
    }

    [Fact]
    public async Task Add_returns_success()
    {
        // arrange
        var count = 1;
        var idDiscriminator = Guid.NewGuid();
        var dtos = Generate(count, DateTimeOffset.UtcNow);
        var dto = dtos.FirstOrDefault()!;

        // act
        var result = await client.Add(idDiscriminator, dto);

        // assert
        Assert.Equal(HttpStatusCode.OK, result.StatusCode);
        Assert.Equal(count, result.Content);      
    }

    [Fact]
    public async Task AddRange_returns_success()
    {
        // arrange
        var count = 3;
        var idDiscriminator = Guid.NewGuid();
        var dtos = Generate(count, DateTimeOffset.UtcNow);

        // act
        var result = await client.AddRange(idDiscriminator, dtos);

        // assert
        Assert.Equal(HttpStatusCode.OK, result.StatusCode);
        Assert.Equal(count, result.Content);
    }

    [Fact]
    public async Task Update_returns_success()
    {
        // arrange
        var idDiscriminator = Guid.NewGuid();
        var dtos = Generate(1, DateTimeOffset.UtcNow);
        var dto = dtos.FirstOrDefault()!;
        var entity = dto.Adapt<ChangeLog>();
        dbContext.ChangeLog.Add(entity);
        dbContext.SaveChanges();

        dto.Id = entity.Id;
        dto.DepthStart = dto.DepthStart + 10;
        dto.DepthEnd = dto.DepthEnd + 10;

        // act
        var result = await client.Update(idDiscriminator, dto);

        // assert
        Assert.Equal(HttpStatusCode.OK, result.StatusCode);
        Assert.Equal(2, result.Content);

        //var entities = dbContext.ChangeLog
        //    .Where(e => e.IdDiscriminator == idDiscriminator)
        //    .ToArray();
        //var obsoleteEntity = entities
        //    .Where(e => e.Obsolete.HasValue)
        //    .FirstOrDefault();

        //var activeEntity = entities
        //    .Where(e => !e.Obsolete.HasValue)
        //    .FirstOrDefault();

        //if (obsoleteEntity == null || activeEntity == null)
        //{
        //    Assert.Fail();
        //    return;
        //}

        //Assert.Equal(activeEntity.IdNext, obsoleteEntity.Id);

    }

    [Fact]
    public async Task UpdateRange_returns_success()
    {
        // arrange
        var count = 2;
        var idDiscriminator = Guid.NewGuid();
        var dtos = Generate(count, DateTimeOffset.UtcNow);
        var entities = dtos.Select(d => d.Adapt<ChangeLog>());
        dbContext.ChangeLog.AddRange(entities);
        dbContext.SaveChanges();

        dtos = entities.Select(c => new DataWithWellDepthAndSectionDto()
        {
            DepthEnd = c.DepthEnd + 10,
            DepthStart = c.DepthStart + 10,
            Id = c.Id,
            IdSection = c.IdSection,
            Value = c.Value
        });

        // act
        var result = await client.UpdateRange(idDiscriminator, dtos);

        // assert
        Assert.Equal(HttpStatusCode.OK, result.StatusCode);
        Assert.Equal(count * 2, result.Content);
    }

    [Fact]
    public async Task Delete_returns_success()
    {
        // arrange
        var dtos = Generate(1, DateTimeOffset.UtcNow);
        var dto = dtos.FirstOrDefault()!;
        var entity = dto.Adapt<ChangeLog>();
        dbContext.ChangeLog.Add(entity);
        dbContext.SaveChanges();

        // act
        var result = await client.Delete(entity.Id);

        // assert
        Assert.Equal(HttpStatusCode.OK, result.StatusCode);
        Assert.Equal(1, result.Content);
    }

    [Fact]
    public async Task DeleteRange_returns_success()
    {
        // arrange
        var count = 10;
        var dtos = Generate(count, DateTimeOffset.UtcNow);
        var entities = dtos.Select(d => d.Adapt<ChangeLog>()).ToArray();
        dbContext.ChangeLog.AddRange(entities);
        dbContext.SaveChanges();

        // act
        var ids = entities.Select(e => e.Id);
        var result = await client.DeleteRange(ids);

        // assert
        Assert.Equal(HttpStatusCode.OK, result.StatusCode);
        Assert.Equal(count, result.Content);
    }

    [Fact]
    public async Task GetDatesRange_returns_success()
    {
        // arrange
        var changeLogItems = CreateChangeLogItems(3);
        var idDiscriminator = changeLogItems.Item1;
        var entities = changeLogItems.Item2;

        var orderedEntities = entities.OrderBy(e => e.Creation);
        var minDate = orderedEntities.First().Creation;
        var maxDate = orderedEntities.Last().Creation;

        // act
        var result = await client.GetDatesRange(idDiscriminator);

        // assert
        Assert.Equal(HttpStatusCode.OK, result.StatusCode);
        Assert.NotNull(result.Content);

        var expectedMinDate = minDate.ToUniversalTime().ToString();
        var actualMinDate = result.Content!.From.ToUniversalTime().ToString();
        Assert.Equal(expectedMinDate, actualMinDate);

        var expectedMaxDate = maxDate.ToUniversalTime().ToString();
        var actualMaxDate = result.Content!.To.ToUniversalTime().ToString();
        Assert.Equal(expectedMaxDate, actualMaxDate);
    }

    private (Guid, ChangeLog[]) CreateChangeLogItems(int count)
    {
        Guid idDiscriminator = Guid.NewGuid();
        var dtos = Generate(count, DateTimeOffset.UtcNow);
        var entities = dtos.Select(d =>
        {
            var entity = d.Adapt<ChangeLog>();
            entity.IdDiscriminator = idDiscriminator;
            entity.Creation = DateTimeOffset.UtcNow.AddDays(generatorRandomDigits.Next(-15, 15));

            return entity;
        }).ToArray();
        dbContext.ChangeLog.AddRange(entities);
        dbContext.SaveChanges();

        return (idDiscriminator, entities);
    }

    [Fact]
    public async Task GetByDate_returns_success()
    {
        // arrange
        var changeLogItems = CreateChangeLogItems(3);
        var idDiscriminator = changeLogItems.Item1;
        var entities = changeLogItems.Item2;
        var createdDates = entities.Select(e => e.Creation);

        var dtos = entities.Select(e =>
        {
            var dto = e.Adapt<DataWithWellDepthAndSectionDto>();
            dto.DepthEnd = dto.DepthEnd + 10;

            return dto;
        }).ToArray();

        var updatedItems = await client.UpdateRange(idDiscriminator, dtos);

        var request = new SectionPartRequest() { 
            Skip = 0,
            Take = 10,
            SortSettings = String.Empty,
        };

        var moment = DateTimeOffset.UtcNow.AddDays(20);
        var result = await client.GetByDate(idDiscriminator, moment, request);

        Assert.Equal(HttpStatusCode.OK, result.StatusCode);
        Assert.NotNull(result.Content);

    }

    private static IEnumerable<DataWithWellDepthAndSectionDto> Generate(int count, DateTimeOffset from)
    {
        for (int i = 0; i < count; i++)
            yield return new DataWithWellDepthAndSectionDto()
            {
                Value = new Dictionary<string, object>()
                {
                    { "Key", 1 }
                },
                DepthStart = generatorRandomDigits.Next(1, 5),
                DepthEnd = generatorRandomDigits.Next(5, 15),
                Id = Guid.NewGuid(),
                IdSection = Guid.NewGuid()
            };

    }
}