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 ExtractCrudTests
    {
        private IClaimsPrincipalAccessor _claimsPrincipalAccessor;
        private AnalyticsDbContext _dbContext;
        private IMapper _mapper;
        private IExtractService _extractService;

        [OneTimeSetUp]
        public void OneTimeSetup()
        {
            _claimsPrincipalAccessor = IClaimsPrincipalAccessorMock.GetClaimsPrincipalAccessor(5, true);
            _dbContext = AnalyticsDbContextMock.GetAnalyticsDbContext(_claimsPrincipalAccessor);
            _mapper = AutoMapperMock.GetAutoMapper();
            _extractService = new ExtractService(_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 ExtractCreateInfo()
            {
                Name = "My First Unit Test Extract!",
                Description = "Be Happy For Me!!!",
                ExtractType = ExtractType.DataSource,
                Content = "{\"dataSourceId\":1,\"rows\":[],\"columnGroups\":[{\"groupId\":\"ABCD1\",\"values\":[],\"dimensions\":[],\"sortOrder\":0}],\"filters\":[],\"queryConfig\":{\"rows\":[],\"values\":[],\"filterGroups\":[],\"withTotals\":false,\"rowLimit\":25}}"
            };

            // act
            var result = await _extractService.CreateAsync(saveInfo, CancellationToken.None);

            // assert
            Assert.IsNotNull(result);
            Assert.That(result.ExtractId, Is.GreaterThan(ExtractTestData.Extracts().Max(h => h.ExtractId)));
            Assert.That(result.ExtractType, Is.EqualTo(ExtractType.DataSource));
            Assert.That(result.Content, Is.EqualTo(saveInfo.Content));
            Assert.That(result.CreatedByUserGuid, Is.EqualTo(_claimsPrincipalAccessor.GetCurrentClaimsPrincipal().GetUserGuid()));
            Assert.That(result.UpdatedByUserGuid, Is.EqualTo(_claimsPrincipalAccessor.GetCurrentClaimsPrincipal().GetUserGuid()));
            Assert.IsNotNull(result.CreatedDate);
            Assert.IsNotNull(result.UpdatedDate);
        }


        [Test]
        public async Task CanGetById()
        {
            // act
            var result = await _extractService.GetByIdAsync(1, CancellationToken.None);

            // assert
            Assert.IsNotNull(result);
        }


        [Test]
        public async Task CanUpdate()
        {
            // arrange
            var extractId = _dbContext.Extracts.First().ExtractId;

            var extract = await _extractService.GetByIdAsync(extractId, CancellationToken.None);

            var saveInfo = new ExtractSaveInfo();
            _mapper.Map(extract, saveInfo);

            saveInfo.Name = "My First RENAMED Extract!";
            saveInfo.Description = "Fear Me!!!";
            saveInfo.RawSql = "My New and IMPROVED Query...";
            _dbContext.ChangeTracker.Clear();
            
            // act
            var result = await _extractService.UpdateAsync(extract.ExtractId, saveInfo, CancellationToken.None);

            // assert
            Assert.IsNotNull(result);
            Assert.That(result.ExtractId, Is.EqualTo(extract.ExtractId));
            Assert.That(result.Name, Is.EqualTo(saveInfo.Name));
            Assert.That(result.Description, Is.EqualTo(saveInfo.Description));
            Assert.That(result.RawSql, Is.EqualTo(saveInfo.RawSql));
            Assert.That(result.CreatedByUserGuid, Is.EqualTo(extract.CreatedByUserGuid));
            Assert.That(result.UpdatedByUserGuid, Is.EqualTo(_claimsPrincipalAccessor.GetCurrentClaimsPrincipal().GetUserGuid()));
            Assert.That(result.CreatedDate, Is.EqualTo(extract.CreatedDate));
            Assert.That(result.UpdatedDate, Is.EqualTo(DateTimeOffset.UtcNow).Within(500).Milliseconds); // this could fail in debug
        }

        [Test]
        public async Task CanDelete_LeaveOrphanHistory()
        {
            // arrange
            var extractId = _dbContext.Extracts.Last().ExtractId;
            _dbContext.ChangeTracker.Clear();

            // act
            await _extractService.DeleteAsync(extractId, CancellationToken.None);

            var result = await _extractService.GetByIdAsync(extractId, CancellationToken.None);
            var histories = new ExtractExportHistoryService(_dbContext, _claimsPrincipalAccessor, _mapper).GetByExtractIdAsync(extractId, CancellationToken.None);


            // assert
            Assert.IsNull(result);
            Assert.IsNotNull(histories);
        }
    }
}