using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Castle.DynamicProxy.Generators;
using LCU.API.Collections.RepoApi.Exceptions;
using LCU.API.Collections.RepoApi.Models;
using LCU.API.Collections.RepoApi.Services;
using LCU.Shared.Collections.RepoApiLib.Exceptions;
using LCU.Shared.Collections.RepoApiLib.Models;
using LCU.Shared.Collections.RepoApiLib.Repositories;
using Moq;
using Xunit;
using Xunit.Sdk;

namespace LCU.API.Collections.RepoApiTests.Services
{
    public class EventAlertServiceTest
    {
        [Fact]
        public async void ListAll_Ok()
        {
            var mockEventAlertRepository = new Mock<IEventAlertRepository>();
            var mockUnitOfWork = new Mock<IUnitOfWork>();
            var mockRepoRepository = new Mock<IRepoAccountRepository>();

            mockEventAlertRepository.Setup(repo => repo.ListAllAsync()).ReturnsAsync(new List<EventAlert>() { new EventAlert(), new EventAlert(), new EventAlert() });
           
            EventAlertService eventAlertService = new EventAlertService(mockEventAlertRepository.Object, mockUnitOfWork.Object, mockRepoRepository.Object);

            var res = await eventAlertService.ListAll();
            Assert.NotNull(res);
            Assert.Equal(3, res.Count());
        }

        [Fact]
        public async void ListAll_Exception()
        {
            var mockEventAlertRepository = new Mock<IEventAlertRepository>();
            var mockUnitOfWork = new Mock<IUnitOfWork>();
            var mockRepoRepository = new Mock<IRepoAccountRepository>();

            mockEventAlertRepository.Setup(repo => repo.ListAllAsync()).ThrowsAsync(new Exception("oops"));

            EventAlertService eventAlertService = new EventAlertService(mockEventAlertRepository.Object, mockUnitOfWork.Object, mockRepoRepository.Object);

            await Assert.ThrowsAsync<ServerErrorException>(async () =>  await eventAlertService.ListAll());
        }

        [Fact]
        public async void ListUnread_Ok()
        {
            var mockEventAlertRepository = new Mock<IEventAlertRepository>();
            var mockUnitOfWork = new Mock<IUnitOfWork>();
            var mockRepoRepository = new Mock<IRepoAccountRepository>();

            mockEventAlertRepository.Setup(repo => repo.ListUnreadAsync()).ReturnsAsync(new List<EventAlert>() { new EventAlert(), new EventAlert(), new EventAlert() });

            EventAlertService eventAlertService = new EventAlertService(mockEventAlertRepository.Object, mockUnitOfWork.Object, mockRepoRepository.Object);

            var res = await eventAlertService.ListUnread();
            Assert.NotNull(res);
            Assert.Equal(3, res.Count());
        }

        [Fact]
        public async void ListUnread_Exception()
        {
            var mockEventAlertRepository = new Mock<IEventAlertRepository>();
            var mockUnitOfWork = new Mock<IUnitOfWork>();
            var mockRepoRepository = new Mock<IRepoAccountRepository>();

            mockEventAlertRepository.Setup(repo => repo.ListUnreadAsync()).ThrowsAsync(new Exception("oops"));

            EventAlertService eventAlertService = new EventAlertService(mockEventAlertRepository.Object, mockUnitOfWork.Object, mockRepoRepository.Object);

            await Assert.ThrowsAsync<ServerErrorException>(async () => await eventAlertService.ListUnread());
        }

        [Fact]
        public async void ListWithinDateRange_OK()
        {
            var mockEventAlertRepository = new Mock<IEventAlertRepository>();
            var mockUnitOfWork = new Mock<IUnitOfWork>();
            var mockRepoRepository = new Mock<IRepoAccountRepository>();

            mockEventAlertRepository.Setup(repo => repo.ListWithinDateRangeAsync(It.IsAny<DateTime>(), It.IsAny<DateTime>())).ReturnsAsync(new List<EventAlert>() { new EventAlert(), new EventAlert(), new EventAlert() });

            EventAlertService eventAlertService = new EventAlertService(mockEventAlertRepository.Object, mockUnitOfWork.Object, mockRepoRepository.Object);

            var res = await eventAlertService.ListWithinDateRange(DateTime.Now, DateTime.Now.AddDays(5));
            Assert.NotNull(res);
            Assert.Equal(3, res.Count());
        }

