using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using LCU.API.Internal.Operations.IncentiveApiLib.Persistence;
using LCU.API.Internal.Operations.IncentiveApiLib.Repositories;
using LCU.API.Internal.Operations.IncentiveApi.Services;
using LCU.Library.Internal.IncentiveApiModels.Entities;
using LCU.Library.Internal.IncentiveApiModels.Enums;
using Microsoft.EntityFrameworkCore;
using Moq;
using NUnit.Framework;

namespace Application.UnitTests.Services
{
    public class GapInsuranceActivityServiceTest
    {
        private GapInsuranceActivityService _gapInsuranceActivityService;
        private IActivityRepository _activityRepository;
        private IActivityDetailService _activityDetailService;
        private IActivityService _activityService;
        private IUnitOfWork _unitOfWork;

        [SetUp]
        public void Setup()
        {
            var options = new DbContextOptionsBuilder<ApplicationDbContext>()
                .UseInMemoryDatabase(Guid.NewGuid().ToString())
                .EnableSensitiveDataLogging(true)
                .Options;

            var mockCurrentUserService = Mock.Of<ICurrentUserService>();

            Mock.Get(mockCurrentUserService)
                .Setup(service => service.GetCurrentUser())
                .Returns(new ApplicationUser()
                {
                    Email = "JohnTest@test.com",
                });

            var context = new ApplicationDbContext(options, mockCurrentUserService, new DateTimeService());
            _activityRepository = new ActivityRepository(context);
            _activityService = Mock.Of<IActivityService>();
            _activityDetailService = Mock.Of<IActivityDetailService>();
            Mock.Get(_activityDetailService).Setup(x => x.SaveActivityDetailUpdate(It.IsAny<ActivityDetailUpdate>())).ReturnsAsync(new ActivityDetailUpdate());
            Mock.Get(_activityService).Setup(x => x.ApplyStateChange(It.IsAny<ActivityStateChange>(), false)).ReturnsAsync(new Activity());
            _unitOfWork = new UnitOfWork(context);
            _gapInsuranceActivityService = new GapInsuranceActivityService(_activityDetailService, _activityRepository, _activityService, _unitOfWork);
        }

        [Test]
        public async Task ExpectedRegularMatch()
        {
            var accepted = DateTime.UtcNow.AddDays(-1);

            var activities = new List<Activity>()
            {
                new()
                {
                    Accepted = accepted,
                    EmployeeId = CreateId(),
                    Product = Product.Vehicle,
                    SourceId = "12345",
                    State = ActivityState.Accepted,
                    Detail = new ActivityDetail
                    {
                        AccountNumber = "12345",
                        IsGapInsuranceEligible = true
                    }
                },
                new()
                {
                    Accepted = accepted,
                    EmployeeId = CreateId(),
                    Product = Product.GAPInsurance,
                    SourceId = "8675309",
                    State = ActivityState.Accepted,
                    Detail = new ActivityDetail
                    {
                        AccountNumber = "12345",
                        IsGapInsuranceEligible = false
                    }
                }
            };

            var parentActivityId = await _activityRepository.SaveActivityAsync(activities[0]);
            var accessoryActivityId = await _activityRepository.SaveActivityAsync(activities[1]);
            await _unitOfWork.CompleteAsync();

            var updated = await _gapInsuranceActivityService.MatchOrRemoveGapAccessories();
            Assert.AreEqual(2, updated);
            var updateAccessoryActivity = await _activityRepository.GetActivityById(accessoryActivityId);
            var updateParentActivity = await _activityRepository.GetActivityById(parentActivityId);

            Assert.AreEqual(2, updated);
            Assert.AreEqual(updateAccessoryActivity.MatchingGapInsuranceActivityId, updateParentActivity.Id);
            Assert.AreEqual(updateParentActivity.MatchingGapInsuranceActivityId, updateAccessoryActivity.Id);
            Assert.IsNotNull(updateAccessoryActivity.Detail.GapInsuranceAddDate);
            Assert.IsNotNull(updateParentActivity.Detail.GapInsuranceAddDate);
            Assert.IsNull(updateAccessoryActivity.Detail.GapInsuranceRemoveDate);
            Assert.IsNull(updateParentActivity.Detail.GapInsuranceRemoveDate);
        }

