using System;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using AutoMapper;
using NUnit.Framework;
using Strata.Analytics.Biz.DbContexts;
using Strata.Analytics.Biz.Extracts.Models;
using Strata.Analytics.Biz.Extracts.Services;
using Strata.Analytics.Test.Unit.Biz.TestData;
using Strata.CoreLib.Claims;
using Strata.CoreLib.Claims.Extensions;
using Strata.Testing.Categories;

namespace Strata.Analytics.Test.Unit.Biz.Extracts
{
    [Category(TestCategory.Unit)]
    [Parallelizable(ParallelScope.Self)]
    public class ExtractHistoryCrudTests
    {
        private IClaimsPrincipalAccessor _claimsPrincipalAccessor;
        private AnalyticsDbContext _dbContext;
        private IMapper _mapper;
        private ExtractExportHistoryService _historyService;

        [OneTimeSetUp]
        public void OneTimeSetup()
        {
            _claimsPrincipalAccessor = IClaimsPrincipalAccessorMock.GetClaimsPrincipalAccessor();
            _dbContext = AnalyticsDbContextMock.GetAnalyticsDbContext(_claimsPrincipalAccessor);
            _mapper = AutoMapperMock.GetAutoMapper();
            _historyService = new ExtractExportHistoryService(_dbContext, _claimsPrincipalAccessor, _mapper);
            _dbContext.Extracts.AddRange(ExtractTestData.Extracts());
            _dbContext.ExtractExportHistory.AddRange(ExtractTestData.ExtractExportHistories());
            _dbContext.SaveChanges();
        }

        [OneTimeTearDown]
        public async Task OneTimeTearDown()
        {
            await _dbContext.Database.EnsureDeletedAsync();
        }

        [Test]
        public async Task CanCreate()
        {
            var now = DateTime.UtcNow;
            // arrange
            var saveInfo = new ExtractExportHistorySaveInfo()
            {
                ExtractId = 2,
                OutputFilename = "Newest Export File",
                ExportStartDate = now.AddMinutes(-10),
                ExportEndDate = now.AddMinutes(-1),
                SqlExecuted = "This is the Sql Executed",
                TotalFileSize = 1000,
                TotalRowCount = 50000
            };

            // act
            var historyId = await _historyService.CreateAsync(saveInfo, CancellationToken.None);
            var result = await _historyService.GetByIdAsync(historyId, CancellationToken.None);

            // assert
            Assert.IsNotNull(result);
            Assert.That(result.ExtractHistoryId, Is.GreaterThan(ExtractTestData.ExtractExportHistories().Max(h => h.ExtractHistoryId)));
            Assert.That(result.ExtractId, Is.EqualTo(saveInfo.ExtractId));
            Assert.That(result.OutputFilename, Is.EqualTo(saveInfo.OutputFilename));
            Assert.That(result.ExportStartDate, Is.EqualTo(saveInfo.ExportStartDate));
            Assert.That(result.ExportEndDate, Is.EqualTo(saveInfo.ExportEndDate));
            Assert.That(result.SqlExecuted, Is.EqualTo(saveInfo.SqlExecuted));
            Assert.That(result.TotalFileSize, Is.EqualTo(saveInfo.TotalFileSize));
            Assert.That(result.TotalRowCount, Is.EqualTo(saveInfo.TotalRowCount));
            Assert.That(result.CreatedByUserGuid, Is.EqualTo(_claimsPrincipalAccessor.GetCurrentClaimsPrincipal().GetUserGuid()));
            Assert.IsNotNull(result.CreatedDate);
        }


        [Test]
        public async Task CanGetByExtractId()
        {
            // act
            var result = await _historyService.GetByExtractIdAsync(1, CancellationToken.None);

            // assert
            Assert.IsNotNull(result);
            Assert.That(result.Count, Is.EqualTo(ExtractTestData.ExtractExportHistories().Count(h => h.ExtractId == 1)));
        }

    }
}