        [Fact]
        public async void ListWithinDateRange_Exception()
        {
            var mockEventAlertRepository = new Mock<IEventAlertRepository>();
            var mockUnitOfWork = new Mock<IUnitOfWork>();
            var mockRepoRepository = new Mock<IRepoAccountRepository>();

            mockEventAlertRepository.Setup(repo => repo.ListWithinDateRangeAsync(It.IsAny<DateTime>(), It.IsAny<DateTime>())).ThrowsAsync(new Exception("oops"));

            EventAlertService eventAlertService = new EventAlertService(mockEventAlertRepository.Object, mockUnitOfWork.Object, mockRepoRepository.Object);

            await Assert.ThrowsAsync<ServerErrorException>(async () => await eventAlertService.ListWithinDateRange(DateTime.Now, DateTime.Now.AddDays(5)));
        }

        [Fact]
        public async void ListActionNeeded_Exception()
        {
            var mockEventAlertRepository = new Mock<IEventAlertRepository>();
            var mockUnitOfWork = new Mock<IUnitOfWork>();
            var mockRepoRepository = new Mock<IRepoAccountRepository>();

            mockEventAlertRepository.Setup(repo => repo.ListRepoNoAuctionAsync()).ReturnsAsync(new List<EventAlert>() { new EventAlert(), new EventAlert() });
            mockEventAlertRepository.Setup(repo => repo.ListRepoNoCompanyAsync()).ReturnsAsync(new List<EventAlert>() { new EventAlert() });
            mockEventAlertRepository.Setup(repo => repo.ListO4rNoCompanyAsync()).ReturnsAsync(new List<EventAlert>() { new EventAlert(), new EventAlert() });
            mockEventAlertRepository.Setup(repo => repo.ListReadyForRetitleAsync()).ReturnsAsync(new List<EventAlert>() { new EventAlert(), new EventAlert(), new EventAlert() });
            mockEventAlertRepository.Setup(repo => repo.ListFloorUpdateFailedAsync()).ThrowsAsync(new Exception("oops"));
            mockEventAlertRepository.Setup(repo => repo.ListFloorNeedsSettingAsync()).ReturnsAsync(new List<EventAlert>() { new EventAlert(), new EventAlert(), new EventAlert() });

            EventAlertService eventAlertService = new EventAlertService(mockEventAlertRepository.Object, mockUnitOfWork.Object, mockRepoRepository.Object);

            await Assert.ThrowsAsync<ServerErrorException>(async () => await eventAlertService.ListActionNeeded());
        }

        [Fact]
        public async void ListActionNeeded_OK()
        {
            var mockEventAlertRepository = new Mock<IEventAlertRepository>();
            var mockUnitOfWork = new Mock<IUnitOfWork>();
            var mockRepoRepository = new Mock<IRepoAccountRepository>();

            mockEventAlertRepository.Setup(repo => repo.ListRepoNoAuctionAsync()).ReturnsAsync(new List<EventAlert>() { new EventAlert(), new EventAlert() });
            mockEventAlertRepository.Setup(repo => repo.ListRepoNoCompanyAsync()).ReturnsAsync(new List<EventAlert>() { new EventAlert() });
            mockEventAlertRepository.Setup(repo => repo.ListO4rNoCompanyAsync()).ReturnsAsync(new List<EventAlert>() { new EventAlert(), new EventAlert() });
            mockEventAlertRepository.Setup(repo => repo.ListReadyForRetitleAsync()).ReturnsAsync(new List<EventAlert>() { new EventAlert(), new EventAlert(), new EventAlert() });
            mockEventAlertRepository.Setup(repo => repo.ListFloorUpdateFailedAsync()).ReturnsAsync(new List<EventAlert>() { new EventAlert() });
            mockEventAlertRepository.Setup(repo => repo.ListFloorNeedsSettingAsync()).ReturnsAsync(new List<EventAlert>() { new EventAlert(), new EventAlert(), new EventAlert() });

            EventAlertService eventAlertService = new EventAlertService(mockEventAlertRepository.Object, mockUnitOfWork.Object, mockRepoRepository.Object);

            var res = await eventAlertService.ListActionNeeded();
            Assert.NotNull(res);
            Assert.Equal(12, res.Count());
        }