        [TestCase(ActivityState.ManualReview, ActivityState.Accepted)]
        [TestCase(ActivityState.Rejected, ActivityState.Accepted)]
        [TestCase(ActivityState.Transferred, ActivityState.Accepted)]
        [TestCase(ActivityState.Accepted, ActivityState.ManualReview)]
        [TestCase(ActivityState.Accepted, ActivityState.Rejected)]
        [TestCase(ActivityState.Accepted, ActivityState.Transferred)]
        public async Task RegularMatchRemovedWhenEitherActivityStateBecomesNotAccepted(ActivityState accessoryActivityState, ActivityState parentActivityState)
        {
            var accepted = DateTime.UtcNow.AddDays(-1);

            var activities = new List<Activity>()
            {
                new()
                {
                    Accepted = accepted,
                    EmployeeId = CreateId(),
                    MatchingGapInsuranceActivityId = 2,
                    Product = Product.Vehicle,
                    SourceId = "Parent",
                    State = parentActivityState,
                    Detail = new ActivityDetail
                    {
                        AccountNumber = "12345",
                        IsGapInsuranceEligible = true,
                        GapInsuranceAddDate = accepted
                    }
                },
                new()
                {
                    Accepted = accepted,
                    EmployeeId = CreateId(),
                    MatchingGapInsuranceActivityId = 1,
                    Product = Product.GAPInsurance,
                    SourceId = "Accessory",
                    State = accessoryActivityState,
                    Detail = new ActivityDetail
                    {
                        AccountNumber = "12345",
                        IsGapInsuranceEligible = false,
                        GapInsuranceAddDate = accepted
                    }
                }
            };

            var parentActivityId = await _activityRepository.SaveActivityAsync(activities[0]);
            var accessoryActivityId = await _activityRepository.SaveActivityAsync(activities[1]);
            await _unitOfWork.CompleteAsync();

            var updated = await _gapInsuranceActivityService.MatchOrRemoveGapAccessories();

            var removedAccessoryActivity = await _activityRepository.GetActivityById(accessoryActivityId);
            var removedParentActivity = await _activityRepository.GetActivityById(parentActivityId);

            Assert.IsNotNull(removedAccessoryActivity.Detail.GapInsuranceRemoveDate);
            Assert.IsNotNull(removedParentActivity.Detail.GapInsuranceRemoveDate);

            Assert.AreEqual(removedAccessoryActivity.MatchingGapInsuranceActivityId, 0);
            Assert.AreEqual(removedParentActivity.MatchingGapInsuranceActivityId, 0);
        }

        [Test]
        public async Task RegularMatchRemovedWhenMatchedActivityCantBeFound()
        {
            var accepted = DateTime.UtcNow.AddDays(-1);

            var activities = new List<Activity>()
            {
                new()
                {
                    Accepted = accepted,
                    EmployeeId = CreateId(),
                    MatchingGapInsuranceActivityId = 2,
                    Product = Product.Vehicle,
                    SourceId = "Parent",
                    State = ActivityState.Accepted,
                    Detail = new ActivityDetail
                    {
                        AccountNumber = "12345",
                        IsGapInsuranceEligible = true,
                        GapInsuranceAddDate = accepted
                    }
                }
            };

            var parentActivityId = await _activityRepository.SaveActivityAsync(activities[0]);
            await _unitOfWork.CompleteAsync();

            var updated = await _gapInsuranceActivityService.MatchOrRemoveGapAccessories();

            var removedParentActivity = await _activityRepository.GetActivityById(parentActivityId);

            Assert.IsNotNull(removedParentActivity.Detail.GapInsuranceRemoveDate);
            Assert.AreEqual(removedParentActivity.MatchingGapInsuranceActivityId, 0);
        }

        private static string CreateId() => Guid.NewGuid().ToString("D");
    }
}