        [Fact]
        public async void SaveAsync_OK()
        {
            EventAlert eventAlert = new EventAlert() 
            { 
                Id = 5,
                RepoId = 100
            };

            RepoAccount account = new RepoAccount()
            {
                RepoId = 100,
                Status = "O4R"
            };

            var mockEventAlertRepository = new Mock<IEventAlertRepository>();
            var mockUnitOfWork = new Mock<IUnitOfWork>();
            var mockRepoRepository = new Mock<IRepoAccountRepository>();

            mockEventAlertRepository.Setup(repo => repo.AddAsync(It.Is<EventAlert>(param => param.Id == 5))).Returns(Task.CompletedTask);
            mockRepoRepository.Setup(repo => repo.FindByIdAsync(It.Is<Int32>(param => param == 100))).Returns(Task.FromResult(account));
            mockUnitOfWork.Setup(mock => mock.CompleteAsync()).Returns(Task.CompletedTask);

            EventAlertService eventAlertService = new EventAlertService(mockEventAlertRepository.Object, mockUnitOfWork.Object, mockRepoRepository.Object);

            var res = await eventAlertService.SaveAsync(eventAlert);
            Assert.NotNull(res);
            Assert.Equal(eventAlert, res);
        }

        [Fact]
        public async void SaveAsync_DuplicateResource_Exception()
        {
            EventAlert eventAlert = new EventAlert()
            {
                Id = 5,
                RepoId = 100,
                Message = "RTC Letter Not Found"
            };

            RepoAccount account = new RepoAccount()
            {
                RepoId = 100,
                Status = "RTC Letter Not Found"
            };

            var mockEventAlertRepository = new Mock<IEventAlertRepository>();
            var mockUnitOfWork = new Mock<IUnitOfWork>();
            var mockRepoRepository = new Mock<IRepoAccountRepository>();

            mockEventAlertRepository.Setup(repo => repo.AddAsync(It.Is<EventAlert>(param => param.Id == 5))).ThrowsAsync(new DuplicateResourceException("resource"));
            mockRepoRepository.Setup(repo => repo.FindByIdAsync(It.Is<Int32>(param => param == 100))).Returns(Task.FromResult(account));
            mockUnitOfWork.Setup(mock => mock.CompleteAsync()).Returns(Task.CompletedTask);

            EventAlertService eventAlertService = new EventAlertService(mockEventAlertRepository.Object, mockUnitOfWork.Object, mockRepoRepository.Object);

            await Assert.ThrowsAsync<DuplicateResourceException>(async () => await eventAlertService.SaveAsync(eventAlert));
        }

        [Fact]
        public async void SaveAsync_Exception()
        {
            EventAlert eventAlert = new EventAlert()
            {
                Id = 5
            };

            var mockEventAlertRepository = new Mock<IEventAlertRepository>();
            var mockUnitOfWork = new Mock<IUnitOfWork>();
            var mockRepoRepository = new Mock<IRepoAccountRepository>();

            mockEventAlertRepository.Setup(repo => repo.AddAsync(It.Is<EventAlert>(param => param.Id == 5))).ThrowsAsync(new Exception("oops"));
            mockUnitOfWork.Setup(mock => mock.CompleteAsync()).Returns(Task.CompletedTask);

            EventAlertService eventAlertService = new EventAlertService(mockEventAlertRepository.Object, mockUnitOfWork.Object, mockRepoRepository.Object);

            await Assert.ThrowsAsync<ServerErrorException>(async () => await eventAlertService.SaveAsync(eventAlert));
        }

        [Fact]
        public async void saveRangeAsync_Ok()
        {
            List<EventAlert> range = new List<EventAlert>() { new EventAlert(), new EventAlert(), new EventAlert() };

            var mockEventAlertRepository = new Mock<IEventAlertRepository>();
            var mockUnitOfWork = new Mock<IUnitOfWork>();
            var mockRepoRepository = new Mock<IRepoAccountRepository>();
            mockEventAlertRepository.Setup(repo => repo.AddRangeAsync(It.Is<List<EventAlert>>(param => param.Count() == 3))).ReturnsAsync(new List<EventAlert>() { new EventAlert(), new EventAlert() });
            mockUnitOfWork.Setup(mock => mock.CompleteAsync()).Returns(Task.CompletedTask);

            EventAlertService eventAlertService = new EventAlertService(mockEventAlertRepository.Object, mockUnitOfWork.Object, mockRepoRepository.Object);

            var res = await eventAlertService.SaveRangeAsync(range);
            Assert.NotNull(res);
            Assert.Equal(2, res.Count());
        }

        [Fact]
        public async void saveRangeAsync_Exception()
        {
            List<EventAlert> range = new List<EventAlert>() { new EventAlert(), new EventAlert(), new EventAlert() };

            var mockEventAlertRepository = new Mock<IEventAlertRepository>();
            var mockUnitOfWork = new Mock<IUnitOfWork>();
            var mockRepoRepository = new Mock<IRepoAccountRepository>();

            mockEventAlertRepository.Setup(repo => repo.AddRangeAsync(It.Is<List<EventAlert>>(param => param.Count() == 3))).ThrowsAsync(new Exception("oops"));
            mockUnitOfWork.Setup(mock => mock.CompleteAsync()).Returns(Task.CompletedTask);

            EventAlertService eventAlertService = new EventAlertService(mockEventAlertRepository.Object, mockUnitOfWork.Object, mockRepoRepository.Object);

            var res = await eventAlertService.SaveRangeAsync(range);
            Assert.NotNull(res);
            Assert.Empty(res);
        }

        [Fact]
        public async void Get_Ok()
        {
            var mockEventAlertRepository = new Mock<IEventAlertRepository>();
            var mockUnitOfWork = new Mock<IUnitOfWork>();
            var mockRepoRepository = new Mock<IRepoAccountRepository>();
            mockEventAlertRepository.Setup(repo => repo.FindByIdAsync(It.IsAny<int>())).ReturnsAsync(new EventAlert() { Id = 5 });
            mockUnitOfWork.Setup(mock => mock.CompleteAsync()).Returns(Task.CompletedTask);

            EventAlertService eventAlertService = new EventAlertService(mockEventAlertRepository.Object, mockUnitOfWork.Object, mockRepoRepository.Object);

            var res = await eventAlertService.Get(5);
            Assert.NotNull(res);
            Assert.Equal(5, res.Id);
        }

        [Fact]
        public async void Get_Exception()
        {
            var mockEventAlertRepository = new Mock<IEventAlertRepository>();
            var mockUnitOfWork = new Mock<IUnitOfWork>();
            var mockRepoRepository = new Mock<IRepoAccountRepository>();
            mockEventAlertRepository.Setup(repo => repo.FindByIdAsync(It.IsAny<int>())).ThrowsAsync(new Exception("Oops"));
            mockUnitOfWork.Setup(mock => mock.CompleteAsync()).Returns(Task.CompletedTask);

            EventAlertService eventAlertService = new EventAlertService(mockEventAlertRepository.Object, mockUnitOfWork.Object, mockRepoRepository.Object);

            await Assert.ThrowsAsync<ServerErrorException>(async () => await eventAlertService.Get(5));
        }

        [Fact]
        public async void Get_Null_Exception()
        {
            var mockEventAlertRepository = new Mock<IEventAlertRepository>();
            var mockUnitOfWork = new Mock<IUnitOfWork>();
            var mockRepoRepository = new Mock<IRepoAccountRepository>();
            mockEventAlertRepository.Setup(repo => repo.FindByIdAsync(It.IsAny<int>())).Returns(Task.FromResult<EventAlert>(null));
            mockUnitOfWork.Setup(mock => mock.CompleteAsync()).Returns(Task.CompletedTask);

            EventAlertService eventAlertService = new EventAlertService(mockEventAlertRepository.Object, mockUnitOfWork.Object, mockRepoRepository.Object);

            await Assert.ThrowsAsync<NotFoundException>(async () => await eventAlertService.Get(5));
        }

        [Fact]
        public async void Update_Null()
        {
            var mockEventAlertRepository = new Mock<IEventAlertRepository>();
            var mockUnitOfWork = new Mock<IUnitOfWork>();
            var mockRepoRepository = new Mock<IRepoAccountRepository>();

            mockEventAlertRepository.Setup(repo => repo.FindByIdAsync(It.IsAny<int>())).Returns(Task.FromResult<EventAlert>(null));

            var eventAlertService = new EventAlertService(mockEventAlertRepository.Object, mockUnitOfWork.Object, mockRepoRepository.Object);

            var dummyAlert = new EventAlert
            {
                Message = "Message",
                DateMarkedRead = DateTime.Now,
                CreatedBy = "Some Guy"
            };

            var dummyUser = new AppUser
            {
                FirstName = "John",
                LastName = "Doe"
            };

            await Assert.ThrowsAsync<NotFoundException>(async () => await eventAlertService.UpdateAsync(dummyAlert, dummyUser));
        }

        [Fact]
        public async void Update_Exception()
        {
            var mockEventAlertRepository = new Mock<IEventAlertRepository>();
            var mockUnitOfWork = new Mock<IUnitOfWork>();
            var mockRepoRepository = new Mock<IRepoAccountRepository>();

            mockEventAlertRepository.Setup(repo => repo.FindByIdAsync(It.IsAny<int>())).ReturnsAsync(new EventAlert());

            var eventAlertService = new EventAlertService(mockEventAlertRepository.Object, mockUnitOfWork.Object, mockRepoRepository.Object);

            var dummyAlert = new EventAlert
            {
                Message = "Message",
                DateMarkedRead = DateTime.Now,
                CreatedBy = "Some Guy"
            };

            var dummyUser = new AppUser
            {
                FirstName = "John",
                LastName = "Doe"
            };

            mockEventAlertRepository.Setup(repo => repo.Update(It.IsAny<EventAlert>())).Throws(new Exception("oops"));

            await Assert.ThrowsAsync<ServerErrorException>(async () => await eventAlertService.UpdateAsync(dummyAlert, dummyUser));
        }

        [Fact]
        public async void Update_Ok()
        {
            var mockEventAlertRepository = new Mock<IEventAlertRepository>();
            var mockUnitOfWork = new Mock<IUnitOfWork>();
            var mockRepoRepository = new Mock<IRepoAccountRepository>();

            mockEventAlertRepository.Setup(repo => repo.FindByIdAsync(It.IsAny<int>())).ReturnsAsync(new EventAlert());

            var eventAlertService = new EventAlertService(mockEventAlertRepository.Object, mockUnitOfWork.Object, mockRepoRepository.Object);

            var dummyAlert = new EventAlert
            {
                Message = "Message",
                DateMarkedRead = DateTime.Now,
                CreatedBy = "Some Guy"
            };

            var dummyUser = new AppUser
            {
                FirstName = "John",
                LastName = "Doe"
            };

            var result = await eventAlertService.UpdateAsync(dummyAlert, dummyUser);

            Assert.NotNull(result);
            Assert.Equal(dummyAlert.DateMarkedRead, result.DateMarkedRead);
            Assert.Equal("Message", result.Message);
            Assert.Equal("John Doe", result.MarkedReadBy);
            Assert.Null(result.CreatedBy);
        }

        [Fact]
        public async void Update_Existing_Exception()
        {
            var mockEventAlertRepository = new Mock<IEventAlertRepository>();
            var mockUnitOfWork = new Mock<IUnitOfWork>();
            var mockRepoRepository = new Mock<IRepoAccountRepository>();

            mockEventAlertRepository.Setup(repo => repo.FindByIdAsync(It.IsAny<int>())).Throws(new Exception("oops"));

            var eventAlertService = new EventAlertService(mockEventAlertRepository.Object, mockUnitOfWork.Object, mockRepoRepository.Object);

            var dummyAlert = new EventAlert
            {
                Message = "Message",
                DateMarkedRead = DateTime.Now,
                CreatedBy = "Some Guy"
            };

            var dummyUser = new AppUser
            {
                FirstName = "John",
                LastName = "Doe"
            };

            await Assert.ThrowsAsync<ServerErrorException>(async () => await eventAlertService.UpdateAsync(dummyAlert, dummyUser));
        }


        [Fact]
        public async void Duplicate_Add_Exception()
        {
            RepoAccount account = new RepoAccount()
            {
                RepoId = 100,
                Status = "RTC Letter Not Found"
            };
            EventAlert eventAlert = new EventAlert()
            {
                Id = 5,
                RepoId = 100
            };
            // arrange
            var mockEventAlertRepository = new Mock<IEventAlertRepository>();
            var mockUnitOfWork = new Mock<IUnitOfWork>();
            var mockRepoRepository = new Mock<IRepoAccountRepository>();

            mockEventAlertRepository.Setup(repo => repo.AddAsync(It.Is<EventAlert>(param => param.Id == 5))).ThrowsAsync(new DuplicateResourceException("EventAlert"));
            mockRepoRepository.Setup(repo => repo.FindByIdAsync(It.Is<Int32>(param => param == 100))).Returns(Task.FromResult(account));
            var eventAlertService = new EventAlertService(mockEventAlertRepository.Object, mockUnitOfWork.Object, mockRepoRepository.Object);

            // act / assert
            try
            {
                var result = await eventAlertService.SaveAsync(eventAlert);
                Assert.True(false, "An exception should have been thrown.");
            }
            catch (DuplicateResourceException ex)
            {
                Assert.Equal("Duplicate Resources of type EventAlert were found.", ex.Message);
            }
            catch (Exception)
            {
                Assert.True(false, "An exception other than DuplicateResourceException was thrown.");
            }
        }

        [Fact]
        public async void DeleteAsync_Ok()
        {
            var dummyAlert = new EventAlert
            {
                Message = "Message",
                DateMarkedRead = DateTime.Now,
                CreatedBy = "Some Guy"
            };


            var mockEventAlertRepository = new Mock<IEventAlertRepository>();
            var mockUnitOfWork = new Mock<IUnitOfWork>();
            var mockRepoRepository = new Mock<IRepoAccountRepository>();

            mockEventAlertRepository.Setup(repo => repo.FindByIdAsync(It.IsAny<int>())).ReturnsAsync(dummyAlert);
            mockUnitOfWork.Setup(mock => mock.CompleteAsync()).Returns(Task.CompletedTask);
            mockEventAlertRepository.Setup(repo => repo.Remove(It.Is<EventAlert>(param => param.Message == "message")));

            EventAlertService eventAlertService = new EventAlertService(mockEventAlertRepository.Object, mockUnitOfWork.Object, mockRepoRepository.Object);

            var res = await eventAlertService.DeleteAsync(5);
        }

        [Fact]
        public async void DeleteAsync_Null()
        {
            var dummyAlert = new EventAlert
            {
                Message = "Message",
                DateMarkedRead = DateTime.Now,
                CreatedBy = "Some Guy"
            };


            var mockEventAlertRepository = new Mock<IEventAlertRepository>();
            var mockUnitOfWork = new Mock<IUnitOfWork>();
            var mockRepoRepository = new Mock<IRepoAccountRepository>();

            mockEventAlertRepository.Setup(repo => repo.FindByIdAsync(It.IsAny<int>())).Returns(Task.FromResult<EventAlert>(null));
            mockUnitOfWork.Setup(mock => mock.CompleteAsync()).Returns(Task.CompletedTask);
            mockEventAlertRepository.Setup(repo => repo.Remove(It.Is<EventAlert>(param => param.Message == "message")));

            EventAlertService eventAlertService = new EventAlertService(mockEventAlertRepository.Object, mockUnitOfWork.Object, mockRepoRepository.Object);

            await Assert.ThrowsAsync<NotFoundException>(async () => await eventAlertService.DeleteAsync(5));
        }

        [Fact]
        public async void DeleteAsync_Remove_Exception()
        {
            var dummyAlert = new EventAlert
            {
                Message = "Message",
                DateMarkedRead = DateTime.Now,
                CreatedBy = "Some Guy"
            };

            var mockEventAlertRepository = new Mock<IEventAlertRepository>();
            var mockUnitOfWork = new Mock<IUnitOfWork>();
            var mockRepoRepository = new Mock<IRepoAccountRepository>();

            mockEventAlertRepository.Setup(repo => repo.FindByIdAsync(It.IsAny<int>())).ReturnsAsync(dummyAlert);
            mockUnitOfWork.Setup(mock => mock.CompleteAsync()).Returns(Task.CompletedTask);
            mockEventAlertRepository.Setup(repo => repo.Remove(It.Is<EventAlert>(param => param.Message == "Message"))).Throws(new Exception("oops"));

            EventAlertService eventAlertService = new EventAlertService(mockEventAlertRepository.Object, mockUnitOfWork.Object, mockRepoRepository.Object);

            await Assert.ThrowsAsync<ServerErrorException>(async () =>  await eventAlertService.DeleteAsync(5));
        }

        [Fact]
        public async void DeleteAsync_Existing_Exception()
        {
            var dummyAlert = new EventAlert
            {
                Message = "Message",
                DateMarkedRead = DateTime.Now,
                CreatedBy = "Some Guy"
            };


            var mockEventAlertRepository = new Mock<IEventAlertRepository>();
            var mockUnitOfWork = new Mock<IUnitOfWork>();
            var mockRepoRepository = new Mock<IRepoAccountRepository>();

            mockEventAlertRepository.Setup(repo => repo.FindByIdAsync(It.IsAny<int>())).Throws(new Exception("oops"));
            mockUnitOfWork.Setup(mock => mock.CompleteAsync()).Returns(Task.CompletedTask);
            mockEventAlertRepository.Setup(repo => repo.Remove(It.Is<EventAlert>(param => param.Message == "message")));

            EventAlertService eventAlertService = new EventAlertService(mockEventAlertRepository.Object, mockUnitOfWork.Object, mockRepoRepository.Object);

            await Assert.ThrowsAsync<ServerErrorException>(async () => await eventAlertService.DeleteAsync(5));
        }

        [Fact]
        public async void MarkAllAsRead_OK()
        {
            var alertList = new List<EventAlert> {
                new EventAlert
                {
                    Id = 1,
                    Message = "Message",
                    CreatedBy = "Some Guy",
                    AccountNo = "123-04566"
                },
                new EventAlert
                {
                    Id = 2,
                    Message = "Message",
                    CreatedBy = "Some Guy",
                    AccountNo = "123-04566"
                },
                new EventAlert
                {
                    Id = 3,
                    Message = "Message",
                    CreatedBy = "Some Guy",
                    AccountNo = "123-04566"
                }
            };

            var mockEventAlertRepository = new Mock<IEventAlertRepository>();
            var mockUnitOfWork = new Mock<IUnitOfWork>();
            var mockRepoRepository = new Mock<IRepoAccountRepository>();

            mockEventAlertRepository.Setup(repo => repo.ListUnreadByAccountNoAsync(It.IsAny<string>())).ReturnsAsync(alertList);
            

            EventAlertService eventAlertService = new EventAlertService(mockEventAlertRepository.Object, mockUnitOfWork.Object, mockRepoRepository.Object);

            var result = await eventAlertService.MarkAllAsRead("123-04566");

            mockUnitOfWork.Verify(m => m.CompleteAsync(), Times.Once());
            mockEventAlertRepository.Verify(m => m.Update(It.IsAny<EventAlert>()), Times.Exactly(3));
            
            Assert.NotNull(result);
            Assert.Equal(3, result.Count());
            Assert.Equal(alertList, result);
        }

        [Fact]
        public async void MarkAllAsRead_NotFoundException()
        {
            var mockEventAlertRepository = new Mock<IEventAlertRepository>();
            var mockUnitOfWork = new Mock<IUnitOfWork>();
            var mockRepoRepository = new Mock<IRepoAccountRepository>();

            mockEventAlertRepository.Setup(repo => repo.ListUnreadByAccountNoAsync(It.IsAny<string>())).Returns(Task.FromResult<IEnumerable<EventAlert>>(null));


            EventAlertService eventAlertService = new EventAlertService(mockEventAlertRepository.Object, mockUnitOfWork.Object, mockRepoRepository.Object);

            await Assert.ThrowsAsync<NotFoundException>(async () => await eventAlertService.MarkAllAsRead("123-04566"));

            mockUnitOfWork.Verify(m => m.CompleteAsync(), Times.Never());
            mockEventAlertRepository.Verify(m => m.Update(It.IsAny<EventAlert>()), Times.Never);
        }

        [Fact]
        public async void MarkAllAsRead_Existing_Exception()
        {
            var mockEventAlertRepository = new Mock<IEventAlertRepository>();
            var mockUnitOfWork = new Mock<IUnitOfWork>();
            var mockRepoRepository = new Mock<IRepoAccountRepository>();

            mockEventAlertRepository.Setup(repo => repo.ListUnreadByAccountNoAsync(It.IsAny<string>())).ThrowsAsync(new Exception("oops"));


            EventAlertService eventAlertService = new EventAlertService(mockEventAlertRepository.Object, mockUnitOfWork.Object, mockRepoRepository.Object);

            await Assert.ThrowsAsync<ServerErrorException>(async () => await eventAlertService.MarkAllAsRead("123-04566"));

            mockUnitOfWork.Verify(m => m.CompleteAsync(), Times.Never());
            mockEventAlertRepository.Verify(m => m.Update(It.IsAny<EventAlert>()), Times.Never);
        }

        [Fact]
        public async void MarkAllAsRead_Update_Exception()
        {
            var alertList = new List<EventAlert> {
                new EventAlert
                {
                    Id = 1,
                    Message = "Message",
                    CreatedBy = "Some Guy",
                    AccountNo = "123-04566"
                },
                new EventAlert
                {
                    Id = 2,
                    Message = "Message",
                    CreatedBy = "Some Guy",
                    AccountNo = "123-04566"
                },
                new EventAlert
                {
                    Id = 3,
                    Message = "Message",
                    CreatedBy = "Some Guy",
                    AccountNo = "123-04566"
                }
            };

            var mockEventAlertRepository = new Mock<IEventAlertRepository>();
            var mockUnitOfWork = new Mock<IUnitOfWork>();
            var mockRepoRepository = new Mock<IRepoAccountRepository>();

            mockEventAlertRepository.Setup(repo => repo.ListUnreadByAccountNoAsync(It.IsAny<string>())).ReturnsAsync(alertList);
            mockEventAlertRepository.Setup(m => m.Update(It.IsAny<EventAlert>())).Throws(new Exception("oops"));


            EventAlertService eventAlertService = new EventAlertService(mockEventAlertRepository.Object, mockUnitOfWork.Object, mockRepoRepository.Object);

            await Assert.ThrowsAsync<ServerErrorException>(async () => await eventAlertService.MarkAllAsRead("123-04566"));

            mockUnitOfWork.Verify(m => m.CompleteAsync(), Times.Never());
            mockEventAlertRepository.Verify(m => m.Update(It.IsAny<EventAlert>()), Times.Once);
        }

        [Fact]
        public async void MarkAllAsRead_Update_Exception_On_2nd()
        {
            var count = 0;
            var alertList = new List<EventAlert> {
                new EventAlert
                {
                    Id = 1,
                    Message = "Message",
                    CreatedBy = "Some Guy",
                    AccountNo = "123-04566"
                },
                new EventAlert
                {
                    Id = 2,
                    Message = "Message",
                    CreatedBy = "Some Guy",
                    AccountNo = "123-04566"
                },
                new EventAlert
                {
                    Id = 3,
                    Message = "Message",
                    CreatedBy = "Some Guy",
                    AccountNo = "123-04566"
                }
            };

            var mockEventAlertRepository = new Mock<IEventAlertRepository>();
            var mockUnitOfWork = new Mock<IUnitOfWork>();
            var mockRepoRepository = new Mock<IRepoAccountRepository>();

            mockEventAlertRepository.Setup(repo => repo.ListUnreadByAccountNoAsync(It.IsAny<string>())).ReturnsAsync(alertList);
            mockEventAlertRepository.Setup(m => m.Update(It.IsAny<EventAlert>())).Callback(() =>
            {
                count++;
                if (count == 2)
                {
                    throw new Exception("oops");
                }
            });


            EventAlertService eventAlertService = new EventAlertService(mockEventAlertRepository.Object, mockUnitOfWork.Object, mockRepoRepository.Object);

            await Assert.ThrowsAsync<ServerErrorException>(async () => await eventAlertService.MarkAllAsRead("123-04566"));

            mockUnitOfWork.Verify(m => m.CompleteAsync(), Times.Never());
            mockEventAlertRepository.Verify(m => m.Update(It.IsAny<EventAlert>()), Times.Exactly(2));
        }



    }
}